@loaders.gl/images 3.1.0-alpha.2 → 4.0.0-alpha.3

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

@@ -1,4 +1,4 @@
-import { assert } from '../utils/assert';
+import { assert } from '@loaders.gl/loader-utils';
 import { isImageTypeSupported, getDefaultImageType } from '../category-api/image-type';
 import { getImageData } from '../category-api/parsed-image-api';
 import parseToImage from './parse-to-image';

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/parsers/parse-image.ts"],"names":["assert","isImageTypeSupported","getDefaultImageType","getImageData","parseToImage","parseToImageBitmap","parseToNodeImage","parseImage","arrayBuffer","options","context","imageOptions","image","imageType","type","url","loadType","getLoadableImageType"],"mappings":"AAAA,SAAQA,MAAR,QAAqB,iBAArB;AACA,SAAQC,oBAAR,EAA8BC,mBAA9B,QAAwD,4BAAxD;AACA,SAAQC,YAAR,QAA2B,kCAA3B;AACA,OAAOC,YAAP,MAAyB,kBAAzB;AACA,OAAOC,kBAAP,MAA+B,yBAA/B;AACA,OAAOC,gBAAP,MAA6B,uBAA7B;AAIA,eAAe,eAAeC,UAAf,CAA0BC,WAA1B,EAAuCC,OAAvC,EAAgDC,OAAhD,EAAyD;AACtED,EAAAA,OAAO,GAAGA,OAAO,IAAI,EAArB;AACA,QAAME,YAAY,GAAGF,OAAO,CAACG,KAAR,IAAiB,EAAtC;AAGA,QAAMC,SAAS,GAAGF,YAAY,CAACG,IAAb,IAAqB,MAAvC;AAEA,QAAM;AAACC,IAAAA;AAAD,MAAQL,OAAO,IAAI,EAAzB;AAGA,QAAMM,QAAQ,GAAGC,oBAAoB,CAACJ,SAAD,CAArC;AAEA,MAAID,KAAJ;;AACA,UAAQI,QAAR;AACE,SAAK,aAAL;AACEJ,MAAAA,KAAK,GAAG,MAAMP,kBAAkB,CAACG,WAAD,EAAcC,OAAd,EAAuBM,GAAvB,CAAhC;AACA;;AACF,SAAK,OAAL;AACEH,MAAAA,KAAK,GAAG,MAAMR,YAAY,CAACI,WAAD,EAAcC,OAAd,EAAuBM,GAAvB,CAA1B;AACA;;AACF,SAAK,MAAL;AAEEH,MAAAA,KAAK,GAAG,MAAMN,gBAAgB,CAACE,WAAD,EAAcC,OAAd,CAA9B;AACA;;AACF;AACET,MAAAA,MAAM,CAAC,KAAD,CAAN;AAZJ;;AAgBA,MAAIa,SAAS,KAAK,MAAlB,EAA0B;AACxBD,IAAAA,KAAK,GAAGT,YAAY,CAACS,KAAD,CAApB;AACD;;AAED,SAAOA,KAAP;AACD;;AAGD,SAASK,oBAAT,CAA8BH,IAA9B,EAAoC;AAClC,UAAQA,IAAR;AACE,SAAK,MAAL;AACA,SAAK,MAAL;AAGE,aAAOZ,mBAAmB,EAA1B;;AACF;AAEED,MAAAA,oBAAoB,CAACa,IAAD,CAApB;AACA,aAAOA,IAAP;AATJ;AAWD","sourcesContent":["import {assert} from '../utils/assert';\nimport {isImageTypeSupported, getDefaultImageType} from '../category-api/image-type';\nimport {getImageData} from '../category-api/parsed-image-api';\nimport parseToImage from './parse-to-image';\nimport parseToImageBitmap from './parse-to-image-bitmap';\nimport parseToNodeImage from './parse-to-node-image';\n\n// Parse to platform defined image type (data on node, ImageBitmap or HTMLImage on browser)\n// eslint-disable-next-line complexity\nexport default async function parseImage(arrayBuffer, options, context) {\n  options = options || {};\n  const imageOptions = options.image || {};\n\n  // The user can request a specific output format via `options.image.type`\n  const imageType = imageOptions.type || 'auto';\n\n  const {url} = context || {};\n\n  // Note: For options.image.type === `data`, we may still need to load as `image` or `imagebitmap`\n  const loadType = getLoadableImageType(imageType);\n\n  let image;\n  switch (loadType) {\n    case 'imagebitmap':\n      image = await parseToImageBitmap(arrayBuffer, options, url);\n      break;\n    case 'image':\n      image = await parseToImage(arrayBuffer, options, url);\n      break;\n    case 'data':\n      // Node.js loads imagedata directly\n      image = await parseToNodeImage(arrayBuffer, options);\n      break;\n    default:\n      assert(false);\n  }\n\n  // Browser: if options.image.type === 'data', we can now extract data from the loaded image\n  if (imageType === 'data') {\n    image = getImageData(image);\n  }\n\n  return image;\n}\n\n// Get a loadable image type from image type\nfunction getLoadableImageType(type) {\n  switch (type) {\n    case 'auto':\n    case 'data':\n      // Browser: For image data we need still need to load using an image format\n      // Node: the default image type is `data`.\n      return getDefaultImageType();\n    default:\n      // Throw an error if not supported\n      isImageTypeSupported(type);\n      return type;\n  }\n}\n"],"file":"parse-image.js"}
+{"version":3,"sources":["../../../src/lib/parsers/parse-image.ts"],"names":["assert","isImageTypeSupported","getDefaultImageType","getImageData","parseToImage","parseToImageBitmap","parseToNodeImage","parseImage","arrayBuffer","options","context","imageOptions","image","imageType","type","url","loadType","getLoadableImageType"],"mappings":"AACA,SAAQA,MAAR,QAAqB,0BAArB;AAGA,SAAQC,oBAAR,EAA8BC,mBAA9B,QAAwD,4BAAxD;AACA,SAAQC,YAAR,QAA2B,kCAA3B;AACA,OAAOC,YAAP,MAAyB,kBAAzB;AACA,OAAOC,kBAAP,MAA+B,yBAA/B;AACA,OAAOC,gBAAP,MAA6B,uBAA7B;AAIA,eAAe,eAAeC,UAAf,CACbC,WADa,EAEbC,OAFa,EAGbC,OAHa,EAIO;AACpBD,EAAAA,OAAO,GAAGA,OAAO,IAAI,EAArB;AACA,QAAME,YAAY,GAAGF,OAAO,CAACG,KAAR,IAAiB,EAAtC;AAGA,QAAMC,SAAS,GAAGF,YAAY,CAACG,IAAb,IAAqB,MAAvC;AAEA,QAAM;AAACC,IAAAA;AAAD,MAAQL,OAAO,IAAI,EAAzB;AAGA,QAAMM,QAAQ,GAAGC,oBAAoB,CAACJ,SAAD,CAArC;AAEA,MAAID,KAAJ;;AACA,UAAQI,QAAR;AACE,SAAK,aAAL;AACEJ,MAAAA,KAAK,GAAG,MAAMP,kBAAkB,CAACG,WAAD,EAAcC,OAAd,EAAuBM,GAAvB,CAAhC;AACA;;AACF,SAAK,OAAL;AACEH,MAAAA,KAAK,GAAG,MAAMR,YAAY,CAACI,WAAD,EAAcC,OAAd,EAAuBM,GAAvB,CAA1B;AACA;;AACF,SAAK,MAAL;AAEEH,MAAAA,KAAK,GAAG,MAAMN,gBAAgB,CAACE,WAAD,EAAcC,OAAd,CAA9B;AACA;;AACF;AACET,MAAAA,MAAM,CAAC,KAAD,CAAN;AAZJ;;AAgBA,MAAIa,SAAS,KAAK,MAAlB,EAA0B;AACxBD,IAAAA,KAAK,GAAGT,YAAY,CAACS,KAAD,CAApB;AACD;;AAED,SAAOA,KAAP;AACD;;AAGD,SAASK,oBAAT,CAA8BH,IAA9B,EAAoC;AAClC,UAAQA,IAAR;AACE,SAAK,MAAL;AACA,SAAK,MAAL;AAGE,aAAOZ,mBAAmB,EAA1B;;AACF;AAEED,MAAAA,oBAAoB,CAACa,IAAD,CAApB;AACA,aAAOA,IAAP;AATJ;AAWD","sourcesContent":["import type {LoaderContext} from '@loaders.gl/loader-utils';\nimport {assert} from '@loaders.gl/loader-utils';\nimport type {ImageType} from '../../types';\nimport type {ImageLoaderOptions} from '../../image-loader';\nimport {isImageTypeSupported, getDefaultImageType} from '../category-api/image-type';\nimport {getImageData} from '../category-api/parsed-image-api';\nimport parseToImage from './parse-to-image';\nimport parseToImageBitmap from './parse-to-image-bitmap';\nimport parseToNodeImage from './parse-to-node-image';\n\n// Parse to platform defined image type (data on node, ImageBitmap or HTMLImage on browser)\n// eslint-disable-next-line complexity\nexport default async function parseImage(\n  arrayBuffer: ArrayBuffer,\n  options?: ImageLoaderOptions,\n  context?: LoaderContext\n): Promise<ImageType> {\n  options = options || {};\n  const imageOptions = options.image || {};\n\n  // The user can request a specific output format via `options.image.type`\n  const imageType = imageOptions.type || 'auto';\n\n  const {url} = context || {};\n\n  // Note: For options.image.type === `data`, we may still need to load as `image` or `imagebitmap`\n  const loadType = getLoadableImageType(imageType);\n\n  let image;\n  switch (loadType) {\n    case 'imagebitmap':\n      image = await parseToImageBitmap(arrayBuffer, options, url);\n      break;\n    case 'image':\n      image = await parseToImage(arrayBuffer, options, url);\n      break;\n    case 'data':\n      // Node.js loads imagedata directly\n      image = await parseToNodeImage(arrayBuffer, options);\n      break;\n    default:\n      assert(false);\n  }\n\n  // Browser: if options.image.type === 'data', we can now extract data from the loaded image\n  if (imageType === 'data') {\n    image = getImageData(image);\n  }\n\n  return image;\n}\n\n// Get a loadable image type from image type\nfunction getLoadableImageType(type) {\n  switch (type) {\n    case 'auto':\n    case 'data':\n      // Browser: For image data we need still need to load using an image format\n      // Node: the default image type is `data`.\n      return getDefaultImageType();\n    default:\n      // Throw an error if not supported\n      isImageTypeSupported(type);\n      return type;\n  }\n}\n"],"file":"parse-image.js"}

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/parsers/parse-to-image-bitmap.ts"],"names":["isSVG","getBlob","parseToImage","EMPTY_OBJECT","imagebitmapOptionsSupported","parseToImageBitmap","arrayBuffer","options","url","blob","image","imagebitmapOptions","imagebitmap","safeCreateImageBitmap","isEmptyObject","createImageBitmap","error","console","warn","object","key"],"mappings":"AAAA,SAAQA,KAAR,EAAeC,OAAf,QAA6B,aAA7B;AACA,OAAOC,YAAP,MAAyB,kBAAzB;AAEA,MAAMC,YAAY,GAAG,EAArB;AAEA,IAAIC,2BAA2B,GAAG,IAAlC;AASA,eAAe,eAAeC,kBAAf,CAAkCC,WAAlC,EAA+CC,OAA/C,EAAwDC,GAAxD,EAA6D;AAC1E,MAAIC,IAAJ;;AAGA,MAAIT,KAAK,CAACQ,GAAD,CAAT,EAAgB;AAEd,UAAME,KAAK,GAAG,MAAMR,YAAY,CAACI,WAAD,EAAcC,OAAd,EAAuBC,GAAvB,CAAhC;AACAC,IAAAA,IAAI,GAAGC,KAAP;AACD,GAJD,MAIO;AAELD,IAAAA,IAAI,GAAGR,OAAO,CAACK,WAAD,EAAcE,GAAd,CAAd;AACD;;AAED,QAAMG,kBAAkB,GAAGJ,OAAO,IAAIA,OAAO,CAACK,WAA9C;AAEA,SAAO,MAAMC,qBAAqB,CAACJ,IAAD,EAAOE,kBAAP,CAAlC;AACD;;AAQD,eAAeE,qBAAf,CAAqCJ,IAArC,EAA2CE,kBAAkB,GAAG,IAAhE,EAAsE;AACpE,MAAIG,aAAa,CAACH,kBAAD,CAAb,IAAqC,CAACP,2BAA1C,EAAuE;AACrEO,IAAAA,kBAAkB,GAAG,IAArB;AACD;;AAED,MAAIA,kBAAJ,EAAwB;AACtB,QAAI;AAEF,aAAO,MAAMI,iBAAiB,CAACN,IAAD,EAAOE,kBAAP,CAA9B;AACD,KAHD,CAGE,OAAOK,KAAP,EAAc;AACdC,MAAAA,OAAO,CAACC,IAAR,CAAaF,KAAb;AACAZ,MAAAA,2BAA2B,GAAG,KAA9B;AACD;AACF;;AAED,SAAO,MAAMW,iBAAiB,CAACN,IAAD,CAA9B;AACD;;AAED,SAASK,aAAT,CAAuBK,MAAvB,EAA+B;AAE7B,OAAK,MAAMC,GAAX,IAAkBD,MAAM,IAAIhB,YAA5B,EAA0C;AACxC,WAAO,KAAP;AACD;;AACD,SAAO,IAAP;AACD","sourcesContent":["import {isSVG, getBlob} from './svg-utils';\nimport parseToImage from './parse-to-image';\n\nconst EMPTY_OBJECT = {};\n\nlet imagebitmapOptionsSupported = true;\n\n/**\n * Asynchronously parses an array buffer into an ImageBitmap - this contains the decoded data\n * ImageBitmaps are supported on worker threads, but not supported on Edge, IE11 and Safari\n * https://developer.mozilla.org/en-US/docs/Web/API/ImageBitmap#Browser_compatibility\n *\n * TODO - createImageBitmap supports source rect (5 param overload), pass through?\n */\nexport default async function parseToImageBitmap(arrayBuffer, options, url) {\n  let blob;\n\n  // Cannot parse SVG directly to ImageBitmap, parse to Image first\n  if (isSVG(url)) {\n    // Note: this only works on main thread\n    const image = await parseToImage(arrayBuffer, options, url);\n    blob = image;\n  } else {\n    // Create blob from the array buffer\n    blob = getBlob(arrayBuffer, url);\n  }\n\n  const imagebitmapOptions = options && options.imagebitmap;\n\n  return await safeCreateImageBitmap(blob, imagebitmapOptions);\n}\n\n/**\n * Safely creates an imageBitmap with options\n * *\n * Firefox crashes if imagebitmapOptions is supplied\n * Avoid supplying if not provided or supported, remember if not supported\n */\nasync function safeCreateImageBitmap(blob, imagebitmapOptions = null) {\n  if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) {\n    imagebitmapOptions = null;\n  }\n\n  if (imagebitmapOptions) {\n    try {\n      // @ts-ignore Options\n      return await createImageBitmap(blob, imagebitmapOptions);\n    } catch (error) {\n      console.warn(error); // eslint-disable-line\n      imagebitmapOptionsSupported = false;\n    }\n  }\n\n  return await createImageBitmap(blob);\n}\n\nfunction isEmptyObject(object) {\n  // @ts-ignore\n  for (const key in object || EMPTY_OBJECT) {\n    return false;\n  }\n  return true;\n}\n"],"file":"parse-to-image-bitmap.js"}
+{"version":3,"sources":["../../../src/lib/parsers/parse-to-image-bitmap.ts"],"names":["isSVG","getBlob","parseToImage","EMPTY_OBJECT","imagebitmapOptionsSupported","parseToImageBitmap","arrayBuffer","options","url","blob","image","imagebitmapOptions","imagebitmap","safeCreateImageBitmap","isEmptyObject","createImageBitmap","error","console","warn","object","key"],"mappings":"AACA,SAAQA,KAAR,EAAeC,OAAf,QAA6B,aAA7B;AACA,OAAOC,YAAP,MAAyB,kBAAzB;AAEA,MAAMC,YAAY,GAAG,EAArB;AAEA,IAAIC,2BAA2B,GAAG,IAAlC;AASA,eAAe,eAAeC,kBAAf,CACbC,WADa,EAEbC,OAFa,EAGbC,GAHa,EAIS;AACtB,MAAIC,IAAJ;;AAGA,MAAIT,KAAK,CAACQ,GAAD,CAAT,EAAgB;AAEd,UAAME,KAAK,GAAG,MAAMR,YAAY,CAACI,WAAD,EAAcC,OAAd,EAAuBC,GAAvB,CAAhC;AACAC,IAAAA,IAAI,GAAGC,KAAP;AACD,GAJD,MAIO;AAELD,IAAAA,IAAI,GAAGR,OAAO,CAACK,WAAD,EAAcE,GAAd,CAAd;AACD;;AAED,QAAMG,kBAAkB,GAAGJ,OAAO,IAAIA,OAAO,CAACK,WAA9C;AAEA,SAAO,MAAMC,qBAAqB,CAACJ,IAAD,EAAOE,kBAAP,CAAlC;AACD;;AAQD,eAAeE,qBAAf,CACEJ,IADF,EAEEE,kBAA6C,GAAG,IAFlD,EAGwB;AACtB,MAAIG,aAAa,CAACH,kBAAD,CAAb,IAAqC,CAACP,2BAA1C,EAAuE;AACrEO,IAAAA,kBAAkB,GAAG,IAArB;AACD;;AAED,MAAIA,kBAAJ,EAAwB;AACtB,QAAI;AAEF,aAAO,MAAMI,iBAAiB,CAACN,IAAD,EAAOE,kBAAP,CAA9B;AACD,KAHD,CAGE,OAAOK,KAAP,EAAc;AACdC,MAAAA,OAAO,CAACC,IAAR,CAAaF,KAAb;AACAZ,MAAAA,2BAA2B,GAAG,KAA9B;AACD;AACF;;AAED,SAAO,MAAMW,iBAAiB,CAACN,IAAD,CAA9B;AACD;;AAED,SAASK,aAAT,CAAuBK,MAAvB,EAA+B;AAE7B,OAAK,MAAMC,GAAX,IAAkBD,MAAM,IAAIhB,YAA5B,EAA0C;AACxC,WAAO,KAAP;AACD;;AACD,SAAO,IAAP;AACD","sourcesContent":["import type {ImageLoaderOptions} from '../../image-loader';\nimport {isSVG, getBlob} from './svg-utils';\nimport parseToImage from './parse-to-image';\n\nconst EMPTY_OBJECT = {};\n\nlet imagebitmapOptionsSupported = true;\n\n/**\n * Asynchronously parses an array buffer into an ImageBitmap - this contains the decoded data\n * ImageBitmaps are supported on worker threads, but not supported on Edge, IE11 and Safari\n * https://developer.mozilla.org/en-US/docs/Web/API/ImageBitmap#Browser_compatibility\n *\n * TODO - createImageBitmap supports source rect (5 param overload), pass through?\n */\nexport default async function parseToImageBitmap(\n  arrayBuffer: ArrayBuffer,\n  options: ImageLoaderOptions,\n  url?: string\n): Promise<ImageBitmap> {\n  let blob;\n\n  // Cannot parse SVG directly to ImageBitmap, parse to Image first\n  if (isSVG(url)) {\n    // Note: this only works on main thread\n    const image = await parseToImage(arrayBuffer, options, url);\n    blob = image;\n  } else {\n    // Create blob from the array buffer\n    blob = getBlob(arrayBuffer, url);\n  }\n\n  const imagebitmapOptions = options && options.imagebitmap;\n\n  return await safeCreateImageBitmap(blob, imagebitmapOptions);\n}\n\n/**\n * Safely creates an imageBitmap with options\n * *\n * Firefox crashes if imagebitmapOptions is supplied\n * Avoid supplying if not provided or supported, remember if not supported\n */\nasync function safeCreateImageBitmap(\n  blob: Blob,\n  imagebitmapOptions: ImageBitmapOptions | null = null\n): Promise<ImageBitmap> {\n  if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) {\n    imagebitmapOptions = null;\n  }\n\n  if (imagebitmapOptions) {\n    try {\n      // @ts-ignore Options\n      return await createImageBitmap(blob, imagebitmapOptions);\n    } catch (error) {\n      console.warn(error); // eslint-disable-line\n      imagebitmapOptionsSupported = false;\n    }\n  }\n\n  return await createImageBitmap(blob);\n}\n\nfunction isEmptyObject(object) {\n  // @ts-ignore\n  for (const key in object || EMPTY_OBJECT) {\n    return false;\n  }\n  return true;\n}\n"],"file":"parse-to-image-bitmap.js"}

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

@@ -25,7 +25,7 @@ export async function loadToImage(url, options) {
     try {
       image.onload = () => resolve(image);
 
-      image.onerror = err => reject(new Error(`Could not load image ${url}: ${err}`));
+      image.onerror = err => reject(new Error("Could not load image ".concat(url, ": ").concat(err)));
     } catch (error) {
       reject(error);
     }

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/parsers/parse-to-image.ts"],"names":["getBlobOrSVGDataUrl","parseToImage","arrayBuffer","options","url","blobOrDataUrl","URL","self","webkitURL","objectUrl","createObjectURL","loadToImage","revokeObjectURL","image","Image","src","decode","Promise","resolve","reject","onload","onerror","err","Error","error"],"mappings":"AAAA,SAAQA,mBAAR,QAAkC,aAAlC;AAGA,eAAe,eAAeC,YAAf,CAA4BC,WAA5B,EAAyCC,OAAzC,EAAkDC,GAAlD,EAAuD;AAKpE,QAAMC,aAAa,GAAGL,mBAAmB,CAACE,WAAD,EAAcE,GAAd,CAAzC;AACA,QAAME,GAAG,GAAGC,IAAI,CAACD,GAAL,IAAYC,IAAI,CAACC,SAA7B;AACA,QAAMC,SAAS,GAAG,OAAOJ,aAAP,KAAyB,QAAzB,IAAqCC,GAAG,CAACI,eAAJ,CAAoBL,aAApB,CAAvD;;AACA,MAAI;AACF,WAAO,MAAMM,WAAW,CAACF,SAAS,IAAIJ,aAAd,EAA6BF,OAA7B,CAAxB;AACD,GAFD,SAEU;AACR,QAAIM,SAAJ,EAAe;AACbH,MAAAA,GAAG,CAACM,eAAJ,CAAoBH,SAApB;AACD;AACF;AACF;AAED,OAAO,eAAeE,WAAf,CAA2BP,GAA3B,EAAgCD,OAAhC,EAAyC;AAC9C,QAAMU,KAAK,GAAG,IAAIC,KAAJ,EAAd;AACAD,EAAAA,KAAK,CAACE,GAAN,GAAYX,GAAZ;;AASA,MAAID,OAAO,CAACU,KAAR,IAAiBV,OAAO,CAACU,KAAR,CAAcG,MAA/B,IAAyCH,KAAK,CAACG,MAAnD,EAA2D;AACzD,UAAMH,KAAK,CAACG,MAAN,EAAN;AACA,WAAOH,KAAP;AACD;;AAGD,SAAO,MAAM,IAAII,OAAJ,CAAY,CAACC,OAAD,EAAUC,MAAV,KAAqB;AAC5C,QAAI;AACFN,MAAAA,KAAK,CAACO,MAAN,GAAe,MAAMF,OAAO,CAACL,KAAD,CAA5B;;AACAA,MAAAA,KAAK,CAACQ,OAAN,GAAiBC,GAAD,IAASH,MAAM,CAAC,IAAII,KAAJ,CAAW,wBAAuBnB,GAAI,KAAIkB,GAAI,EAA9C,CAAD,CAA/B;AACD,KAHD,CAGE,OAAOE,KAAP,EAAc;AACdL,MAAAA,MAAM,CAACK,KAAD,CAAN;AACD;AACF,GAPY,CAAb;AAQD","sourcesContent":["import {getBlobOrSVGDataUrl} from './svg-utils';\n\n// Parses html image from array buffer\nexport default async function parseToImage(arrayBuffer, options, url) {\n  // Note: image parsing requires conversion to Blob (for createObjectURL).\n  // Potentially inefficient for not using `response.blob()` (and for File / Blob inputs)...\n  // But presumably not worth adding 'blob' flag to loader objects?\n\n  const blobOrDataUrl = getBlobOrSVGDataUrl(arrayBuffer, url);\n  const URL = self.URL || self.webkitURL;\n  const objectUrl = typeof blobOrDataUrl !== 'string' && URL.createObjectURL(blobOrDataUrl);\n  try {\n    return await loadToImage(objectUrl || blobOrDataUrl, options);\n  } finally {\n    if (objectUrl) {\n      URL.revokeObjectURL(objectUrl);\n    }\n  }\n}\n\nexport async function loadToImage(url, options) {\n  const image = new Image();\n  image.src = url;\n\n  // The `image.onload()` callback does not guarantee that the image has been decoded\n  // so a main thread \"freeze\" can be incurred when using the image for the first time.\n  // `Image.decode()` returns a promise that completes when image is decoded.\n\n  // https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement/decode\n  // Note: When calling `img.decode()`, we do not need to wait for `img.onload()`\n  // Note: `HTMLImageElement.decode()` is not available in Edge and IE11\n  if (options.image && options.image.decode && image.decode) {\n    await image.decode();\n    return image;\n  }\n\n  // Create a promise that tracks onload/onerror callbacks\n  return await new Promise((resolve, reject) => {\n    try {\n      image.onload = () => resolve(image);\n      image.onerror = (err) => reject(new Error(`Could not load image ${url}: ${err}`));\n    } catch (error) {\n      reject(error);\n    }\n  });\n}\n"],"file":"parse-to-image.js"}
+{"version":3,"sources":["../../../src/lib/parsers/parse-to-image.ts"],"names":["getBlobOrSVGDataUrl","parseToImage","arrayBuffer","options","url","blobOrDataUrl","URL","self","webkitURL","objectUrl","createObjectURL","loadToImage","revokeObjectURL","image","Image","src","decode","Promise","resolve","reject","onload","onerror","err","Error","error"],"mappings":"AACA,SAAQA,mBAAR,QAAkC,aAAlC;AAGA,eAAe,eAAeC,YAAf,CACbC,WADa,EAEbC,OAFa,EAGbC,GAHa,EAIc;AAK3B,QAAMC,aAAa,GAAGL,mBAAmB,CAACE,WAAD,EAAcE,GAAd,CAAzC;AACA,QAAME,GAAG,GAAGC,IAAI,CAACD,GAAL,IAAYC,IAAI,CAACC,SAA7B;AACA,QAAMC,SAAS,GAAG,OAAOJ,aAAP,KAAyB,QAAzB,IAAqCC,GAAG,CAACI,eAAJ,CAAoBL,aAApB,CAAvD;;AACA,MAAI;AACF,WAAO,MAAMM,WAAW,CAACF,SAAS,IAAIJ,aAAd,EAA6BF,OAA7B,CAAxB;AACD,GAFD,SAEU;AACR,QAAIM,SAAJ,EAAe;AACbH,MAAAA,GAAG,CAACM,eAAJ,CAAoBH,SAApB;AACD;AACF;AACF;AAED,OAAO,eAAeE,WAAf,CAA2BP,GAA3B,EAAgCD,OAAhC,EAAoE;AACzE,QAAMU,KAAK,GAAG,IAAIC,KAAJ,EAAd;AACAD,EAAAA,KAAK,CAACE,GAAN,GAAYX,GAAZ;;AASA,MAAID,OAAO,CAACU,KAAR,IAAiBV,OAAO,CAACU,KAAR,CAAcG,MAA/B,IAAyCH,KAAK,CAACG,MAAnD,EAA2D;AACzD,UAAMH,KAAK,CAACG,MAAN,EAAN;AACA,WAAOH,KAAP;AACD;;AAGD,SAAO,MAAM,IAAII,OAAJ,CAAY,CAACC,OAAD,EAAUC,MAAV,KAAqB;AAC5C,QAAI;AACFN,MAAAA,KAAK,CAACO,MAAN,GAAe,MAAMF,OAAO,CAACL,KAAD,CAA5B;;AACAA,MAAAA,KAAK,CAACQ,OAAN,GAAiBC,GAAD,IAASH,MAAM,CAAC,IAAII,KAAJ,gCAAkCnB,GAAlC,eAA0CkB,GAA1C,EAAD,CAA/B;AACD,KAHD,CAGE,OAAOE,KAAP,EAAc;AACdL,MAAAA,MAAM,CAACK,KAAD,CAAN;AACD;AACF,GAPY,CAAb;AAQD","sourcesContent":["import type {ImageLoaderOptions} from '../../image-loader';\nimport {getBlobOrSVGDataUrl} from './svg-utils';\n\n// Parses html image from array buffer\nexport default async function parseToImage(\n  arrayBuffer: ArrayBuffer,\n  options: ImageLoaderOptions,\n  url?: string\n): Promise<HTMLImageElement> {\n  // Note: image parsing requires conversion to Blob (for createObjectURL).\n  // Potentially inefficient for not using `response.blob()` (and for File / Blob inputs)...\n  // But presumably not worth adding 'blob' flag to loader objects?\n\n  const blobOrDataUrl = getBlobOrSVGDataUrl(arrayBuffer, url);\n  const URL = self.URL || self.webkitURL;\n  const objectUrl = typeof blobOrDataUrl !== 'string' && URL.createObjectURL(blobOrDataUrl);\n  try {\n    return await loadToImage(objectUrl || blobOrDataUrl, options);\n  } finally {\n    if (objectUrl) {\n      URL.revokeObjectURL(objectUrl);\n    }\n  }\n}\n\nexport async function loadToImage(url, options): Promise<HTMLImageElement> {\n  const image = new Image();\n  image.src = url;\n\n  // The `image.onload()` callback does not guarantee that the image has been decoded\n  // so a main thread \"freeze\" can be incurred when using the image for the first time.\n  // `Image.decode()` returns a promise that completes when image is decoded.\n\n  // https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement/decode\n  // Note: When calling `img.decode()`, we do not need to wait for `img.onload()`\n  // Note: `HTMLImageElement.decode()` is not available in Edge and IE11\n  if (options.image && options.image.decode && image.decode) {\n    await image.decode();\n    return image;\n  }\n\n  // Create a promise that tracks onload/onerror callbacks\n  return await new Promise((resolve, reject) => {\n    try {\n      image.onload = () => resolve(image);\n      image.onerror = (err) => reject(new Error(`Could not load image ${url}: ${err}`));\n    } catch (error) {\n      reject(error);\n    }\n  });\n}\n"],"file":"parse-to-image.js"}

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

@@ -1,14 +1,11 @@
-import { global } from '../utils/globals';
-import { assert } from '../utils/assert';
+import { assert } from '@loaders.gl/loader-utils';
 import { getBinaryImageMetadata } from '../category-api/binary-image-api';
-export default function parseToNodeImage(arrayBuffer, options) {
+export default async function parseToNodeImage(arrayBuffer, options) {
   const {
     mimeType
   } = getBinaryImageMetadata(arrayBuffer) || {};
-  const {
-    _parseImageNode
-  } = global;
+  const _parseImageNode = globalThis._parseImageNode;
   assert(_parseImageNode);
-  return _parseImageNode(arrayBuffer, mimeType, options);
+  return await _parseImageNode(arrayBuffer, mimeType);
 }
 //# sourceMappingURL=parse-to-node-image.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/parsers/parse-to-node-image.ts"],"names":["global","assert","getBinaryImageMetadata","parseToNodeImage","arrayBuffer","options","mimeType","_parseImageNode"],"mappings":"AAAA,SAAQA,MAAR,QAAqB,kBAArB;AACA,SAAQC,MAAR,QAAqB,iBAArB;AACA,SAAQC,sBAAR,QAAqC,kCAArC;AAGA,eAAe,SAASC,gBAAT,CAA0BC,WAA1B,EAAuCC,OAAvC,EAAgD;AAC7D,QAAM;AAACC,IAAAA;AAAD,MAAaJ,sBAAsB,CAACE,WAAD,CAAtB,IAAuC,EAA1D;AAGA,QAAM;AAACG,IAAAA;AAAD,MAAoBP,MAA1B;AACAC,EAAAA,MAAM,CAACM,eAAD,CAAN;AAEA,SAAOA,eAAe,CAACH,WAAD,EAAcE,QAAd,EAAwBD,OAAxB,CAAtB;AACD","sourcesContent":["import {global} from '../utils/globals';\nimport {assert} from '../utils/assert';\nimport {getBinaryImageMetadata} from '../category-api/binary-image-api';\n\n// Use polyfills if installed to p[arsed image using get-pixels\nexport default function parseToNodeImage(arrayBuffer, options) {\n  const {mimeType} = getBinaryImageMetadata(arrayBuffer) || {};\n\n  // @ts-ignore\n  const {_parseImageNode} = global;\n  assert(_parseImageNode); // '@loaders.gl/polyfills not installed'\n\n  return _parseImageNode(arrayBuffer, mimeType, options);\n}\n"],"file":"parse-to-node-image.js"}
+{"version":3,"sources":["../../../src/lib/parsers/parse-to-node-image.ts"],"names":["assert","getBinaryImageMetadata","parseToNodeImage","arrayBuffer","options","mimeType","_parseImageNode","globalThis"],"mappings":"AAEA,SAAQA,MAAR,QAAqB,0BAArB;AACA,SAAQC,sBAAR,QAAqC,kCAArC;AAgBA,eAAe,eAAeC,gBAAf,CACbC,WADa,EAEbC,OAFa,EAGW;AACxB,QAAM;AAACC,IAAAA;AAAD,MAAaJ,sBAAsB,CAACE,WAAD,CAAtB,IAAuC,EAA1D;AAGA,QAAMG,eAA+B,GAAGC,UAAU,CAACD,eAAnD;AACAN,EAAAA,MAAM,CAACM,eAAD,CAAN;AAGA,SAAO,MAAMA,eAAe,CAACH,WAAD,EAAcE,QAAd,CAA5B;AACD","sourcesContent":["import type {ImageLoaderOptions} from '../../image-loader';\nimport type {ImageDataType} from '../../types';\nimport {assert} from '@loaders.gl/loader-utils';\nimport {getBinaryImageMetadata} from '../category-api/binary-image-api';\n\n// Note: These types should be consistent with loaders.gl/polyfills\n\ntype NDArray = {\n  shape: number[];\n  data: Uint8Array;\n  width: number;\n  height: number;\n  components: number;\n  layers: number[];\n};\n\ntype ParseImageNode = (arrayBuffer: ArrayBuffer, mimeType: string) => Promise<NDArray>;\n\n// Use polyfills if installed to parsed image using get-pixels\nexport default async function parseToNodeImage(\n  arrayBuffer: ArrayBuffer,\n  options: ImageLoaderOptions\n): Promise<ImageDataType> {\n  const {mimeType} = getBinaryImageMetadata(arrayBuffer) || {};\n\n  // @ts-ignore\n  const _parseImageNode: ParseImageNode = globalThis._parseImageNode;\n  assert(_parseImageNode); // '@loaders.gl/polyfills not installed'\n\n  // @ts-expect-error TODO should we throw error in this case?\n  return await _parseImageNode(arrayBuffer, mimeType);\n}\n"],"file":"parse-to-node-image.js"}

package/dist/lib/parsers/svg-utils.js

@@ -16,7 +16,7 @@ export function getBlobOrSVGDataUrl(arrayBuffer, url) {
       throw new Error(error.message);
     }
 
-    const src = `data:image/svg+xml;base64,${btoa(xmlText)}`;
+    const src = "data:image/svg+xml;base64,".concat(btoa(xmlText));
     return src;
   }
 

package/dist/lib/parsers/svg-utils.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/parsers/svg-utils.ts"],"names":["SVG_DATA_URL_PATTERN","SVG_URL_PATTERN","isSVG","url","test","getBlobOrSVGDataUrl","arrayBuffer","textDecoder","TextDecoder","xmlText","decode","unescape","encodeURIComponent","error","Error","message","src","btoa","getBlob","Blob","Uint8Array"],"mappings":"AAGA,MAAMA,oBAAoB,GAAG,uBAA7B;AACA,MAAMC,eAAe,GAAG,mBAAxB;AAEA,OAAO,SAASC,KAAT,CAAeC,GAAf,EAAoB;AACzB,SAAOA,GAAG,KAAKH,oBAAoB,CAACI,IAArB,CAA0BD,GAA1B,KAAkCF,eAAe,CAACG,IAAhB,CAAqBD,GAArB,CAAvC,CAAV;AACD;AAED,OAAO,SAASE,mBAAT,CAA6BC,WAA7B,EAA0CH,GAA1C,EAA+C;AACpD,MAAID,KAAK,CAACC,GAAD,CAAT,EAAgB;AAEd,UAAMI,WAAW,GAAG,IAAIC,WAAJ,EAApB;AACA,QAAIC,OAAO,GAAGF,WAAW,CAACG,MAAZ,CAAmBJ,WAAnB,CAAd;;AAEA,QAAI;AACF,UAAI,OAAOK,QAAP,KAAoB,UAApB,IAAkC,OAAOC,kBAAP,KAA8B,UAApE,EAAgF;AAC9EH,QAAAA,OAAO,GAAGE,QAAQ,CAACC,kBAAkB,CAACH,OAAD,CAAnB,CAAlB;AACD;AACF,KAJD,CAIE,OAAOI,KAAP,EAAc;AACd,YAAM,IAAIC,KAAJ,CAAWD,KAAD,CAAiBE,OAA3B,CAAN;AACD;;AAED,UAAMC,GAAG,GAAI,6BAA4BC,IAAI,CAACR,OAAD,CAAU,EAAvD;AACA,WAAOO,GAAP;AACD;;AACD,SAAOE,OAAO,CAACZ,WAAD,EAAcH,GAAd,CAAd;AACD;AAED,OAAO,SAASe,OAAT,CAAiBZ,WAAjB,EAA8BH,GAA9B,EAAmC;AACxC,MAAID,KAAK,CAACC,GAAD,CAAT,EAAgB;AAGd,UAAM,IAAIW,KAAJ,CAAU,8CAAV,CAAN;AACD;;AAED,SAAO,IAAIK,IAAJ,CAAS,CAAC,IAAIC,UAAJ,CAAed,WAAf,CAAD,CAAT,CAAP;AACD","sourcesContent":["// SVG parsing has limitations, e.g:\n// https://bugs.chromium.org/p/chromium/issues/detail?id=606319\n\nconst SVG_DATA_URL_PATTERN = /^data:image\\/svg\\+xml/;\nconst SVG_URL_PATTERN = /\\.svg((\\?|#).*)?$/;\n\nexport function isSVG(url) {\n  return url && (SVG_DATA_URL_PATTERN.test(url) || SVG_URL_PATTERN.test(url));\n}\n\nexport function getBlobOrSVGDataUrl(arrayBuffer, url) {\n  if (isSVG(url)) {\n    // Prepare a properly tagged data URL, and load using normal mechanism\n    const textDecoder = new TextDecoder();\n    let xmlText = textDecoder.decode(arrayBuffer);\n    // TODO Escape in browser to support e.g. Chinese characters\n    try {\n      if (typeof unescape === 'function' && typeof encodeURIComponent === 'function') {\n        xmlText = unescape(encodeURIComponent(xmlText));\n      }\n    } catch (error) {\n      throw new Error((error as Error).message);\n    }\n    // base64 encoding is safer. utf-8 fails in some browsers\n    const src = `data:image/svg+xml;base64,${btoa(xmlText)}`;\n    return src;\n  }\n  return getBlob(arrayBuffer, url);\n}\n\nexport function getBlob(arrayBuffer, url) {\n  if (isSVG(url)) {\n    // https://bugs.chromium.org/p/chromium/issues/detail?id=606319\n    // return new Blob([new Uint8Array(arrayBuffer)], {type: 'image/svg+xml'});\n    throw new Error('SVG cannot be parsed directly to imagebitmap');\n  }\n  // TODO - how to determine mime type? Param? Sniff here?\n  return new Blob([new Uint8Array(arrayBuffer)]); // MIME type not needed?\n}\n"],"file":"svg-utils.js"}
+{"version":3,"sources":["../../../src/lib/parsers/svg-utils.ts"],"names":["SVG_DATA_URL_PATTERN","SVG_URL_PATTERN","isSVG","url","test","getBlobOrSVGDataUrl","arrayBuffer","textDecoder","TextDecoder","xmlText","decode","unescape","encodeURIComponent","error","Error","message","src","btoa","getBlob","Blob","Uint8Array"],"mappings":"AAGA,MAAMA,oBAAoB,GAAG,uBAA7B;AACA,MAAMC,eAAe,GAAG,mBAAxB;AAEA,OAAO,SAASC,KAAT,CAAeC,GAAf,EAAoB;AACzB,SAAOA,GAAG,KAAKH,oBAAoB,CAACI,IAArB,CAA0BD,GAA1B,KAAkCF,eAAe,CAACG,IAAhB,CAAqBD,GAArB,CAAvC,CAAV;AACD;AAED,OAAO,SAASE,mBAAT,CAA6BC,WAA7B,EAAuDH,GAAvD,EAAoF;AACzF,MAAID,KAAK,CAACC,GAAD,CAAT,EAAgB;AAEd,UAAMI,WAAW,GAAG,IAAIC,WAAJ,EAApB;AACA,QAAIC,OAAO,GAAGF,WAAW,CAACG,MAAZ,CAAmBJ,WAAnB,CAAd;;AAEA,QAAI;AACF,UAAI,OAAOK,QAAP,KAAoB,UAApB,IAAkC,OAAOC,kBAAP,KAA8B,UAApE,EAAgF;AAC9EH,QAAAA,OAAO,GAAGE,QAAQ,CAACC,kBAAkB,CAACH,OAAD,CAAnB,CAAlB;AACD;AACF,KAJD,CAIE,OAAOI,KAAP,EAAc;AACd,YAAM,IAAIC,KAAJ,CAAWD,KAAD,CAAiBE,OAA3B,CAAN;AACD;;AAED,UAAMC,GAAG,uCAAgCC,IAAI,CAACR,OAAD,CAApC,CAAT;AACA,WAAOO,GAAP;AACD;;AACD,SAAOE,OAAO,CAACZ,WAAD,EAAcH,GAAd,CAAd;AACD;AAED,OAAO,SAASe,OAAT,CAAiBZ,WAAjB,EAA2CH,GAA3C,EAA+D;AACpE,MAAID,KAAK,CAACC,GAAD,CAAT,EAAgB;AAGd,UAAM,IAAIW,KAAJ,CAAU,8CAAV,CAAN;AACD;;AAED,SAAO,IAAIK,IAAJ,CAAS,CAAC,IAAIC,UAAJ,CAAed,WAAf,CAAD,CAAT,CAAP;AACD","sourcesContent":["// SVG parsing has limitations, e.g:\n// https://bugs.chromium.org/p/chromium/issues/detail?id=606319\n\nconst SVG_DATA_URL_PATTERN = /^data:image\\/svg\\+xml/;\nconst SVG_URL_PATTERN = /\\.svg((\\?|#).*)?$/;\n\nexport function isSVG(url) {\n  return url && (SVG_DATA_URL_PATTERN.test(url) || SVG_URL_PATTERN.test(url));\n}\n\nexport function getBlobOrSVGDataUrl(arrayBuffer: ArrayBuffer, url?: string): Blob | string {\n  if (isSVG(url)) {\n    // Prepare a properly tagged data URL, and load using normal mechanism\n    const textDecoder = new TextDecoder();\n    let xmlText = textDecoder.decode(arrayBuffer);\n    // TODO Escape in browser to support e.g. Chinese characters\n    try {\n      if (typeof unescape === 'function' && typeof encodeURIComponent === 'function') {\n        xmlText = unescape(encodeURIComponent(xmlText));\n      }\n    } catch (error) {\n      throw new Error((error as Error).message);\n    }\n    // base64 encoding is safer. utf-8 fails in some browsers\n    const src = `data:image/svg+xml;base64,${btoa(xmlText)}`;\n    return src;\n  }\n  return getBlob(arrayBuffer, url);\n}\n\nexport function getBlob(arrayBuffer: ArrayBuffer, url?: string): Blob {\n  if (isSVG(url)) {\n    // https://bugs.chromium.org/p/chromium/issues/detail?id=606319\n    // return new Blob([new Uint8Array(arrayBuffer)], {type: 'image/svg+xml'});\n    throw new Error('SVG cannot be parsed directly to imagebitmap');\n  }\n  // TODO - how to determine mime type? Param? Sniff here?\n  return new Blob([new Uint8Array(arrayBuffer)]); // MIME type not needed?\n}\n"],"file":"svg-utils.js"}

package/dist/lib/texture-api/generate-url.js

@@ -1,5 +1,4 @@
-import { resolvePath } from '@loaders.gl/loader-utils';
-import { assert } from '../utils/assert';
+import { resolvePath, assert } from '@loaders.gl/loader-utils';
 export function generateUrl(getUrl, options, urlOptions) {
   let url = getUrl;
 
@@ -15,7 +14,7 @@ export function generateUrl(getUrl, options, urlOptions) {
   } = options;
 
   if (baseUrl) {
-    url = baseUrl[baseUrl.length - 1] === '/' ? `${baseUrl}${url}` : `${baseUrl}/${url}`;
+    url = baseUrl[baseUrl.length - 1] === '/' ? "".concat(baseUrl).concat(url) : "".concat(baseUrl, "/").concat(url);
   }
 
   return resolvePath(url);

package/dist/lib/texture-api/generate-url.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/texture-api/generate-url.ts"],"names":["resolvePath","assert","generateUrl","getUrl","options","urlOptions","url","baseUrl","length"],"mappings":"AAAA,SAAQA,WAAR,QAA0B,0BAA1B;AACA,SAAQC,MAAR,QAAqB,iBAArB;AAGA,OAAO,SAASC,WAAT,CAAqBC,MAArB,EAA6BC,OAA7B,EAAsCC,UAAtC,EAAkD;AAEvD,MAAIC,GAAG,GAAGH,MAAV;;AACA,MAAI,OAAOA,MAAP,KAAkB,UAAtB,EAAkC;AAChCG,IAAAA,GAAG,GAAGH,MAAM,CAAC,EAAC,GAAGC,OAAJ;AAAa,SAAGC;AAAhB,KAAD,CAAZ;AACD;;AACDJ,EAAAA,MAAM,CAAC,OAAOK,GAAP,KAAe,QAAhB,CAAN;AAGA,QAAM;AAACC,IAAAA;AAAD,MAAYH,OAAlB;;AACA,MAAIG,OAAJ,EAAa;AACXD,IAAAA,GAAG,GAAGC,OAAO,CAACA,OAAO,CAACC,MAAR,GAAiB,CAAlB,CAAP,KAAgC,GAAhC,GAAuC,GAAED,OAAQ,GAAED,GAAI,EAAvD,GAA4D,GAAEC,OAAQ,IAAGD,GAAI,EAAnF;AACD;;AAED,SAAON,WAAW,CAACM,GAAD,CAAlB;AACD","sourcesContent":["import {resolvePath} from '@loaders.gl/loader-utils';\nimport {assert} from '../utils/assert';\n\n// Generate a url by calling getUrl with mix of options, applying options.baseUrl\nexport function generateUrl(getUrl, options, urlOptions) {\n  // Get url\n  let url = getUrl;\n  if (typeof getUrl === 'function') {\n    url = getUrl({...options, ...urlOptions});\n  }\n  assert(typeof url === 'string');\n\n  // Apply options.baseUrl\n  const {baseUrl} = options;\n  if (baseUrl) {\n    url = baseUrl[baseUrl.length - 1] === '/' ? `${baseUrl}${url}` : `${baseUrl}/${url}`;\n  }\n\n  return resolvePath(url);\n}\n"],"file":"generate-url.js"}
+{"version":3,"sources":["../../../src/lib/texture-api/generate-url.ts"],"names":["resolvePath","assert","generateUrl","getUrl","options","urlOptions","url","baseUrl","length"],"mappings":"AAAA,SAAQA,WAAR,EAAqBC,MAArB,QAAkC,0BAAlC;AAGA,OAAO,SAASC,WAAT,CAAqBC,MAArB,EAA6BC,OAA7B,EAAsCC,UAAtC,EAAkD;AAEvD,MAAIC,GAAG,GAAGH,MAAV;;AACA,MAAI,OAAOA,MAAP,KAAkB,UAAtB,EAAkC;AAChCG,IAAAA,GAAG,GAAGH,MAAM,CAAC,EAAC,GAAGC,OAAJ;AAAa,SAAGC;AAAhB,KAAD,CAAZ;AACD;;AACDJ,EAAAA,MAAM,CAAC,OAAOK,GAAP,KAAe,QAAhB,CAAN;AAGA,QAAM;AAACC,IAAAA;AAAD,MAAYH,OAAlB;;AACA,MAAIG,OAAJ,EAAa;AACXD,IAAAA,GAAG,GAAGC,OAAO,CAACA,OAAO,CAACC,MAAR,GAAiB,CAAlB,CAAP,KAAgC,GAAhC,aAAyCD,OAAzC,SAAmDD,GAAnD,cAA8DC,OAA9D,cAAyED,GAAzE,CAAN;AACD;;AAED,SAAON,WAAW,CAACM,GAAD,CAAlB;AACD","sourcesContent":["import {resolvePath, assert} from '@loaders.gl/loader-utils';\n\n// Generate a url by calling getUrl with mix of options, applying options.baseUrl\nexport function generateUrl(getUrl, options, urlOptions) {\n  // Get url\n  let url = getUrl;\n  if (typeof getUrl === 'function') {\n    url = getUrl({...options, ...urlOptions});\n  }\n  assert(typeof url === 'string');\n\n  // Apply options.baseUrl\n  const {baseUrl} = options;\n  if (baseUrl) {\n    url = baseUrl[baseUrl.length - 1] === '/' ? `${baseUrl}${url}` : `${baseUrl}/${url}`;\n  }\n\n  return resolvePath(url);\n}\n"],"file":"generate-url.js"}

package/dist/lib/texture-api/load-image.js

@@ -1,4 +1,4 @@
-import { assert } from '../utils/assert';
+import { assert } from '@loaders.gl/loader-utils';
 import parseImage from '../parsers/parse-image';
 import { getImageSize } from '../category-api/parsed-image-api';
 import { generateUrl } from './generate-url';

package/dist/lib/texture-api/load-image.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/texture-api/load-image.ts"],"names":["assert","parseImage","getImageSize","generateUrl","deepLoad","shallowLoad","loadImage","getUrl","options","imageUrls","getImageUrls","urlOptions","mipLevels","image","getMipmappedImageUrls","urls","url","lod","width","height","getMipLevels","push","mipLevel","length","Math","floor","log2","max"],"mappings":"AAAA,SAAQA,MAAR,QAAqB,iBAArB;AACA,OAAOC,UAAP,MAAuB,wBAAvB;AACA,SAAQC,YAAR,QAA2B,kCAA3B;AACA,SAAQC,WAAR,QAA0B,gBAA1B;AACA,SAAQC,QAAR,EAAkBC,WAAlB,QAAoC,aAApC;AAEA,OAAO,eAAeC,SAAf,CAAyBC,MAAzB,EAAiCC,OAAO,GAAG,EAA3C,EAA+C;AACpD,QAAMC,SAAS,GAAG,MAAMC,YAAY,CAACH,MAAD,EAASC,OAAT,CAApC;AACA,SAAO,MAAMJ,QAAQ,CAACK,SAAD,EAAYR,UAAZ,EAAwBO,OAAxB,CAArB;AACD;AAED,OAAO,eAAeE,YAAf,CAA4BH,MAA5B,EAAoCC,OAApC,EAA6CG,UAAU,GAAG,EAA1D,EAA8D;AACnE,QAAMC,SAAS,GAAIJ,OAAO,IAAIA,OAAO,CAACK,KAAnB,IAA4BL,OAAO,CAACK,KAAR,CAAcD,SAA3C,IAAyD,CAA3E;AACA,SAAOA,SAAS,KAAK,CAAd,GACH,MAAME,qBAAqB,CAACP,MAAD,EAASK,SAAT,EAAoBJ,OAApB,EAA6BG,UAA7B,CADxB,GAEHR,WAAW,CAACI,MAAD,EAASC,OAAT,EAAkBG,UAAlB,CAFf;AAGD;;AAED,eAAeG,qBAAf,CAAqCP,MAArC,EAA6CK,SAA7C,EAAwDJ,OAAxD,EAAiEG,UAAjE,EAA6E;AAC3E,QAAMI,IAAc,GAAG,EAAvB;;AAGA,MAAIH,SAAS,KAAK,MAAlB,EAA0B;AACxB,UAAMI,GAAG,GAAGb,WAAW,CAACI,MAAD,EAASC,OAAT,EAAkB,EAAC,GAAGG,UAAJ;AAAgBM,MAAAA,GAAG,EAAE;AAArB,KAAlB,CAAvB;AACA,UAAMJ,KAAK,GAAG,MAAMR,WAAW,CAACW,GAAD,EAAMf,UAAN,EAAkBO,OAAlB,CAA/B;AAEA,UAAM;AAACU,MAAAA,KAAD;AAAQC,MAAAA;AAAR,QAAkBjB,YAAY,CAACW,KAAD,CAApC;AACAD,IAAAA,SAAS,GAAGQ,YAAY,CAAC;AAACF,MAAAA,KAAD;AAAQC,MAAAA;AAAR,KAAD,CAAxB;AAGAJ,IAAAA,IAAI,CAACM,IAAL,CAAUL,GAAV;AACD;;AAGDhB,EAAAA,MAAM,CAACY,SAAS,GAAG,CAAb,CAAN;;AAEA,OAAK,IAAIU,QAAQ,GAAGP,IAAI,CAACQ,MAAzB,EAAiCD,QAAQ,GAAGV,SAA5C,EAAuD,EAAEU,QAAzD,EAAmE;AACjE,UAAMN,GAAG,GAAGb,WAAW,CAACI,MAAD,EAASC,OAAT,EAAkB,EAAC,GAAGG,UAAJ;AAAgBM,MAAAA,GAAG,EAAEK;AAArB,KAAlB,CAAvB;AACAP,IAAAA,IAAI,CAACM,IAAL,CAAUL,GAAV;AACD;;AAED,SAAOD,IAAP;AACD;;AAGD,OAAO,SAASK,YAAT,CAAsB;AAACF,EAAAA,KAAD;AAAQC,EAAAA;AAAR,CAAtB,EAAuC;AAC5C,SAAO,IAAIK,IAAI,CAACC,KAAL,CAAWD,IAAI,CAACE,IAAL,CAAUF,IAAI,CAACG,GAAL,CAAST,KAAT,EAAgBC,MAAhB,CAAV,CAAX,CAAX;AACD","sourcesContent":["import {assert} from '../utils/assert';\nimport parseImage from '../parsers/parse-image';\nimport {getImageSize} from '../category-api/parsed-image-api';\nimport {generateUrl} from './generate-url';\nimport {deepLoad, shallowLoad} from './deep-load';\n\nexport async function loadImage(getUrl, options = {}) {\n  const imageUrls = await getImageUrls(getUrl, options);\n  return await deepLoad(imageUrls, parseImage, options);\n}\n\nexport async function getImageUrls(getUrl, options, urlOptions = {}) {\n  const mipLevels = (options && options.image && options.image.mipLevels) || 0;\n  return mipLevels !== 0\n    ? await getMipmappedImageUrls(getUrl, mipLevels, options, urlOptions)\n    : generateUrl(getUrl, options, urlOptions);\n}\n\nasync function getMipmappedImageUrls(getUrl, mipLevels, options, urlOptions) {\n  const urls: string[] = [];\n\n  // If no mip levels supplied, we need to load the level 0 image and calculate based on size\n  if (mipLevels === 'auto') {\n    const url = generateUrl(getUrl, options, {...urlOptions, lod: 0});\n    const image = await shallowLoad(url, parseImage, options);\n\n    const {width, height} = getImageSize(image);\n    mipLevels = getMipLevels({width, height});\n\n    // TODO - push image and make `deepLoad` pass through non-url values, avoid loading twice?\n    urls.push(url);\n  }\n\n  // We now know how many mipLevels we need, remaining image urls can now be constructed\n  assert(mipLevels > 0);\n\n  for (let mipLevel = urls.length; mipLevel < mipLevels; ++mipLevel) {\n    const url = generateUrl(getUrl, options, {...urlOptions, lod: mipLevel});\n    urls.push(url);\n  }\n\n  return urls;\n}\n\n// Calculates number of mipmaps based on texture size (log2)\nexport function getMipLevels({width, height}) {\n  return 1 + Math.floor(Math.log2(Math.max(width, height)));\n}\n"],"file":"load-image.js"}
+{"version":3,"sources":["../../../src/lib/texture-api/load-image.ts"],"names":["assert","parseImage","getImageSize","generateUrl","deepLoad","shallowLoad","loadImage","getUrl","options","imageUrls","getImageUrls","urlOptions","mipLevels","image","getMipmappedImageUrls","urls","url","lod","width","height","getMipLevels","push","mipLevel","length","Math","floor","log2","max"],"mappings":"AAAA,SAAQA,MAAR,QAAqB,0BAArB;AACA,OAAOC,UAAP,MAAuB,wBAAvB;AACA,SAAQC,YAAR,QAA2B,kCAA3B;AACA,SAAQC,WAAR,QAA0B,gBAA1B;AACA,SAAQC,QAAR,EAAkBC,WAAlB,QAAoC,aAApC;AAEA,OAAO,eAAeC,SAAf,CAAyBC,MAAzB,EAAiCC,OAAO,GAAG,EAA3C,EAA+C;AACpD,QAAMC,SAAS,GAAG,MAAMC,YAAY,CAACH,MAAD,EAASC,OAAT,CAApC;AACA,SAAO,MAAMJ,QAAQ,CAACK,SAAD,EAAYR,UAAZ,EAAwBO,OAAxB,CAArB;AACD;AAED,OAAO,eAAeE,YAAf,CAA4BH,MAA5B,EAAoCC,OAApC,EAA6CG,UAAU,GAAG,EAA1D,EAA8D;AACnE,QAAMC,SAAS,GAAIJ,OAAO,IAAIA,OAAO,CAACK,KAAnB,IAA4BL,OAAO,CAACK,KAAR,CAAcD,SAA3C,IAAyD,CAA3E;AACA,SAAOA,SAAS,KAAK,CAAd,GACH,MAAME,qBAAqB,CAACP,MAAD,EAASK,SAAT,EAAoBJ,OAApB,EAA6BG,UAA7B,CADxB,GAEHR,WAAW,CAACI,MAAD,EAASC,OAAT,EAAkBG,UAAlB,CAFf;AAGD;;AAED,eAAeG,qBAAf,CAAqCP,MAArC,EAA6CK,SAA7C,EAAwDJ,OAAxD,EAAiEG,UAAjE,EAA6E;AAC3E,QAAMI,IAAc,GAAG,EAAvB;;AAGA,MAAIH,SAAS,KAAK,MAAlB,EAA0B;AACxB,UAAMI,GAAG,GAAGb,WAAW,CAACI,MAAD,EAASC,OAAT,EAAkB,EAAC,GAAGG,UAAJ;AAAgBM,MAAAA,GAAG,EAAE;AAArB,KAAlB,CAAvB;AACA,UAAMJ,KAAK,GAAG,MAAMR,WAAW,CAACW,GAAD,EAAMf,UAAN,EAAkBO,OAAlB,CAA/B;AAEA,UAAM;AAACU,MAAAA,KAAD;AAAQC,MAAAA;AAAR,QAAkBjB,YAAY,CAACW,KAAD,CAApC;AACAD,IAAAA,SAAS,GAAGQ,YAAY,CAAC;AAACF,MAAAA,KAAD;AAAQC,MAAAA;AAAR,KAAD,CAAxB;AAGAJ,IAAAA,IAAI,CAACM,IAAL,CAAUL,GAAV;AACD;;AAGDhB,EAAAA,MAAM,CAACY,SAAS,GAAG,CAAb,CAAN;;AAEA,OAAK,IAAIU,QAAQ,GAAGP,IAAI,CAACQ,MAAzB,EAAiCD,QAAQ,GAAGV,SAA5C,EAAuD,EAAEU,QAAzD,EAAmE;AACjE,UAAMN,GAAG,GAAGb,WAAW,CAACI,MAAD,EAASC,OAAT,EAAkB,EAAC,GAAGG,UAAJ;AAAgBM,MAAAA,GAAG,EAAEK;AAArB,KAAlB,CAAvB;AACAP,IAAAA,IAAI,CAACM,IAAL,CAAUL,GAAV;AACD;;AAED,SAAOD,IAAP;AACD;;AAGD,OAAO,SAASK,YAAT,CAAsB;AAACF,EAAAA,KAAD;AAAQC,EAAAA;AAAR,CAAtB,EAAuC;AAC5C,SAAO,IAAIK,IAAI,CAACC,KAAL,CAAWD,IAAI,CAACE,IAAL,CAAUF,IAAI,CAACG,GAAL,CAAST,KAAT,EAAgBC,MAAhB,CAAV,CAAX,CAAX;AACD","sourcesContent":["import {assert} from '@loaders.gl/loader-utils';\nimport parseImage from '../parsers/parse-image';\nimport {getImageSize} from '../category-api/parsed-image-api';\nimport {generateUrl} from './generate-url';\nimport {deepLoad, shallowLoad} from './deep-load';\n\nexport async function loadImage(getUrl, options = {}) {\n  const imageUrls = await getImageUrls(getUrl, options);\n  return await deepLoad(imageUrls, parseImage, options);\n}\n\nexport async function getImageUrls(getUrl, options, urlOptions = {}) {\n  const mipLevels = (options && options.image && options.image.mipLevels) || 0;\n  return mipLevels !== 0\n    ? await getMipmappedImageUrls(getUrl, mipLevels, options, urlOptions)\n    : generateUrl(getUrl, options, urlOptions);\n}\n\nasync function getMipmappedImageUrls(getUrl, mipLevels, options, urlOptions) {\n  const urls: string[] = [];\n\n  // If no mip levels supplied, we need to load the level 0 image and calculate based on size\n  if (mipLevels === 'auto') {\n    const url = generateUrl(getUrl, options, {...urlOptions, lod: 0});\n    const image = await shallowLoad(url, parseImage, options);\n\n    const {width, height} = getImageSize(image);\n    mipLevels = getMipLevels({width, height});\n\n    // TODO - push image and make `deepLoad` pass through non-url values, avoid loading twice?\n    urls.push(url);\n  }\n\n  // We now know how many mipLevels we need, remaining image urls can now be constructed\n  assert(mipLevels > 0);\n\n  for (let mipLevel = urls.length; mipLevel < mipLevels; ++mipLevel) {\n    const url = generateUrl(getUrl, options, {...urlOptions, lod: mipLevel});\n    urls.push(url);\n  }\n\n  return urls;\n}\n\n// Calculates number of mipmaps based on texture size (log2)\nexport function getMipLevels({width, height}) {\n  return 1 + Math.floor(Math.log2(Math.max(width, height)));\n}\n"],"file":"load-image.js"}

package/dist/lib/utils/version.js

@@ -1,2 +1,2 @@
-export const VERSION = typeof "3.1.0-alpha.2" !== 'undefined' ? "3.1.0-alpha.2" : 'latest';
+export const VERSION = typeof "4.0.0-alpha.3" !== 'undefined' ? "4.0.0-alpha.3" : 'latest';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/images",
-  "version": "3.1.0-alpha.2",
+  "version": "4.0.0-alpha.3",
   "description": "Framework-independent loaders and writers for images (PNG, JPG, ...)",
   "license": "MIT",
   "publishConfig": {
@@ -29,11 +29,10 @@
   ],
   "scripts": {
     "pre-build": "npm run build-bundle",
-    "build-bundle": "webpack  --display=minimal --config ../../scripts/webpack/bundle.js",
-    "build-worker": "webpack --entry ./src/image-worker.js --output ./dist/image-worker.js --config ../../scripts/webpack/worker.js"
+    "build-bundle": "webpack  --display=minimal --config ../../scripts/webpack/bundle.js"
   },
   "dependencies": {
-    "@loaders.gl/loader-utils": "3.1.0-alpha.2"
+    "@loaders.gl/loader-utils": "4.0.0-alpha.3"
   },
-  "gitHead": "ca83b8f05a6874db93051d446266d9ea360affb2"
+  "gitHead": "ded84630d02ba4fc97277ebecea3e42ae1bc2616"
 }

package/src/bundle.ts

@@ -1,5 +1,4 @@
 // @ts-nocheck
 const moduleExports = require('./index');
-const _global = typeof window === 'undefined' ? global : window;
-_global.loaders = _global.loaders || {};
-module.exports = Object.assign(_global.loaders, moduleExports);
+globalThis.loaders = globalThis.loaders || {};
+module.exports = Object.assign(globalThis.loaders, moduleExports);

package/src/image-loader.ts

@@ -1,4 +1,4 @@
-import type {LoaderWithParser} from '@loaders.gl/loader-utils';
+import type {LoaderOptions, LoaderWithParser} from '@loaders.gl/loader-utils';
 import {VERSION} from './lib/utils/version';
 import parseImage from './lib/parsers/parse-image';
 import {getBinaryImageMetadata} from './lib/category-api/binary-image-api';
@@ -14,6 +14,22 @@ const MIME_TYPES = [
   'image/svg+xml'
 ];
 
+export type ImageLoaderOptions = LoaderOptions & {
+  image?: {
+    type?: 'auto' | 'data' | 'imagebitmap' | 'image';
+    decode?: boolean;
+  };
+  imagebitmap?: ImageBitmapOptions;
+};
+
+const DEFAULT_IMAGE_LOADER_OPTIONS: ImageLoaderOptions = {
+  image: {
+    type: 'auto',
+    decode: true // if format is HTML
+  }
+  // imagebitmap: {} - passes (platform dependent) parameters to ImageBitmap constructor
+};
+
 /**
  * Loads a platform-specific image type
  * Note: This type can be used as input data to WebGL texture creation
@@ -28,13 +44,7 @@ export const ImageLoader = {
   parse: parseImage,
   // TODO: byteOffset, byteLength;
   tests: [(arrayBuffer) => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer)))],
-  options: {
-    image: {
-      type: 'auto',
-      decode: true // if format is HTML
-    }
-    // imagebitmap: {} - passes (platform dependent) parameters to ImageBitmap constructor
-  }
+  options: DEFAULT_IMAGE_LOADER_OPTIONS
 };
 
 export const _typecheckImageLoader: LoaderWithParser = ImageLoader;

package/src/index.ts

@@ -1,5 +1,6 @@
 // TYPES
 export type {ImageDataType, ImageType, ImageTypeEnum} from './types';
+export type {ImageLoaderOptions} from './image-loader';
 
 // LOADERS AND WRITERS
 export {ImageLoader} from './image-loader';
@@ -20,5 +21,8 @@ export {
   getImageData
 } from './lib/category-api/parsed-image-api';
 
+// EXPERIMENTAL
+export {_isImageFormatSupported} from './lib/category-api/image-format';
+
 // DEPRECATED - Remove in V3 (fix dependency in luma.gl)
 export {loadImage} from './lib/texture-api/load-image';

package/src/lib/category-api/image-format.ts

@@ -0,0 +1,66 @@
+import {isBrowser} from '@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: {[mimeType: string]: boolean} = {};
+
+/**
+ * Check if image MIME type is supported. Result is cached.
+ */
+export function _isImageFormatSupported(mimeType: string): boolean {
+  if (mimeTypeSupported[mimeType] === undefined) {
+    mimeTypeSupported[mimeType] = checkFormatSupport(mimeType);
+  }
+  return mimeTypeSupported[mimeType];
+}
+
+/**
+ * Check if image MIME type is supported.
+ */
+function checkFormatSupport(mimeType: string): boolean {
+  switch (mimeType) {
+    case 'image/webp':
+      return checkWebPSupport();
+    case 'image/svg':
+      return isBrowser;
+    default:
+      if (!isBrowser) {
+        // @ts-ignore
+        const {_parseImageNode} = globalThis;
+        return Boolean(_parseImageNode) && NODE_FORMAT_SUPPORT.includes(mimeType);
+      }
+      return true;
+  }
+}
+
+/** Check WebPSupport synchronously */
+function checkWebPSupport() {
+  if (!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/src/lib/category-api/image-type.ts

@@ -1,8 +1,8 @@
+import {isBrowser} from '@loaders.gl/loader-utils';
 import type {ImageTypeEnum} from '../../types';
-import {global, isBrowser} from '../utils/globals';
 
 // @ts-ignore TS2339: Property does not exist on type
-const {_parseImageNode} = global;
+const {_parseImageNode} = globalThis;
 
 const IMAGE_SUPPORTED = typeof Image !== 'undefined'; // NOTE: "false" positives if jsdom is installed
 const IMAGE_BITMAP_SUPPORTED = typeof ImageBitmap !== 'undefined';

package/src/lib/encoders/encode-image.ts

@@ -1,9 +1,8 @@
 // Image loading/saving for browser and Node.js
-import {global} from '../utils/globals';
 import {getImageSize} from '../category-api/parsed-image-api';
 
 // @ts-ignore TS2339: Property does not exist on type
-const {_encodeImageNode} = global;
+const {_encodeImageNode} = globalThis;
 
 /**
  * Returns data bytes representing a compressed image in PNG or JPG format,

package/src/lib/parsers/parse-image.ts

@@ -1,4 +1,7 @@
-import {assert} from '../utils/assert';
+import type {LoaderContext} from '@loaders.gl/loader-utils';
+import {assert} from '@loaders.gl/loader-utils';
+import type {ImageType} from '../../types';
+import type {ImageLoaderOptions} from '../../image-loader';
 import {isImageTypeSupported, getDefaultImageType} from '../category-api/image-type';
 import {getImageData} from '../category-api/parsed-image-api';
 import parseToImage from './parse-to-image';
@@ -7,7 +10,11 @@ import parseToNodeImage from './parse-to-node-image';
 
 // Parse to platform defined image type (data on node, ImageBitmap or HTMLImage on browser)
 // eslint-disable-next-line complexity
-export default async function parseImage(arrayBuffer, options, context) {
+export default async function parseImage(
+  arrayBuffer: ArrayBuffer,
+  options?: ImageLoaderOptions,
+  context?: LoaderContext
+): Promise<ImageType> {
   options = options || {};
   const imageOptions = options.image || {};
 

package/src/lib/parsers/parse-to-image-bitmap.ts

@@ -1,3 +1,4 @@
+import type {ImageLoaderOptions} from '../../image-loader';
 import {isSVG, getBlob} from './svg-utils';
 import parseToImage from './parse-to-image';
 
@@ -12,7 +13,11 @@ let imagebitmapOptionsSupported = true;
  *
  * TODO - createImageBitmap supports source rect (5 param overload), pass through?
  */
-export default async function parseToImageBitmap(arrayBuffer, options, url) {
+export default async function parseToImageBitmap(
+  arrayBuffer: ArrayBuffer,
+  options: ImageLoaderOptions,
+  url?: string
+): Promise<ImageBitmap> {
   let blob;
 
   // Cannot parse SVG directly to ImageBitmap, parse to Image first
@@ -36,7 +41,10 @@ export default async function parseToImageBitmap(arrayBuffer, options, url) {
  * Firefox crashes if imagebitmapOptions is supplied
  * Avoid supplying if not provided or supported, remember if not supported
  */
-async function safeCreateImageBitmap(blob, imagebitmapOptions = null) {
+async function safeCreateImageBitmap(
+  blob: Blob,
+  imagebitmapOptions: ImageBitmapOptions | null = null
+): Promise<ImageBitmap> {
   if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) {
     imagebitmapOptions = null;
   }

package/src/lib/parsers/parse-to-image.ts

@@ -1,7 +1,12 @@
+import type {ImageLoaderOptions} from '../../image-loader';
 import {getBlobOrSVGDataUrl} from './svg-utils';
 
 // Parses html image from array buffer
-export default async function parseToImage(arrayBuffer, options, url) {
+export default async function parseToImage(
+  arrayBuffer: ArrayBuffer,
+  options: ImageLoaderOptions,
+  url?: string
+): Promise<HTMLImageElement> {
   // 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?
@@ -18,7 +23,7 @@ export default async function parseToImage(arrayBuffer, options, url) {
   }
 }
 
-export async function loadToImage(url, options) {
+export async function loadToImage(url, options): Promise<HTMLImageElement> {
   const image = new Image();
   image.src = url;
 

package/src/lib/parsers/parse-to-node-image.ts

@@ -1,14 +1,32 @@
-import {global} from '../utils/globals';
-import {assert} from '../utils/assert';
+import type {ImageLoaderOptions} from '../../image-loader';
+import type {ImageDataType} from '../../types';
+import {assert} from '@loaders.gl/loader-utils';
 import {getBinaryImageMetadata} from '../category-api/binary-image-api';
 
-// Use polyfills if installed to p[arsed image using get-pixels
-export default function parseToNodeImage(arrayBuffer, options) {
+// Note: These types should be consistent with loaders.gl/polyfills
+
+type NDArray = {
+  shape: number[];
+  data: Uint8Array;
+  width: number;
+  height: number;
+  components: number;
+  layers: number[];
+};
+
+type ParseImageNode = (arrayBuffer: ArrayBuffer, mimeType: string) => Promise<NDArray>;
+
+// Use polyfills if installed to parsed image using get-pixels
+export default async function parseToNodeImage(
+  arrayBuffer: ArrayBuffer,
+  options: ImageLoaderOptions
+): Promise<ImageDataType> {
   const {mimeType} = getBinaryImageMetadata(arrayBuffer) || {};
 
   // @ts-ignore
-  const {_parseImageNode} = global;
+  const _parseImageNode: ParseImageNode = globalThis._parseImageNode;
   assert(_parseImageNode); // '@loaders.gl/polyfills not installed'
 
-  return _parseImageNode(arrayBuffer, mimeType, options);
+  // @ts-expect-error TODO should we throw error in this case?
+  return await _parseImageNode(arrayBuffer, mimeType);
 }

package/src/lib/parsers/svg-utils.ts

@@ -8,7 +8,7 @@ export function isSVG(url) {
   return url && (SVG_DATA_URL_PATTERN.test(url) || SVG_URL_PATTERN.test(url));
 }
 
-export function getBlobOrSVGDataUrl(arrayBuffer, url) {
+export function getBlobOrSVGDataUrl(arrayBuffer: ArrayBuffer, url?: string): Blob | string {
   if (isSVG(url)) {
     // Prepare a properly tagged data URL, and load using normal mechanism
     const textDecoder = new TextDecoder();
@@ -28,7 +28,7 @@ export function getBlobOrSVGDataUrl(arrayBuffer, url) {
   return getBlob(arrayBuffer, url);
 }
 
-export function getBlob(arrayBuffer, url) {
+export function getBlob(arrayBuffer: ArrayBuffer, url?: string): Blob {
   if (isSVG(url)) {
     // https://bugs.chromium.org/p/chromium/issues/detail?id=606319
     // return new Blob([new Uint8Array(arrayBuffer)], {type: 'image/svg+xml'});

package/src/lib/texture-api/generate-url.ts

@@ -1,5 +1,4 @@
-import {resolvePath} from '@loaders.gl/loader-utils';
-import {assert} from '../utils/assert';
+import {resolvePath, assert} from '@loaders.gl/loader-utils';
 
 // Generate a url by calling getUrl with mix of options, applying options.baseUrl
 export function generateUrl(getUrl, options, urlOptions) {

package/src/lib/texture-api/load-image.ts

@@ -1,4 +1,4 @@
-import {assert} from '../utils/assert';
+import {assert} from '@loaders.gl/loader-utils';
 import parseImage from '../parsers/parse-image';
 import {getImageSize} from '../category-api/parsed-image-api';
 import {generateUrl} from './generate-url';

package/dist/lib/utils/assert.js

@@ -1,6 +0,0 @@
-export function assert(condition, message) {
-  if (!condition) {
-    throw new Error(message);
-  }
-}
-//# sourceMappingURL=assert.js.map

package/dist/lib/utils/assert.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/utils/assert.js"],"names":["assert","condition","message","Error"],"mappings":"AAAA,OAAO,SAASA,MAAT,CAAgBC,SAAhB,EAA2BC,OAA3B,EAAoC;AACzC,MAAI,CAACD,SAAL,EAAgB;AACd,UAAM,IAAIE,KAAJ,CAAUD,OAAV,CAAN;AACD;AACF","sourcesContent":["export function assert(condition, message) {\n  if (!condition) {\n    throw new Error(message);\n  }\n}\n"],"file":"assert.js"}

package/dist/lib/utils/globals.js

@@ -1,16 +0,0 @@
-const globals = {
-  self: typeof self !== 'undefined' && self,
-  window: typeof window !== 'undefined' && window,
-  global: typeof global !== 'undefined' && global,
-  document: typeof document !== 'undefined' && document
-};
-const self_ = globals.self || globals.window || globals.global;
-const window_ = globals.window || globals.self || globals.global;
-const global_ = globals.global || globals.self || globals.window;
-const document_ = globals.document || {};
-export { self_ as self, window_ as window, global_ as global, document_ as document };
-export const isBrowser = typeof process !== 'object' || String(process) !== '[object process]' || process.browser;
-export const isWorker = typeof importScripts === 'function';
-const matches = typeof process !== 'undefined' && process.version && /v([0-9]*)/.exec(process.version);
-export const nodeVersion = matches && parseFloat(matches[1]) || 0;
-//# sourceMappingURL=globals.js.map

package/dist/lib/utils/globals.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/lib/utils/globals.ts"],"names":["globals","self","window","global","document","self_","window_","global_","document_","isBrowser","process","String","browser","isWorker","importScripts","matches","version","exec","nodeVersion","parseFloat"],"mappings":"AAwBA,MAAMA,OAAO,GAAG;AACdC,EAAAA,IAAI,EAAE,OAAOA,IAAP,KAAgB,WAAhB,IAA+BA,IADvB;AAEdC,EAAAA,MAAM,EAAE,OAAOA,MAAP,KAAkB,WAAlB,IAAiCA,MAF3B;AAGdC,EAAAA,MAAM,EAAE,OAAOA,MAAP,KAAkB,WAAlB,IAAiCA,MAH3B;AAIdC,EAAAA,QAAQ,EAAE,OAAOA,QAAP,KAAoB,WAApB,IAAmCA;AAJ/B,CAAhB;AAOA,MAAMC,KAAK,GAAGL,OAAO,CAACC,IAAR,IAAgBD,OAAO,CAACE,MAAxB,IAAkCF,OAAO,CAACG,MAAxD;AACA,MAAMG,OAAO,GAAGN,OAAO,CAACE,MAAR,IAAkBF,OAAO,CAACC,IAA1B,IAAkCD,OAAO,CAACG,MAA1D;AACA,MAAMI,OAAO,GAAGP,OAAO,CAACG,MAAR,IAAkBH,OAAO,CAACC,IAA1B,IAAkCD,OAAO,CAACE,MAA1D;AACA,MAAMM,SAAS,GAAGR,OAAO,CAACI,QAAR,IAAoB,EAAtC;AAEA,SAAQC,KAAK,IAAIJ,IAAjB,EAAuBK,OAAO,IAAIJ,MAAlC,EAA0CK,OAAO,IAAIJ,MAArD,EAA6DK,SAAS,IAAIJ,QAA1E;AAEA,OAAO,MAAMK,SAAS,GAEpB,OAAOC,OAAP,KAAmB,QAAnB,IAA+BC,MAAM,CAACD,OAAD,CAAN,KAAoB,kBAAnD,IAAyEA,OAAO,CAACE,OAF5E;AAIP,OAAO,MAAMC,QAAQ,GAAG,OAAOC,aAAP,KAAyB,UAA1C;AAGP,MAAMC,OAAO,GACX,OAAOL,OAAP,KAAmB,WAAnB,IAAkCA,OAAO,CAACM,OAA1C,IAAqD,YAAYC,IAAZ,CAAiBP,OAAO,CAACM,OAAzB,CADvD;AAEA,OAAO,MAAME,WAAW,GAAIH,OAAO,IAAII,UAAU,CAACJ,OAAO,CAAC,CAAD,CAAR,CAAtB,IAAuC,CAA3D","sourcesContent":["// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n// Purpose: include this in your module to avoids adding dependencies on\n// micro modules like 'global' and 'is-browser';\n\n/* eslint-disable no-restricted-globals */\nconst globals = {\n  self: typeof self !== 'undefined' && self,\n  window: typeof window !== 'undefined' && window,\n  global: typeof global !== 'undefined' && global,\n  document: typeof document !== 'undefined' && document\n};\n\nconst self_ = globals.self || globals.window || globals.global;\nconst window_ = globals.window || globals.self || globals.global;\nconst global_ = globals.global || globals.self || globals.window;\nconst document_ = globals.document || {};\n\nexport {self_ as self, window_ as window, global_ as global, document_ as document};\n\nexport const isBrowser =\n  // @ts-ignore\n  typeof process !== 'object' || String(process) !== '[object process]' || process.browser;\n\nexport const isWorker = typeof importScripts === 'function';\n\n// Extract node major version\nconst matches =\n  typeof process !== 'undefined' && process.version && /v([0-9]*)/.exec(process.version);\nexport const nodeVersion = (matches && parseFloat(matches[1])) || 0;\n"],"file":"globals.js"}

package/src/lib/utils/assert.js

@@ -1,5 +0,0 @@
-export function assert(condition, message) {
-  if (!condition) {
-    throw new Error(message);
-  }
-}