@loaders.gl/images 3.3.0-alpha.1 → 3.3.0-alpha.11

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

@@ -2,6 +2,7 @@ import { isSVG, getBlob } from './svg-utils';
 import parseToImage from './parse-to-image';
 const EMPTY_OBJECT = {};
 let imagebitmapOptionsSupported = true;
+
 export default async function parseToImageBitmap(arrayBuffer, options, url) {
   let blob;
 
@@ -11,16 +12,15 @@ export default async function parseToImageBitmap(arrayBuffer, options, url) {
   } else {
     blob = getBlob(arrayBuffer, url);
   }
-
   const imagebitmapOptions = options && options.imagebitmap;
   return await safeCreateImageBitmap(blob, imagebitmapOptions);
 }
 
-async function safeCreateImageBitmap(blob, imagebitmapOptions = null) {
+async function safeCreateImageBitmap(blob) {
+  let imagebitmapOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
   if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) {
     imagebitmapOptions = null;
   }
-
   if (imagebitmapOptions) {
     try {
       return await createImageBitmap(blob, imagebitmapOptions);
@@ -29,15 +29,12 @@ async function safeCreateImageBitmap(blob, imagebitmapOptions = null) {
       imagebitmapOptionsSupported = false;
     }
   }
-
   return await createImageBitmap(blob);
 }
-
 function isEmptyObject(object) {
   for (const key in object || EMPTY_OBJECT) {
     return false;
   }
-
   return true;
 }
 //# sourceMappingURL=parse-to-image-bitmap.js.map

package/dist/esm/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":"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"}
+{"version":3,"file":"parse-to-image-bitmap.js","names":["isSVG","getBlob","parseToImage","EMPTY_OBJECT","imagebitmapOptionsSupported","parseToImageBitmap","arrayBuffer","options","url","blob","image","imagebitmapOptions","imagebitmap","safeCreateImageBitmap","isEmptyObject","createImageBitmap","error","console","warn","object","key"],"sources":["../../../../src/lib/parsers/parse-to-image-bitmap.ts"],"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"],"mappings":"AACA,SAAQA,KAAK,EAAEC,OAAO,QAAO,aAAa;AAC1C,OAAOC,YAAY,MAAM,kBAAkB;AAE3C,MAAMC,YAAY,GAAG,CAAC,CAAC;AAEvB,IAAIC,2BAA2B,GAAG,IAAI;;AAStC,eAAe,eAAeC,kBAAkB,CAC9CC,WAAwB,EACxBC,OAA2B,EAC3BC,GAAY,EACU;EACtB,IAAIC,IAAI;;EAGR,IAAIT,KAAK,CAACQ,GAAG,CAAC,EAAE;IAEd,MAAME,KAAK,GAAG,MAAMR,YAAY,CAACI,WAAW,EAAEC,OAAO,EAAEC,GAAG,CAAC;IAC3DC,IAAI,GAAGC,KAAK;EACd,CAAC,MAAM;IAELD,IAAI,GAAGR,OAAO,CAACK,WAAW,EAAEE,GAAG,CAAC;EAClC;EAEA,MAAMG,kBAAkB,GAAGJ,OAAO,IAAIA,OAAO,CAACK,WAAW;EAEzD,OAAO,MAAMC,qBAAqB,CAACJ,IAAI,EAAEE,kBAAkB,CAAC;AAC9D;;AAQA,eAAeE,qBAAqB,CAClCJ,IAAU,EAEY;EAAA,IADtBE,kBAA6C,uEAAG,IAAI;EAEpD,IAAIG,aAAa,CAACH,kBAAkB,CAAC,IAAI,CAACP,2BAA2B,EAAE;IACrEO,kBAAkB,GAAG,IAAI;EAC3B;EAEA,IAAIA,kBAAkB,EAAE;IACtB,IAAI;MAEF,OAAO,MAAMI,iBAAiB,CAACN,IAAI,EAAEE,kBAAkB,CAAC;IAC1D,CAAC,CAAC,OAAOK,KAAK,EAAE;MACdC,OAAO,CAACC,IAAI,CAACF,KAAK,CAAC;MACnBZ,2BAA2B,GAAG,KAAK;IACrC;EACF;EAEA,OAAO,MAAMW,iBAAiB,CAACN,IAAI,CAAC;AACtC;AAEA,SAASK,aAAa,CAACK,MAAM,EAAE;EAE7B,KAAK,MAAMC,GAAG,IAAID,MAAM,IAAIhB,YAAY,EAAE;IACxC,OAAO,KAAK;EACd;EACA,OAAO,IAAI;AACb"}

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

@@ -1,9 +1,10 @@
 import { getBlobOrSVGDataUrl } from './svg-utils';
+
 export default async function parseToImage(arrayBuffer, options, url) {
+
   const blobOrDataUrl = getBlobOrSVGDataUrl(arrayBuffer, url);
   const URL = self.URL || self.webkitURL;
   const objectUrl = typeof blobOrDataUrl !== 'string' && URL.createObjectURL(blobOrDataUrl);
-
   try {
     return await loadToImage(objectUrl || blobOrDataUrl, options);
   } finally {
@@ -24,7 +25,6 @@ export async function loadToImage(url, options) {
   return await new Promise((resolve, reject) => {
     try {
       image.onload = () => resolve(image);
-
       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,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"}
+{"version":3,"file":"parse-to-image.js","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"],"sources":["../../../../src/lib/parsers/parse-to-image.ts"],"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"],"mappings":"AACA,SAAQA,mBAAmB,QAAO,aAAa;;AAG/C,eAAe,eAAeC,YAAY,CACxCC,WAAwB,EACxBC,OAA2B,EAC3BC,GAAY,EACe;;EAK3B,MAAMC,aAAa,GAAGL,mBAAmB,CAACE,WAAW,EAAEE,GAAG,CAAC;EAC3D,MAAME,GAAG,GAAGC,IAAI,CAACD,GAAG,IAAIC,IAAI,CAACC,SAAS;EACtC,MAAMC,SAAS,GAAG,OAAOJ,aAAa,KAAK,QAAQ,IAAIC,GAAG,CAACI,eAAe,CAACL,aAAa,CAAC;EACzF,IAAI;IACF,OAAO,MAAMM,WAAW,CAACF,SAAS,IAAIJ,aAAa,EAAEF,OAAO,CAAC;EAC/D,CAAC,SAAS;IACR,IAAIM,SAAS,EAAE;MACbH,GAAG,CAACM,eAAe,CAACH,SAAS,CAAC;IAChC;EACF;AACF;AAEA,OAAO,eAAeE,WAAW,CAACP,GAAG,EAAED,OAAO,EAA6B;EACzE,MAAMU,KAAK,GAAG,IAAIC,KAAK,EAAE;EACzBD,KAAK,CAACE,GAAG,GAAGX,GAAG;;EASf,IAAID,OAAO,CAACU,KAAK,IAAIV,OAAO,CAACU,KAAK,CAACG,MAAM,IAAIH,KAAK,CAACG,MAAM,EAAE;IACzD,MAAMH,KAAK,CAACG,MAAM,EAAE;IACpB,OAAOH,KAAK;EACd;;EAGA,OAAO,MAAM,IAAII,OAAO,CAAC,CAACC,OAAO,EAAEC,MAAM,KAAK;IAC5C,IAAI;MACFN,KAAK,CAACO,MAAM,GAAG,MAAMF,OAAO,CAACL,KAAK,CAAC;MACnCA,KAAK,CAACQ,OAAO,GAAIC,GAAG,IAAKH,MAAM,CAAC,IAAII,KAAK,gCAAyBnB,GAAG,eAAKkB,GAAG,EAAG,CAAC;IACnF,CAAC,CAAC,OAAOE,KAAK,EAAE;MACdL,MAAM,CAACK,KAAK,CAAC;IACf;EACF,CAAC,CAAC;AACJ"}

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

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

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"parse-to-node-image.js","names":["assert","getBinaryImageMetadata","parseToNodeImage","arrayBuffer","options","mimeType","_parseImageNode","globalThis"],"sources":["../../../../src/lib/parsers/parse-to-node-image.ts"],"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"],"mappings":"AAEA,SAAQA,MAAM,QAAO,0BAA0B;AAC/C,SAAQC,sBAAsB,QAAO,kCAAkC;;AAgBvE,eAAe,eAAeC,gBAAgB,CAC5CC,WAAwB,EACxBC,OAA2B,EACH;EACxB,MAAM;IAACC;EAAQ,CAAC,GAAGJ,sBAAsB,CAACE,WAAW,CAAC,IAAI,CAAC,CAAC;;EAG5D,MAAMG,eAA+B,GAAGC,UAAU,CAACD,eAAe;EAClEN,MAAM,CAACM,eAAe,CAAC;;EAGvB,OAAO,MAAMA,eAAe,CAACH,WAAW,EAAEE,QAAQ,CAAC;AACrD"}

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

@@ -1,3 +1,5 @@
+
+
 const SVG_DATA_URL_PATTERN = /^data:image\/svg\+xml/;
 const SVG_URL_PATTERN = /\.svg((\?|#).*)?$/;
 export function isSVG(url) {
@@ -7,7 +9,6 @@ export function getBlobOrSVGDataUrl(arrayBuffer, url) {
   if (isSVG(url)) {
     const textDecoder = new TextDecoder();
     let xmlText = textDecoder.decode(arrayBuffer);
-
     try {
       if (typeof unescape === 'function' && typeof encodeURIComponent === 'function') {
         xmlText = unescape(encodeURIComponent(xmlText));
@@ -15,18 +16,15 @@ export function getBlobOrSVGDataUrl(arrayBuffer, url) {
     } catch (error) {
       throw new Error(error.message);
     }
-
     const src = "data:image/svg+xml;base64,".concat(btoa(xmlText));
     return src;
   }
-
   return getBlob(arrayBuffer, url);
 }
 export function getBlob(arrayBuffer, url) {
   if (isSVG(url)) {
     throw new Error('SVG cannot be parsed directly to imagebitmap');
   }
-
   return new Blob([new Uint8Array(arrayBuffer)]);
 }
 //# sourceMappingURL=svg-utils.js.map

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,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"}
+{"version":3,"file":"svg-utils.js","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"],"sources":["../../../../src/lib/parsers/svg-utils.ts"],"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"],"mappings":";;AAGA,MAAMA,oBAAoB,GAAG,uBAAuB;AACpD,MAAMC,eAAe,GAAG,mBAAmB;AAE3C,OAAO,SAASC,KAAK,CAACC,GAAG,EAAE;EACzB,OAAOA,GAAG,KAAKH,oBAAoB,CAACI,IAAI,CAACD,GAAG,CAAC,IAAIF,eAAe,CAACG,IAAI,CAACD,GAAG,CAAC,CAAC;AAC7E;AAEA,OAAO,SAASE,mBAAmB,CAACC,WAAwB,EAAEH,GAAY,EAAiB;EACzF,IAAID,KAAK,CAACC,GAAG,CAAC,EAAE;IAEd,MAAMI,WAAW,GAAG,IAAIC,WAAW,EAAE;IACrC,IAAIC,OAAO,GAAGF,WAAW,CAACG,MAAM,CAACJ,WAAW,CAAC;IAE7C,IAAI;MACF,IAAI,OAAOK,QAAQ,KAAK,UAAU,IAAI,OAAOC,kBAAkB,KAAK,UAAU,EAAE;QAC9EH,OAAO,GAAGE,QAAQ,CAACC,kBAAkB,CAACH,OAAO,CAAC,CAAC;MACjD;IACF,CAAC,CAAC,OAAOI,KAAK,EAAE;MACd,MAAM,IAAIC,KAAK,CAAED,KAAK,CAAWE,OAAO,CAAC;IAC3C;IAEA,MAAMC,GAAG,uCAAgCC,IAAI,CAACR,OAAO,CAAC,CAAE;IACxD,OAAOO,GAAG;EACZ;EACA,OAAOE,OAAO,CAACZ,WAAW,EAAEH,GAAG,CAAC;AAClC;AAEA,OAAO,SAASe,OAAO,CAACZ,WAAwB,EAAEH,GAAY,EAAQ;EACpE,IAAID,KAAK,CAACC,GAAG,CAAC,EAAE;IAGd,MAAM,IAAIW,KAAK,CAAC,8CAA8C,CAAC;EACjE;EAEA,OAAO,IAAIK,IAAI,CAAC,CAAC,IAAIC,UAAU,CAACd,WAAW,CAAC,CAAC,CAAC;AAChD"}

package/dist/esm/lib/texture-api/async-deep-map.js

@@ -1,13 +1,15 @@
+
+
 const isObject = value => value && typeof value === 'object';
 
-export async function asyncDeepMap(tree, func, options = {}) {
+export async function asyncDeepMap(tree, func) {
+  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   return await mapSubtree(tree, func, options);
 }
 export async function mapSubtree(object, func, options) {
   if (Array.isArray(object)) {
     return await mapArray(object, func, options);
   }
-
   if (isObject(object)) {
     return await mapObject(object, func, options);
   }
@@ -19,7 +21,6 @@ export async function mapSubtree(object, func, options) {
 async function mapObject(object, func, options) {
   const promises = [];
   const values = {};
-
   for (const key in object) {
     const url = object[key];
     const promise = mapSubtree(url, func, options).then(value => {
@@ -27,12 +28,11 @@ async function mapObject(object, func, options) {
     });
     promises.push(promise);
   }
-
   await Promise.all(promises);
   return values;
 }
-
-async function mapArray(urlArray, func, options = {}) {
+async function mapArray(urlArray, func) {
+  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   const promises = urlArray.map(url => mapSubtree(url, func, options));
   return await Promise.all(promises);
 }

package/dist/esm/lib/texture-api/async-deep-map.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/texture-api/async-deep-map.ts"],"names":["isObject","value","asyncDeepMap","tree","func","options","mapSubtree","object","Array","isArray","mapArray","mapObject","url","promises","values","key","promise","then","push","Promise","all","urlArray","map"],"mappings":"AAgBA,MAAMA,QAAQ,GAAIC,KAAD,IAAWA,KAAK,IAAI,OAAOA,KAAP,KAAiB,QAAtD;;AAKA,OAAO,eAAeC,YAAf,CAA4BC,IAA5B,EAAkCC,IAAlC,EAAwCC,OAAO,GAAG,EAAlD,EAAsD;AAC3D,SAAO,MAAMC,UAAU,CAACH,IAAD,EAAOC,IAAP,EAAaC,OAAb,CAAvB;AACD;AAED,OAAO,eAAeC,UAAf,CAA0BC,MAA1B,EAAkCH,IAAlC,EAAwCC,OAAxC,EAAiD;AACtD,MAAIG,KAAK,CAACC,OAAN,CAAcF,MAAd,CAAJ,EAA2B;AACzB,WAAO,MAAMG,QAAQ,CAACH,MAAD,EAASH,IAAT,EAAeC,OAAf,CAArB;AACD;;AAED,MAAIL,QAAQ,CAACO,MAAD,CAAZ,EAAsB;AACpB,WAAO,MAAMI,SAAS,CAACJ,MAAD,EAASH,IAAT,EAAeC,OAAf,CAAtB;AACD;;AAGD,QAAMO,GAAG,GAAGL,MAAZ;AACA,SAAO,MAAMH,IAAI,CAACQ,GAAD,EAAMP,OAAN,CAAjB;AACD;;AAID,eAAeM,SAAf,CAAyBJ,MAAzB,EAAiCH,IAAjC,EAAuCC,OAAvC,EAAgD;AAC9C,QAAMQ,QAAwB,GAAG,EAAjC;AACA,QAAMC,MAAM,GAAG,EAAf;;AAEA,OAAK,MAAMC,GAAX,IAAkBR,MAAlB,EAA0B;AACxB,UAAMK,GAAG,GAAGL,MAAM,CAACQ,GAAD,CAAlB;AACA,UAAMC,OAAO,GAAGV,UAAU,CAACM,GAAD,EAAMR,IAAN,EAAYC,OAAZ,CAAV,CAA+BY,IAA/B,CAAqChB,KAAD,IAAW;AAC7Da,MAAAA,MAAM,CAACC,GAAD,CAAN,GAAcd,KAAd;AACD,KAFe,CAAhB;AAGAY,IAAAA,QAAQ,CAACK,IAAT,CAAcF,OAAd;AACD;;AAED,QAAMG,OAAO,CAACC,GAAR,CAAYP,QAAZ,CAAN;AAEA,SAAOC,MAAP;AACD;;AAED,eAAeJ,QAAf,CAAwBW,QAAxB,EAAkCjB,IAAlC,EAAwCC,OAAO,GAAG,EAAlD,EAAsD;AACpD,QAAMQ,QAAQ,GAAGQ,QAAQ,CAACC,GAAT,CAAcV,GAAD,IAASN,UAAU,CAACM,GAAD,EAAMR,IAAN,EAAYC,OAAZ,CAAhC,CAAjB;AACA,SAAO,MAAMc,OAAO,CAACC,GAAR,CAAYP,QAAZ,CAAb;AACD","sourcesContent":["/*\nAsynchronously maps a deep structure of values (e.g. objects and arrays of urls).\n\nE.g. a mipmapped cubemap\n{\n  [CUBE_FACE_FRONT]: [\n    \"image-front-0.jpg\",\n    \"image-front-1.jpg\",\n    \"image-front-2.jpg\",\n  ],\n  [CUBE_MAP_BACK]: [\n    ...\n  ]\n}\n*/\n\nconst isObject = (value) => value && typeof value === 'object';\n\n// Loads a deep structure of urls (objects and arrays of urls)\n// Returns an object with six key-value pairs containing the images (or image mip arrays)\n// for each cube face\nexport async function asyncDeepMap(tree, func, options = {}) {\n  return await mapSubtree(tree, func, options);\n}\n\nexport async function mapSubtree(object, func, options) {\n  if (Array.isArray(object)) {\n    return await mapArray(object, func, options);\n  }\n\n  if (isObject(object)) {\n    return await mapObject(object, func, options);\n  }\n\n  // TODO - ignore non-urls, non-arraybuffers?\n  const url = object;\n  return await func(url, options);\n}\n\n// HELPERS\n\nasync function mapObject(object, func, options) {\n  const promises: Promise<any>[] = [];\n  const values = {};\n\n  for (const key in object) {\n    const url = object[key];\n    const promise = mapSubtree(url, func, options).then((value) => {\n      values[key] = value;\n    });\n    promises.push(promise);\n  }\n\n  await Promise.all(promises);\n\n  return values;\n}\n\nasync function mapArray(urlArray, func, options = {}) {\n  const promises = urlArray.map((url) => mapSubtree(url, func, options));\n  return await Promise.all(promises);\n}\n"],"file":"async-deep-map.js"}
+{"version":3,"file":"async-deep-map.js","names":["isObject","value","asyncDeepMap","tree","func","options","mapSubtree","object","Array","isArray","mapArray","mapObject","url","promises","values","key","promise","then","push","Promise","all","urlArray","map"],"sources":["../../../../src/lib/texture-api/async-deep-map.ts"],"sourcesContent":["/*\nAsynchronously maps a deep structure of values (e.g. objects and arrays of urls).\n\nE.g. a mipmapped cubemap\n{\n  [CUBE_FACE_FRONT]: [\n    \"image-front-0.jpg\",\n    \"image-front-1.jpg\",\n    \"image-front-2.jpg\",\n  ],\n  [CUBE_MAP_BACK]: [\n    ...\n  ]\n}\n*/\n\nconst isObject = (value) => value && typeof value === 'object';\n\n// Loads a deep structure of urls (objects and arrays of urls)\n// Returns an object with six key-value pairs containing the images (or image mip arrays)\n// for each cube face\nexport async function asyncDeepMap(tree, func, options = {}) {\n  return await mapSubtree(tree, func, options);\n}\n\nexport async function mapSubtree(object, func, options) {\n  if (Array.isArray(object)) {\n    return await mapArray(object, func, options);\n  }\n\n  if (isObject(object)) {\n    return await mapObject(object, func, options);\n  }\n\n  // TODO - ignore non-urls, non-arraybuffers?\n  const url = object;\n  return await func(url, options);\n}\n\n// HELPERS\n\nasync function mapObject(object, func, options) {\n  const promises: Promise<any>[] = [];\n  const values = {};\n\n  for (const key in object) {\n    const url = object[key];\n    const promise = mapSubtree(url, func, options).then((value) => {\n      values[key] = value;\n    });\n    promises.push(promise);\n  }\n\n  await Promise.all(promises);\n\n  return values;\n}\n\nasync function mapArray(urlArray, func, options = {}) {\n  const promises = urlArray.map((url) => mapSubtree(url, func, options));\n  return await Promise.all(promises);\n}\n"],"mappings":";;AAgBA,MAAMA,QAAQ,GAAIC,KAAK,IAAKA,KAAK,IAAI,OAAOA,KAAK,KAAK,QAAQ;;AAK9D,OAAO,eAAeC,YAAY,CAACC,IAAI,EAAEC,IAAI,EAAgB;EAAA,IAAdC,OAAO,uEAAG,CAAC,CAAC;EACzD,OAAO,MAAMC,UAAU,CAACH,IAAI,EAAEC,IAAI,EAAEC,OAAO,CAAC;AAC9C;AAEA,OAAO,eAAeC,UAAU,CAACC,MAAM,EAAEH,IAAI,EAAEC,OAAO,EAAE;EACtD,IAAIG,KAAK,CAACC,OAAO,CAACF,MAAM,CAAC,EAAE;IACzB,OAAO,MAAMG,QAAQ,CAACH,MAAM,EAAEH,IAAI,EAAEC,OAAO,CAAC;EAC9C;EAEA,IAAIL,QAAQ,CAACO,MAAM,CAAC,EAAE;IACpB,OAAO,MAAMI,SAAS,CAACJ,MAAM,EAAEH,IAAI,EAAEC,OAAO,CAAC;EAC/C;;EAGA,MAAMO,GAAG,GAAGL,MAAM;EAClB,OAAO,MAAMH,IAAI,CAACQ,GAAG,EAAEP,OAAO,CAAC;AACjC;;AAIA,eAAeM,SAAS,CAACJ,MAAM,EAAEH,IAAI,EAAEC,OAAO,EAAE;EAC9C,MAAMQ,QAAwB,GAAG,EAAE;EACnC,MAAMC,MAAM,GAAG,CAAC,CAAC;EAEjB,KAAK,MAAMC,GAAG,IAAIR,MAAM,EAAE;IACxB,MAAMK,GAAG,GAAGL,MAAM,CAACQ,GAAG,CAAC;IACvB,MAAMC,OAAO,GAAGV,UAAU,CAACM,GAAG,EAAER,IAAI,EAAEC,OAAO,CAAC,CAACY,IAAI,CAAEhB,KAAK,IAAK;MAC7Da,MAAM,CAACC,GAAG,CAAC,GAAGd,KAAK;IACrB,CAAC,CAAC;IACFY,QAAQ,CAACK,IAAI,CAACF,OAAO,CAAC;EACxB;EAEA,MAAMG,OAAO,CAACC,GAAG,CAACP,QAAQ,CAAC;EAE3B,OAAOC,MAAM;AACf;AAEA,eAAeJ,QAAQ,CAACW,QAAQ,EAAEjB,IAAI,EAAgB;EAAA,IAAdC,OAAO,uEAAG,CAAC,CAAC;EAClD,MAAMQ,QAAQ,GAAGQ,QAAQ,CAACC,GAAG,CAAEV,GAAG,IAAKN,UAAU,CAACM,GAAG,EAAER,IAAI,EAAEC,OAAO,CAAC,CAAC;EACtE,OAAO,MAAMc,OAAO,CAACC,GAAG,CAACP,QAAQ,CAAC;AACpC"}

package/dist/esm/lib/texture-api/deep-load.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/texture-api/deep-load.ts"],"names":["asyncDeepMap","deepLoad","urlTree","load","options","url","shallowLoad","response","fetch","arrayBuffer"],"mappings":"AAAA,SAAQA,YAAR,QAA2B,kBAA3B;AAEA,OAAO,eAAeC,QAAf,CAAwBC,OAAxB,EAAiCC,IAAjC,EAAuCC,OAAvC,EAAgD;AACrD,SAAO,MAAMJ,YAAY,CAACE,OAAD,EAAWG,GAAD,IAASC,WAAW,CAACD,GAAD,EAAMF,IAAN,EAAYC,OAAZ,CAA9B,CAAzB;AACD;AAED,OAAO,eAAeE,WAAf,CAA2BD,GAA3B,EAAgCF,IAAhC,EAAsCC,OAAtC,EAA+C;AAEpD,QAAMG,QAAQ,GAAG,MAAMC,KAAK,CAACH,GAAD,EAAMD,OAAO,CAACI,KAAd,CAA5B;AACA,QAAMC,WAAW,GAAG,MAAMF,QAAQ,CAACE,WAAT,EAA1B;AACA,SAAO,MAAMN,IAAI,CAACM,WAAD,EAAcL,OAAd,CAAjB;AACD","sourcesContent":["import {asyncDeepMap} from './async-deep-map';\n\nexport async function deepLoad(urlTree, load, options) {\n  return await asyncDeepMap(urlTree, (url) => shallowLoad(url, load, options));\n}\n\nexport async function shallowLoad(url, load, options) {\n  // console.error('loading', url);\n  const response = await fetch(url, options.fetch);\n  const arrayBuffer = await response.arrayBuffer();\n  return await load(arrayBuffer, options);\n}\n"],"file":"deep-load.js"}
+{"version":3,"file":"deep-load.js","names":["asyncDeepMap","deepLoad","urlTree","load","options","url","shallowLoad","response","fetch","arrayBuffer"],"sources":["../../../../src/lib/texture-api/deep-load.ts"],"sourcesContent":["import {asyncDeepMap} from './async-deep-map';\n\nexport async function deepLoad(urlTree, load, options) {\n  return await asyncDeepMap(urlTree, (url) => shallowLoad(url, load, options));\n}\n\nexport async function shallowLoad(url, load, options) {\n  // console.error('loading', url);\n  const response = await fetch(url, options.fetch);\n  const arrayBuffer = await response.arrayBuffer();\n  return await load(arrayBuffer, options);\n}\n"],"mappings":"AAAA,SAAQA,YAAY,QAAO,kBAAkB;AAE7C,OAAO,eAAeC,QAAQ,CAACC,OAAO,EAAEC,IAAI,EAAEC,OAAO,EAAE;EACrD,OAAO,MAAMJ,YAAY,CAACE,OAAO,EAAGG,GAAG,IAAKC,WAAW,CAACD,GAAG,EAAEF,IAAI,EAAEC,OAAO,CAAC,CAAC;AAC9E;AAEA,OAAO,eAAeE,WAAW,CAACD,GAAG,EAAEF,IAAI,EAAEC,OAAO,EAAE;EAEpD,MAAMG,QAAQ,GAAG,MAAMC,KAAK,CAACH,GAAG,EAAED,OAAO,CAACI,KAAK,CAAC;EAChD,MAAMC,WAAW,GAAG,MAAMF,QAAQ,CAACE,WAAW,EAAE;EAChD,OAAO,MAAMN,IAAI,CAACM,WAAW,EAAEL,OAAO,CAAC;AACzC"}

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

@@ -1,22 +1,21 @@
 import { resolvePath, assert } from '@loaders.gl/loader-utils';
+
 export function generateUrl(getUrl, options, urlOptions) {
   let url = getUrl;
-
   if (typeof getUrl === 'function') {
-    url = getUrl({ ...options,
+    url = getUrl({
+      ...options,
       ...urlOptions
     });
   }
-
   assert(typeof url === 'string');
+
   const {
     baseUrl
   } = options;
-
   if (baseUrl) {
     url = baseUrl[baseUrl.length - 1] === '/' ? "".concat(baseUrl).concat(url) : "".concat(baseUrl, "/").concat(url);
   }
-
   return resolvePath(url);
 }
 //# sourceMappingURL=generate-url.js.map

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,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"}
+{"version":3,"file":"generate-url.js","names":["resolvePath","assert","generateUrl","getUrl","options","urlOptions","url","baseUrl","length"],"sources":["../../../../src/lib/texture-api/generate-url.ts"],"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"],"mappings":"AAAA,SAAQA,WAAW,EAAEC,MAAM,QAAO,0BAA0B;;AAG5D,OAAO,SAASC,WAAW,CAACC,MAAM,EAAEC,OAAO,EAAEC,UAAU,EAAE;EAEvD,IAAIC,GAAG,GAAGH,MAAM;EAChB,IAAI,OAAOA,MAAM,KAAK,UAAU,EAAE;IAChCG,GAAG,GAAGH,MAAM,CAAC;MAAC,GAAGC,OAAO;MAAE,GAAGC;IAAU,CAAC,CAAC;EAC3C;EACAJ,MAAM,CAAC,OAAOK,GAAG,KAAK,QAAQ,CAAC;;EAG/B,MAAM;IAACC;EAAO,CAAC,GAAGH,OAAO;EACzB,IAAIG,OAAO,EAAE;IACXD,GAAG,GAAGC,OAAO,CAACA,OAAO,CAACC,MAAM,GAAG,CAAC,CAAC,KAAK,GAAG,aAAMD,OAAO,SAAGD,GAAG,cAAQC,OAAO,cAAID,GAAG,CAAE;EACtF;EAEA,OAAON,WAAW,CAACM,GAAG,CAAC;AACzB"}

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

@@ -3,20 +3,22 @@ import parseImage from '../parsers/parse-image';
 import { getImageSize } from '../category-api/parsed-image-api';
 import { generateUrl } from './generate-url';
 import { deepLoad, shallowLoad } from './deep-load';
-export async function loadImage(getUrl, options = {}) {
+export async function loadImage(getUrl) {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   const imageUrls = await getImageUrls(getUrl, options);
   return await deepLoad(imageUrls, parseImage, options);
 }
-export async function getImageUrls(getUrl, options, urlOptions = {}) {
+export async function getImageUrls(getUrl, options) {
+  let urlOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   const mipLevels = options && options.image && options.image.mipLevels || 0;
   return mipLevels !== 0 ? await getMipmappedImageUrls(getUrl, mipLevels, options, urlOptions) : generateUrl(getUrl, options, urlOptions);
 }
-
 async function getMipmappedImageUrls(getUrl, mipLevels, options, urlOptions) {
   const urls = [];
 
   if (mipLevels === 'auto') {
-    const url = generateUrl(getUrl, options, { ...urlOptions,
+    const url = generateUrl(getUrl, options, {
+      ...urlOptions,
       lod: 0
     });
     const image = await shallowLoad(url, parseImage, options);
@@ -28,25 +30,26 @@ async function getMipmappedImageUrls(getUrl, mipLevels, options, urlOptions) {
       width,
       height
     });
+
     urls.push(url);
   }
 
   assert(mipLevels > 0);
-
   for (let mipLevel = urls.length; mipLevel < mipLevels; ++mipLevel) {
-    const url = generateUrl(getUrl, options, { ...urlOptions,
+    const url = generateUrl(getUrl, options, {
+      ...urlOptions,
       lod: mipLevel
     });
     urls.push(url);
   }
-
   return urls;
 }
 
-export function getMipLevels({
-  width,
-  height
-}) {
+export function getMipLevels(_ref) {
+  let {
+    width,
+    height
+  } = _ref;
   return 1 + Math.floor(Math.log2(Math.max(width, height)));
 }
 //# sourceMappingURL=load-image.js.map

package/dist/esm/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,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"}
+{"version":3,"file":"load-image.js","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"],"sources":["../../../../src/lib/texture-api/load-image.ts"],"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"],"mappings":"AAAA,SAAQA,MAAM,QAAO,0BAA0B;AAC/C,OAAOC,UAAU,MAAM,wBAAwB;AAC/C,SAAQC,YAAY,QAAO,kCAAkC;AAC7D,SAAQC,WAAW,QAAO,gBAAgB;AAC1C,SAAQC,QAAQ,EAAEC,WAAW,QAAO,aAAa;AAEjD,OAAO,eAAeC,SAAS,CAACC,MAAM,EAAgB;EAAA,IAAdC,OAAO,uEAAG,CAAC,CAAC;EAClD,MAAMC,SAAS,GAAG,MAAMC,YAAY,CAACH,MAAM,EAAEC,OAAO,CAAC;EACrD,OAAO,MAAMJ,QAAQ,CAACK,SAAS,EAAER,UAAU,EAAEO,OAAO,CAAC;AACvD;AAEA,OAAO,eAAeE,YAAY,CAACH,MAAM,EAAEC,OAAO,EAAmB;EAAA,IAAjBG,UAAU,uEAAG,CAAC,CAAC;EACjE,MAAMC,SAAS,GAAIJ,OAAO,IAAIA,OAAO,CAACK,KAAK,IAAIL,OAAO,CAACK,KAAK,CAACD,SAAS,IAAK,CAAC;EAC5E,OAAOA,SAAS,KAAK,CAAC,GAClB,MAAME,qBAAqB,CAACP,MAAM,EAAEK,SAAS,EAAEJ,OAAO,EAAEG,UAAU,CAAC,GACnER,WAAW,CAACI,MAAM,EAAEC,OAAO,EAAEG,UAAU,CAAC;AAC9C;AAEA,eAAeG,qBAAqB,CAACP,MAAM,EAAEK,SAAS,EAAEJ,OAAO,EAAEG,UAAU,EAAE;EAC3E,MAAMI,IAAc,GAAG,EAAE;;EAGzB,IAAIH,SAAS,KAAK,MAAM,EAAE;IACxB,MAAMI,GAAG,GAAGb,WAAW,CAACI,MAAM,EAAEC,OAAO,EAAE;MAAC,GAAGG,UAAU;MAAEM,GAAG,EAAE;IAAC,CAAC,CAAC;IACjE,MAAMJ,KAAK,GAAG,MAAMR,WAAW,CAACW,GAAG,EAAEf,UAAU,EAAEO,OAAO,CAAC;IAEzD,MAAM;MAACU,KAAK;MAAEC;IAAM,CAAC,GAAGjB,YAAY,CAACW,KAAK,CAAC;IAC3CD,SAAS,GAAGQ,YAAY,CAAC;MAACF,KAAK;MAAEC;IAAM,CAAC,CAAC;;IAGzCJ,IAAI,CAACM,IAAI,CAACL,GAAG,CAAC;EAChB;;EAGAhB,MAAM,CAACY,SAAS,GAAG,CAAC,CAAC;EAErB,KAAK,IAAIU,QAAQ,GAAGP,IAAI,CAACQ,MAAM,EAAED,QAAQ,GAAGV,SAAS,EAAE,EAAEU,QAAQ,EAAE;IACjE,MAAMN,GAAG,GAAGb,WAAW,CAACI,MAAM,EAAEC,OAAO,EAAE;MAAC,GAAGG,UAAU;MAAEM,GAAG,EAAEK;IAAQ,CAAC,CAAC;IACxEP,IAAI,CAACM,IAAI,CAACL,GAAG,CAAC;EAChB;EAEA,OAAOD,IAAI;AACb;;AAGA,OAAO,SAASK,YAAY,OAAkB;EAAA,IAAjB;IAACF,KAAK;IAAEC;EAAM,CAAC;EAC1C,OAAO,CAAC,GAAGK,IAAI,CAACC,KAAK,CAACD,IAAI,CAACE,IAAI,CAACF,IAAI,CAACG,GAAG,CAACT,KAAK,EAAEC,MAAM,CAAC,CAAC,CAAC;AAC3D"}

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

@@ -1,2 +1,3 @@
-export const VERSION = typeof "3.3.0-alpha.1" !== 'undefined' ? "3.3.0-alpha.1" : 'latest';
+
+export const VERSION = typeof "3.3.0-alpha.11" !== 'undefined' ? "3.3.0-alpha.11" : '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,"file":"version.js","names":["VERSION"],"sources":["../../../../src/lib/utils/version.ts"],"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"],"mappings":";AAGA,OAAO,MAAMA,OAAO,GAAG,uBAAkB,KAAK,WAAW,sBAAiB,QAAQ"}

package/dist/esm/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"types.js"}
+{"version":3,"file":"types.js","names":[],"sources":["../../src/types.ts"],"sourcesContent":["/**\n * data images\n */\nexport type ImageDataType = {\n  data: Uint8Array;\n  width: number;\n  height: number;\n  compressed?: boolean;\n};\n\n/**\n * Supported Image Types\n */\nexport type ImageType = ImageBitmap | typeof Image | ImageDataType;\n\n/**\n * Image type string used to control or determine the type of images returned from ImageLoader\n */\nexport type ImageTypeEnum = 'imagebitmap' | 'image' | 'data';\n"],"mappings":""}

package/dist/image-loader.d.ts

@@ -1,6 +1,6 @@
 import type { LoaderOptions, LoaderWithParser } from '@loaders.gl/loader-utils';
 import parseImage from './lib/parsers/parse-image';
-export declare type ImageLoaderOptions = LoaderOptions & {
+export type ImageLoaderOptions = LoaderOptions & {
     image?: {
         type?: 'auto' | 'data' | 'imagebitmap' | 'image';
         decode?: boolean;

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

@@ -1 +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"}
+{"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,MAAM,MAAM,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/lib/category-api/binary-image-api.d.ts

@@ -1,5 +1,5 @@
 /** MIME type, width and height extracted from binary compressed image data */
-export declare type BinaryImageMetadata = {
+export type BinaryImageMetadata = {
     mimeType: string;
     width: number;
     height: number;

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

@@ -1 +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"}
+{"version":3,"file":"binary-image-api.d.ts","sourceRoot":"","sources":["../../../src/lib/category-api/binary-image-api.ts"],"names":[],"mappings":"AAQA,8EAA8E;AAC9E,MAAM,MAAM,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/types.d.ts

@@ -1,7 +1,7 @@
 /**
  * data images
  */
-export declare type ImageDataType = {
+export type ImageDataType = {
     data: Uint8Array;
     width: number;
     height: number;
@@ -10,9 +10,9 @@ export declare type ImageDataType = {
 /**
  * Supported Image Types
  */
-export declare type ImageType = ImageBitmap | typeof Image | ImageDataType;
+export type ImageType = ImageBitmap | typeof Image | ImageDataType;
 /**
  * Image type string used to control or determine the type of images returned from ImageLoader
  */
-export declare type ImageTypeEnum = 'imagebitmap' | 'image' | 'data';
+export type ImageTypeEnum = 'imagebitmap' | 'image' | 'data';
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,aAAa,GAAG;IAC1B,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF;;GAEG;AACH,oBAAY,SAAS,GAAG,WAAW,GAAG,OAAO,KAAK,GAAG,aAAa,CAAC;AAEnE;;GAEG;AACH,oBAAY,aAAa,GAAG,aAAa,GAAG,OAAO,GAAG,MAAM,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,WAAW,GAAG,OAAO,KAAK,GAAG,aAAa,CAAC;AAEnE;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,aAAa,GAAG,OAAO,GAAG,MAAM,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/images",
-  "version": "3.3.0-alpha.1",
+  "version": "3.3.0-alpha.11",
   "description": "Framework-independent loaders and writers for images (PNG, JPG, ...)",
   "license": "MIT",
   "publishConfig": {
@@ -32,7 +32,10 @@
     "build-bundle": "esbuild src/bundle.ts --outfile=dist/dist.min.js --bundle --minify --sourcemap"
   },
   "dependencies": {
-    "@loaders.gl/loader-utils": "3.3.0-alpha.1"
+    "@loaders.gl/loader-utils": "3.3.0-alpha.11"
   },
-  "gitHead": "85ed2df7d17dd0d204c8bd8feb44779f70bc693b"
+  "gitHead": "1863a8875f63d578c0fdf5bdb3b7d6827f799db9",
+  "devDependencies": {
+    "@types/get-pixels": "^3.3.2"
+  }
 }