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

package/dist/esm/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/esm/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":"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,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 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"}
+{"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/esm/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/esm/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,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,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,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"}
+{"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/esm/lib/texture-api/generate-url.js

@@ -14,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/esm/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,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,GAAuC,GAAED,OAAQ,GAAED,GAAI,EAAvD,GAA4D,GAAEC,OAAQ,IAAGD,GAAI,EAAnF;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"}
+{"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/esm/lib/utils/version.js

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

package/dist/esm/lib/utils/version.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/utils/version.ts"],"names":["VERSION"],"mappings":"AAGA,OAAO,MAAMA,OAAO,GAAG,2BAAuB,WAAvB,qBAAmD,QAAnE","sourcesContent":["// Version constant cannot be imported, it needs to correspond to the build version of **this** module.\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nexport const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n"],"file":"version.js"}
+{"version":3,"sources":["../../../../src/lib/utils/version.ts"],"names":["VERSION"],"mappings":"AAGA,OAAO,MAAMA,OAAO,GAAG,0BAAuB,WAAvB,oBAAmD,QAAnE","sourcesContent":["// Version constant cannot be imported, it needs to correspond to the build version of **this** module.\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nexport const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n"],"file":"version.js"}

package/dist/image-loader.d.ts

@@ -0,0 +1,26 @@
+import type { LoaderOptions, LoaderWithParser } from '@loaders.gl/loader-utils';
+import parseImage from './lib/parsers/parse-image';
+export declare type ImageLoaderOptions = LoaderOptions & {
+    image?: {
+        type?: 'auto' | 'data' | 'imagebitmap' | 'image';
+        decode?: boolean;
+    };
+    imagebitmap?: ImageBitmapOptions;
+};
+/**
+ * Loads a platform-specific image type
+ * Note: This type can be used as input data to WebGL texture creation
+ */
+export declare const ImageLoader: {
+    id: string;
+    module: string;
+    name: string;
+    version: any;
+    mimeTypes: string[];
+    extensions: string[];
+    parse: typeof parseImage;
+    tests: ((arrayBuffer: any) => boolean)[];
+    options: ImageLoaderOptions;
+};
+export declare const _typecheckImageLoader: LoaderWithParser;
+//# sourceMappingURL=image-loader.d.ts.map

package/dist/image-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-loader.d.ts","sourceRoot":"","sources":["../src/image-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAE,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAE9E,OAAO,UAAU,MAAM,2BAA2B,CAAC;AAcnD,oBAAY,kBAAkB,GAAG,aAAa,GAAG;IAC/C,KAAK,CAAC,EAAE;QACN,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,aAAa,GAAG,OAAO,CAAC;QACjD,MAAM,CAAC,EAAE,OAAO,CAAC;KAClB,CAAC;IACF,WAAW,CAAC,EAAE,kBAAkB,CAAC;CAClC,CAAC;AAUF;;;GAGG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;CAWvB,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,gBAA8B,CAAC"}

package/dist/image-loader.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._typecheckImageLoader = exports.ImageLoader = void 0;
+const version_1 = require("./lib/utils/version");
+const parse_image_1 = __importDefault(require("./lib/parsers/parse-image"));
+const binary_image_api_1 = require("./lib/category-api/binary-image-api");
+const EXTENSIONS = ['png', 'jpg', 'jpeg', 'gif', 'webp', 'bmp', 'ico', 'svg'];
+const MIME_TYPES = [
+    'image/png',
+    'image/jpeg',
+    'image/gif',
+    'image/webp',
+    'image/bmp',
+    'image/vnd.microsoft.icon',
+    'image/svg+xml'
+];
+const DEFAULT_IMAGE_LOADER_OPTIONS = {
+    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
+ */
+exports.ImageLoader = {
+    id: 'image',
+    module: 'images',
+    name: 'Images',
+    version: version_1.VERSION,
+    mimeTypes: MIME_TYPES,
+    extensions: EXTENSIONS,
+    parse: parse_image_1.default,
+    // TODO: byteOffset, byteLength;
+    tests: [(arrayBuffer) => Boolean((0, binary_image_api_1.getBinaryImageMetadata)(new DataView(arrayBuffer)))],
+    options: DEFAULT_IMAGE_LOADER_OPTIONS
+};
+exports._typecheckImageLoader = exports.ImageLoader;

package/dist/image-writer.d.ts

@@ -0,0 +1,16 @@
+import { encodeImage } from './lib/encoders/encode-image';
+export declare const ImageWriter: {
+    name: string;
+    id: string;
+    module: string;
+    version: any;
+    extensions: string[];
+    options: {
+        image: {
+            mimeType: string;
+            jpegQuality: null;
+        };
+    };
+    encode: typeof encodeImage;
+};
+//# sourceMappingURL=image-writer.d.ts.map

package/dist/image-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-writer.d.ts","sourceRoot":"","sources":["../src/image-writer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,WAAW,EAAC,MAAM,6BAA6B,CAAC;AAExD,eAAO,MAAM,WAAW;;;;;;;;;;;;;CAavB,CAAC"}

package/dist/image-writer.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageWriter = void 0;
+// import type {Writer} from '@loaders.gl/loader-utils';
+const version_1 = require("./lib/utils/version");
+const encode_image_1 = require("./lib/encoders/encode-image");
+exports.ImageWriter = {
+    name: 'Images',
+    id: 'image',
+    module: 'images',
+    version: version_1.VERSION,
+    extensions: ['jpeg'],
+    options: {
+        image: {
+            mimeType: 'image/png',
+            jpegQuality: null
+        }
+    },
+    encode: encode_image_1.encodeImage
+};

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export type { ImageDataType, ImageType, ImageTypeEnum } from './types';
+export type { ImageLoaderOptions } from './image-loader';
+export { ImageLoader } from './image-loader';
+export { ImageWriter } from './image-writer';
+export { getBinaryImageMetadata } from './lib/category-api/binary-image-api';
+export { isImageTypeSupported, getDefaultImageType } from './lib/category-api/image-type';
+export { isImage, getImageType, getImageSize, getImageData } from './lib/category-api/parsed-image-api';
+export { _isImageFormatSupported } from './lib/category-api/image-format';
+export { loadImage } from './lib/texture-api/load-image';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,YAAY,EAAC,aAAa,EAAE,SAAS,EAAE,aAAa,EAAC,MAAM,SAAS,CAAC;AACrE,YAAY,EAAC,kBAAkB,EAAC,MAAM,gBAAgB,CAAC;AAGvD,OAAO,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAK3C,OAAO,EAAC,sBAAsB,EAAC,MAAM,qCAAqC,CAAC;AAG3E,OAAO,EAAC,oBAAoB,EAAE,mBAAmB,EAAC,MAAM,+BAA+B,CAAC;AAExF,OAAO,EACL,OAAO,EACP,YAAY,EACZ,YAAY,EACZ,YAAY,EACb,MAAM,qCAAqC,CAAC;AAG7C,OAAO,EAAC,uBAAuB,EAAC,MAAM,iCAAiC,CAAC;AAGxE,OAAO,EAAC,SAAS,EAAC,MAAM,8BAA8B,CAAC"}

package/dist/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadImage = exports._isImageFormatSupported = exports.getImageData = exports.getImageSize = exports.getImageType = exports.isImage = exports.getDefaultImageType = exports.isImageTypeSupported = exports.getBinaryImageMetadata = exports.ImageWriter = exports.ImageLoader = void 0;
+// LOADERS AND WRITERS
+var image_loader_1 = require("./image-loader");
+Object.defineProperty(exports, "ImageLoader", { enumerable: true, get: function () { return image_loader_1.ImageLoader; } });
+var image_writer_1 = require("./image-writer");
+Object.defineProperty(exports, "ImageWriter", { enumerable: true, get: function () { return image_writer_1.ImageWriter; } });
+// IMAGE CATEGORY API
+// Binary Image API
+var binary_image_api_1 = require("./lib/category-api/binary-image-api");
+Object.defineProperty(exports, "getBinaryImageMetadata", { enumerable: true, get: function () { return binary_image_api_1.getBinaryImageMetadata; } });
+// Parsed Image API
+var image_type_1 = require("./lib/category-api/image-type");
+Object.defineProperty(exports, "isImageTypeSupported", { enumerable: true, get: function () { return image_type_1.isImageTypeSupported; } });
+Object.defineProperty(exports, "getDefaultImageType", { enumerable: true, get: function () { return image_type_1.getDefaultImageType; } });
+var parsed_image_api_1 = require("./lib/category-api/parsed-image-api");
+Object.defineProperty(exports, "isImage", { enumerable: true, get: function () { return parsed_image_api_1.isImage; } });
+Object.defineProperty(exports, "getImageType", { enumerable: true, get: function () { return parsed_image_api_1.getImageType; } });
+Object.defineProperty(exports, "getImageSize", { enumerable: true, get: function () { return parsed_image_api_1.getImageSize; } });
+Object.defineProperty(exports, "getImageData", { enumerable: true, get: function () { return parsed_image_api_1.getImageData; } });
+// EXPERIMENTAL
+var image_format_1 = require("./lib/category-api/image-format");
+Object.defineProperty(exports, "_isImageFormatSupported", { enumerable: true, get: function () { return image_format_1._isImageFormatSupported; } });
+// DEPRECATED - Remove in V3 (fix dependency in luma.gl)
+var load_image_1 = require("./lib/texture-api/load-image");
+Object.defineProperty(exports, "loadImage", { enumerable: true, get: function () { return load_image_1.loadImage; } });

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

@@ -0,0 +1,19 @@
+/** MIME type, width and height extracted from binary compressed image data */
+export declare type BinaryImageMetadata = {
+    mimeType: string;
+    width: number;
+    height: number;
+};
+/**
+ * Extracts `{mimeType, width and height}` from a memory buffer containing a known image format
+ * Currently supports `image/png`, `image/jpeg`, `image/bmp` and `image/gif`.
+ * @param binaryData image file memory to parse
+ * @returns metadata or null if memory is not a valid image file format layout.
+ */
+export declare function getBinaryImageMetadata(binaryData: DataView | ArrayBuffer): BinaryImageMetadata | null;
+export declare function getBmpMetadata(binaryData: any): {
+    mimeType: string;
+    width: number;
+    height: number;
+} | null;
+//# sourceMappingURL=binary-image-api.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"binary-image-api.d.ts","sourceRoot":"","sources":["../../../src/lib/category-api/binary-image-api.ts"],"names":[],"mappings":"AAQA,8EAA8E;AAC9E,oBAAY,mBAAmB,GAAG;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAKF;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,QAAQ,GAAG,WAAW,GACjC,mBAAmB,GAAG,IAAI,CAQ5B;AA2CD,wBAAgB,cAAc,CAAC,UAAU,KAAA;;;;SAmBxC"}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,12 @@
+import type { ImageTypeEnum } from '../../types';
+/**
+ * Checks if a loaders.gl image type is supported
+ * @param type image type string
+ */
+export declare function isImageTypeSupported(type: string): boolean;
+/**
+ * Returns the "most performant" supported image type on this platform
+ * @returns image type string
+ */
+export declare function getDefaultImageType(): ImageTypeEnum;
+//# sourceMappingURL=image-type.d.ts.map

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

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

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

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

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

@@ -0,0 +1,10 @@
+import type { ImageType, ImageTypeEnum, ImageDataType } from '../../types';
+export declare function isImage(image: ImageType): boolean;
+export declare function deleteImage(image: ImageType): void;
+export declare function getImageType(image: ImageType): ImageTypeEnum;
+export declare function getImageSize(image: ImageType): {
+    width: number;
+    height: number;
+};
+export declare function getImageData(image: ImageType): ImageDataType | ImageData;
+//# sourceMappingURL=parsed-image-api.d.ts.map

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

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

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

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