@loaders.gl/images 3.1.3 → 4.0.0-alpha.5

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/lib/category-api/image-type.ts"],"names":["isBrowser","_parseImageNode","globalThis","IMAGE_SUPPORTED","Image","IMAGE_BITMAP_SUPPORTED","ImageBitmap","NODE_IMAGE_SUPPORTED","Boolean","DATA_SUPPORTED","isImageTypeSupported","type","Error","getDefaultImageType"],"mappings":"AAAA,SAAQA,SAAR,QAAwB,0BAAxB;AAIA,MAAM;AAACC,EAAAA;AAAD,IAAoBC,UAA1B;AAEA,MAAMC,eAAe,GAAG,OAAOC,KAAP,KAAiB,WAAzC;AACA,MAAMC,sBAAsB,GAAG,OAAOC,WAAP,KAAuB,WAAtD;AACA,MAAMC,oBAAoB,GAAGC,OAAO,CAACP,eAAD,CAApC;AACA,MAAMQ,cAAc,GAAGT,SAAS,GAAG,IAAH,GAAUO,oBAA1C;AAMA,OAAO,SAASG,oBAAT,CAA8BC,IAA9B,EAAqD;AAC1D,UAAQA,IAAR;AACE,SAAK,MAAL;AAEE,aAAON,sBAAsB,IAAIF,eAA1B,IAA6CM,cAApD;;AAEF,SAAK,aAAL;AACE,aAAOJ,sBAAP;;AACF,SAAK,OAAL;AACE,aAAOF,eAAP;;AACF,SAAK,MAAL;AACE,aAAOM,cAAP;;AAEF;AACE,YAAM,IAAIG,KAAJ,qCAAuCD,IAAvC,wCAAN;AAbJ;AAeD;AAMD,OAAO,SAASE,mBAAT,GAA8C;AACnD,MAAIR,sBAAJ,EAA4B;AAC1B,WAAO,aAAP;AACD;;AACD,MAAIF,eAAJ,EAAqB;AACnB,WAAO,OAAP;AACD;;AACD,MAAIM,cAAJ,EAAoB;AAClB,WAAO,MAAP;AACD;;AAGD,QAAM,IAAIG,KAAJ,CAAU,iEAAV,CAAN;AACD","sourcesContent":["import {isBrowser} from '@loaders.gl/loader-utils';\nimport type {ImageTypeEnum} from '../../types';\n\n// @ts-ignore TS2339: Property does not exist on type\nconst {_parseImageNode} = globalThis;\n\nconst IMAGE_SUPPORTED = typeof Image !== 'undefined'; // NOTE: \"false\" positives if jsdom is installed\nconst IMAGE_BITMAP_SUPPORTED = typeof ImageBitmap !== 'undefined';\nconst NODE_IMAGE_SUPPORTED = Boolean(_parseImageNode);\nconst DATA_SUPPORTED = isBrowser ? true : NODE_IMAGE_SUPPORTED;\n\n/**\n * Checks if a loaders.gl image type is supported\n * @param type image type string\n */\nexport function isImageTypeSupported(type: string): boolean {\n  switch (type) {\n    case 'auto':\n      // Should only ever be false in Node.js, if polyfills have not been installed...\n      return IMAGE_BITMAP_SUPPORTED || IMAGE_SUPPORTED || DATA_SUPPORTED;\n\n    case 'imagebitmap':\n      return IMAGE_BITMAP_SUPPORTED;\n    case 'image':\n      return IMAGE_SUPPORTED;\n    case 'data':\n      return DATA_SUPPORTED;\n\n    default:\n      throw new Error(`@loaders.gl/images: image ${type} not supported in this environment`);\n  }\n}\n\n/**\n * Returns the \"most performant\" supported image type on this platform\n * @returns image type string\n */\nexport function getDefaultImageType(): ImageTypeEnum {\n  if (IMAGE_BITMAP_SUPPORTED) {\n    return 'imagebitmap';\n  }\n  if (IMAGE_SUPPORTED) {\n    return 'image';\n  }\n  if (DATA_SUPPORTED) {\n    return 'data';\n  }\n\n  // This should only happen in Node.js\n  throw new Error('Install \\'@loaders.gl/polyfills\\' to parse images under Node.js');\n}\n"],"file":"image-type.js"}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/lib/category-api/parsed-image-api.ts"],"names":["isImage","image","Boolean","getImageTypeOrNull","deleteImage","getImageType","close","format","Error","getImageSize","getImageData","canvas","document","createElement","context","getContext","width","height","drawImage","ImageBitmap","Image","data"],"mappings":"AAEA,OAAO,SAASA,OAAT,CAAiBC,KAAjB,EAA4C;AACjD,SAAOC,OAAO,CAACC,kBAAkB,CAACF,KAAD,CAAnB,CAAd;AACD;AAED,OAAO,SAASG,WAAT,CAAqBH,KAArB,EAA6C;AAClD,UAAQI,YAAY,CAACJ,KAAD,CAApB;AACE,SAAK,aAAL;AACGA,MAAAA,KAAD,CAAuBK,KAAvB;AACA;;AACF;AAJF;AAOD;AAED,OAAO,SAASD,YAAT,CAAsBJ,KAAtB,EAAuD;AAC5D,QAAMM,MAAM,GAAGJ,kBAAkB,CAACF,KAAD,CAAjC;;AACA,MAAI,CAACM,MAAL,EAAa;AACX,UAAM,IAAIC,KAAJ,CAAU,cAAV,CAAN;AACD;;AACD,SAAOD,MAAP;AACD;AAED,OAAO,SAASE,YAAT,CAAsBR,KAAtB,EAAyE;AAC9E,SAAOS,YAAY,CAACT,KAAD,CAAnB;AACD;AAED,OAAO,SAASS,YAAT,CAAsBT,KAAtB,EAAmE;AACxE,UAAQI,YAAY,CAACJ,KAAD,CAApB;AACE,SAAK,MAAL;AACE,aAAOA,KAAP;;AAEF,SAAK,OAAL;AACA,SAAK,aAAL;AAEE,YAAMU,MAAM,GAAGC,QAAQ,CAACC,aAAT,CAAuB,QAAvB,CAAf;AAEA,YAAMC,OAAO,GAAGH,MAAM,CAACI,UAAP,CAAkB,IAAlB,CAAhB;;AACA,UAAI,CAACD,OAAL,EAAc;AACZ,cAAM,IAAIN,KAAJ,CAAU,cAAV,CAAN;AACD;;AAEDG,MAAAA,MAAM,CAACK,KAAP,GAAef,KAAK,CAACe,KAArB;AAEAL,MAAAA,MAAM,CAACM,MAAP,GAAgBhB,KAAK,CAACgB,MAAtB;AAEAH,MAAAA,OAAO,CAACI,SAAR,CAAkBjB,KAAlB,EAAyB,CAAzB,EAA4B,CAA5B;AAEA,aAAOa,OAAO,CAACJ,YAAR,CAAqB,CAArB,EAAwB,CAAxB,EAA2BT,KAAK,CAACe,KAAjC,EAAwCf,KAAK,CAACgB,MAA9C,CAAP;;AAEF;AACE,YAAM,IAAIT,KAAJ,CAAU,cAAV,CAAN;AAvBJ;AAyBD;;AAKD,SAASL,kBAAT,CAA4BF,KAA5B,EAAmC;AACjC,MAAI,OAAOkB,WAAP,KAAuB,WAAvB,IAAsClB,KAAK,YAAYkB,WAA3D,EAAwE;AACtE,WAAO,aAAP;AACD;;AACD,MAAI,OAAOC,KAAP,KAAiB,WAAjB,IAAgCnB,KAAK,YAAYmB,KAArD,EAA4D;AAC1D,WAAO,OAAP;AACD;;AACD,MAAInB,KAAK,IAAI,OAAOA,KAAP,KAAiB,QAA1B,IAAsCA,KAAK,CAACoB,IAA5C,IAAoDpB,KAAK,CAACe,KAA1D,IAAmEf,KAAK,CAACgB,MAA7E,EAAqF;AACnF,WAAO,MAAP;AACD;;AACD,SAAO,IAAP;AACD","sourcesContent":["import type {ImageType, ImageTypeEnum, ImageDataType} from '../../types';\n\nexport function isImage(image: ImageType): boolean {\n  return Boolean(getImageTypeOrNull(image));\n}\n\nexport function deleteImage(image: ImageType): void {\n  switch (getImageType(image)) {\n    case 'imagebitmap':\n      (image as ImageBitmap).close();\n      break;\n    default:\n    // Nothing to do for images and image data objects\n  }\n}\n\nexport function getImageType(image: ImageType): ImageTypeEnum {\n  const format = getImageTypeOrNull(image);\n  if (!format) {\n    throw new Error('Not an image');\n  }\n  return format;\n}\n\nexport function getImageSize(image: ImageType): {width: number; height: number} {\n  return getImageData(image);\n}\n\nexport function getImageData(image: ImageType): ImageDataType | ImageData {\n  switch (getImageType(image)) {\n    case 'data':\n      return image as unknown as ImageData;\n\n    case 'image':\n    case 'imagebitmap':\n      // Extract the image data from the image via a canvas\n      const canvas = document.createElement('canvas');\n      // TODO - reuse the canvas?\n      const context = canvas.getContext('2d');\n      if (!context) {\n        throw new Error('getImageData');\n      }\n      // @ts-ignore\n      canvas.width = image.width;\n      // @ts-ignore\n      canvas.height = image.height;\n      // @ts-ignore\n      context.drawImage(image, 0, 0);\n      // @ts-ignore\n      return context.getImageData(0, 0, image.width, image.height);\n\n    default:\n      throw new Error('getImageData');\n  }\n}\n\n// PRIVATE\n\n// eslint-disable-next-line complexity\nfunction getImageTypeOrNull(image) {\n  if (typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap) {\n    return 'imagebitmap';\n  }\n  if (typeof Image !== 'undefined' && image instanceof Image) {\n    return 'image';\n  }\n  if (image && typeof image === 'object' && image.data && image.width && image.height) {\n    return 'data';\n  }\n  return null;\n}\n"],"file":"parsed-image-api.js"}

package/dist/esm/lib/encoders/encode-image.js

@@ -1,69 +0,0 @@
-import { getImageSize } from '../category-api/parsed-image-api';
-const {
-  _encodeImageNode
-} = globalThis;
-export async function encodeImage(image, options) {
-  options = options || {};
-  options.image = options.image || {};
-  return _encodeImageNode ? _encodeImageNode(image, {
-    type: options.image.mimeType
-  }) : encodeImageInBrowser(image, options);
-}
-let qualityParamSupported = true;
-
-async function encodeImageInBrowser(image, options) {
-  const {
-    mimeType,
-    jpegQuality
-  } = options.image;
-  const {
-    width,
-    height
-  } = getImageSize(image);
-  const canvas = document.createElement('canvas');
-  canvas.width = width;
-  canvas.height = height;
-  drawImageToCanvas(image, canvas);
-  const blob = await new Promise(resolve => {
-    if (jpegQuality && qualityParamSupported) {
-      try {
-        canvas.toBlob(resolve, mimeType, jpegQuality);
-        return;
-      } catch (error) {
-        qualityParamSupported = false;
-      }
-    }
-
-    canvas.toBlob(resolve, mimeType);
-  });
-
-  if (!blob) {
-    throw new Error('image encoding failed');
-  }
-
-  return await blob.arrayBuffer();
-}
-
-function drawImageToCanvas(image, canvas, x = 0, y = 0) {
-  if (x === 0 && y === 0 && typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap) {
-    const context = canvas.getContext('bitmaprenderer');
-
-    if (context) {
-      context.transferFromImageBitmap(image);
-      return canvas;
-    }
-  }
-
-  const context = canvas.getContext('2d');
-
-  if (image.data) {
-    const clampedArray = new Uint8ClampedArray(image.data);
-    const imageData = new ImageData(clampedArray, image.width, image.height);
-    context.putImageData(imageData, 0, 0);
-    return canvas;
-  }
-
-  context.drawImage(image, 0, 0);
-  return canvas;
-}
-//# sourceMappingURL=encode-image.js.map

package/dist/esm/lib/encoders/encode-image.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/lib/encoders/encode-image.ts"],"names":["getImageSize","_encodeImageNode","globalThis","encodeImage","image","options","type","mimeType","encodeImageInBrowser","qualityParamSupported","jpegQuality","width","height","canvas","document","createElement","drawImageToCanvas","blob","Promise","resolve","toBlob","error","Error","arrayBuffer","x","y","ImageBitmap","context","getContext","transferFromImageBitmap","data","clampedArray","Uint8ClampedArray","imageData","ImageData","putImageData","drawImage"],"mappings":"AACA,SAAQA,YAAR,QAA2B,kCAA3B;AAGA,MAAM;AAACC,EAAAA;AAAD,IAAqBC,UAA3B;AAUA,OAAO,eAAeC,WAAf,CACLC,KADK,EAELC,OAFK,EAGiB;AACtBA,EAAAA,OAAO,GAAGA,OAAO,IAAI,EAArB;AACAA,EAAAA,OAAO,CAACD,KAAR,GAAgBC,OAAO,CAACD,KAAR,IAAkB,EAAlC;AAEA,SAAOH,gBAAgB,GACnBA,gBAAgB,CAACG,KAAD,EAAQ;AAACE,IAAAA,IAAI,EAAED,OAAO,CAACD,KAAR,CAAcG;AAArB,GAAR,CADG,GAEnBC,oBAAoB,CAACJ,KAAD,EAAQC,OAAR,CAFxB;AAGD;AAGD,IAAII,qBAAqB,GAAG,IAA5B;;AASA,eAAeD,oBAAf,CAAoCJ,KAApC,EAA2CC,OAA3C,EAAoD;AAClD,QAAM;AAACE,IAAAA,QAAD;AAAWG,IAAAA;AAAX,MAA0BL,OAAO,CAACD,KAAxC;AAEA,QAAM;AAACO,IAAAA,KAAD;AAAQC,IAAAA;AAAR,MAAkBZ,YAAY,CAACI,KAAD,CAApC;AAGA,QAAMS,MAAM,GAAGC,QAAQ,CAACC,aAAT,CAAuB,QAAvB,CAAf;AACAF,EAAAA,MAAM,CAACF,KAAP,GAAeA,KAAf;AACAE,EAAAA,MAAM,CAACD,MAAP,GAAgBA,MAAhB;AAEAI,EAAAA,iBAAiB,CAACZ,KAAD,EAAQS,MAAR,CAAjB;AAGA,QAAMI,IAAI,GAAG,MAAM,IAAIC,OAAJ,CAA0BC,OAAD,IAAa;AAEvD,QAAIT,WAAW,IAAID,qBAAnB,EAA0C;AACxC,UAAI;AACFI,QAAAA,MAAM,CAACO,MAAP,CAAcD,OAAd,EAAuBZ,QAAvB,EAAiCG,WAAjC;AACA;AACD,OAHD,CAGE,OAAOW,KAAP,EAAc;AACdZ,QAAAA,qBAAqB,GAAG,KAAxB;AACD;AACF;;AACDI,IAAAA,MAAM,CAACO,MAAP,CAAcD,OAAd,EAAuBZ,QAAvB;AACD,GAXkB,CAAnB;;AAaA,MAAI,CAACU,IAAL,EAAW;AACT,UAAM,IAAIK,KAAJ,CAAU,uBAAV,CAAN;AACD;;AAED,SAAO,MAAML,IAAI,CAACM,WAAL,EAAb;AACD;;AAED,SAASP,iBAAT,CAA2BZ,KAA3B,EAAkCS,MAAlC,EAA0CW,CAAC,GAAG,CAA9C,EAAiDC,CAAC,GAAG,CAArD,EAAwD;AAEtD,MAAID,CAAC,KAAK,CAAN,IAAWC,CAAC,KAAK,CAAjB,IAAsB,OAAOC,WAAP,KAAuB,WAA7C,IAA4DtB,KAAK,YAAYsB,WAAjF,EAA8F;AAC5F,UAAMC,OAAO,GAAGd,MAAM,CAACe,UAAP,CAAkB,gBAAlB,CAAhB;;AACA,QAAID,OAAJ,EAAa;AAEXA,MAAAA,OAAO,CAACE,uBAAR,CAAgCzB,KAAhC;AACA,aAAOS,MAAP;AACD;AACF;;AAGD,QAAMc,OAAO,GAAGd,MAAM,CAACe,UAAP,CAAkB,IAAlB,CAAhB;;AACA,MAAIxB,KAAK,CAAC0B,IAAV,EAAgB;AAEd,UAAMC,YAAY,GAAG,IAAIC,iBAAJ,CAAsB5B,KAAK,CAAC0B,IAA5B,CAArB;AACA,UAAMG,SAAS,GAAG,IAAIC,SAAJ,CAAcH,YAAd,EAA4B3B,KAAK,CAACO,KAAlC,EAAyCP,KAAK,CAACQ,MAA/C,CAAlB;AACAe,IAAAA,OAAO,CAACQ,YAAR,CAAqBF,SAArB,EAAgC,CAAhC,EAAmC,CAAnC;AACA,WAAOpB,MAAP;AACD;;AAGDc,EAAAA,OAAO,CAACS,SAAR,CAAkBhC,KAAlB,EAAyB,CAAzB,EAA4B,CAA5B;AACA,SAAOS,MAAP;AACD","sourcesContent":["// Image loading/saving for browser and Node.js\nimport {getImageSize} from '../category-api/parsed-image-api';\n\n// @ts-ignore TS2339: Property does not exist on type\nconst {_encodeImageNode} = globalThis;\n\n/**\n * Returns data bytes representing a compressed image in PNG or JPG format,\n * This data can be saved using file system (f) methods or used in a request.\n * @param image - ImageBitmap Image or Canvas\n * @param options\n * param opt.type='png' - png, jpg or image/png, image/jpg are valid\n * param mimeType= - Whether to include a data URI header\n */\nexport async function encodeImage(\n  image: any,\n  options?: {[key: string]: any}\n): Promise<ArrayBuffer> {\n  options = options || {};\n  options.image = options.image || ({} as {[key: string]: any});\n\n  return _encodeImageNode\n    ? _encodeImageNode(image, {type: options.image.mimeType})\n    : encodeImageInBrowser(image, options);\n}\n\n// In case we get exceptions from canvas.toBlob(resolve, type, quality)\nlet qualityParamSupported = true;\n\n/**\n *\n * @param image\n * @param options\n * @note Based on canvas.toBlob\n * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob\n */\nasync function encodeImageInBrowser(image, options) {\n  const {mimeType, jpegQuality} = options.image;\n\n  const {width, height} = getImageSize(image);\n\n  // create a canvas and resize it to the size of our image\n  const canvas = document.createElement('canvas');\n  canvas.width = width;\n  canvas.height = height;\n\n  drawImageToCanvas(image, canvas);\n\n  // The actual encoding is done asynchronously with `canvas.toBlob()`\n  const blob = await new Promise<Blob | null>((resolve) => {\n    // get it back as a Blob\n    if (jpegQuality && qualityParamSupported) {\n      try {\n        canvas.toBlob(resolve, mimeType, jpegQuality);\n        return;\n      } catch (error) {\n        qualityParamSupported = false;\n      }\n    }\n    canvas.toBlob(resolve, mimeType);\n  });\n\n  if (!blob) {\n    throw new Error('image encoding failed');\n  }\n\n  return await blob.arrayBuffer();\n}\n\nfunction drawImageToCanvas(image, canvas, x = 0, y = 0) {\n  // Try optimized path for ImageBitmaps via bitmaprenderer context\n  if (x === 0 && y === 0 && typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap) {\n    const context = canvas.getContext('bitmaprenderer');\n    if (context) {\n      // transfer the ImageBitmap to it\n      context.transferFromImageBitmap(image);\n      return canvas;\n    }\n  }\n\n  // Available on most platforms, except IE11 and Andriod WebViews...\n  const context = canvas.getContext('2d');\n  if (image.data) {\n    // ImageData constructor expects clamped array even though getImageData does not return a clamped array...\n    const clampedArray = new Uint8ClampedArray(image.data);\n    const imageData = new ImageData(clampedArray, image.width, image.height);\n    context.putImageData(imageData, 0, 0);\n    return canvas;\n  }\n\n  // Fall back to generic image/image bitmap rendering path\n  context.drawImage(image, 0, 0);\n  return canvas;\n}\n"],"file":"encode-image.js"}

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

@@ -1,52 +0,0 @@
-import { assert } from '@loaders.gl/loader-utils';
-import { isImageTypeSupported, getDefaultImageType } from '../category-api/image-type';
-import { getImageData } from '../category-api/parsed-image-api';
-import parseToImage from './parse-to-image';
-import parseToImageBitmap from './parse-to-image-bitmap';
-import parseToNodeImage from './parse-to-node-image';
-export default async function parseImage(arrayBuffer, options, context) {
-  options = options || {};
-  const imageOptions = options.image || {};
-  const imageType = imageOptions.type || 'auto';
-  const {
-    url
-  } = context || {};
-  const loadType = getLoadableImageType(imageType);
-  let image;
-
-  switch (loadType) {
-    case 'imagebitmap':
-      image = await parseToImageBitmap(arrayBuffer, options, url);
-      break;
-
-    case 'image':
-      image = await parseToImage(arrayBuffer, options, url);
-      break;
-
-    case 'data':
-      image = await parseToNodeImage(arrayBuffer, options);
-      break;
-
-    default:
-      assert(false);
-  }
-
-  if (imageType === 'data') {
-    image = getImageData(image);
-  }
-
-  return image;
-}
-
-function getLoadableImageType(type) {
-  switch (type) {
-    case 'auto':
-    case 'data':
-      return getDefaultImageType();
-
-    default:
-      isImageTypeSupported(type);
-      return type;
-  }
-}
-//# sourceMappingURL=parse-image.js.map

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

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

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

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

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

@@ -1,34 +0,0 @@
-import { getBlobOrSVGDataUrl } from './svg-utils';
-export default async function parseToImage(arrayBuffer, options, url) {
-  const blobOrDataUrl = getBlobOrSVGDataUrl(arrayBuffer, url);
-  const URL = self.URL || self.webkitURL;
-  const objectUrl = typeof blobOrDataUrl !== 'string' && URL.createObjectURL(blobOrDataUrl);
-
-  try {
-    return await loadToImage(objectUrl || blobOrDataUrl, options);
-  } finally {
-    if (objectUrl) {
-      URL.revokeObjectURL(objectUrl);
-    }
-  }
-}
-export async function loadToImage(url, options) {
-  const image = new Image();
-  image.src = url;
-
-  if (options.image && options.image.decode && image.decode) {
-    await image.decode();
-    return image;
-  }
-
-  return await new Promise((resolve, reject) => {
-    try {
-      image.onload = () => resolve(image);
-
-      image.onerror = err => reject(new Error("Could not load image ".concat(url, ": ").concat(err)));
-    } catch (error) {
-      reject(error);
-    }
-  });
-}
-//# sourceMappingURL=parse-to-image.js.map

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

@@ -1 +0,0 @@
-{"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/parse-to-node-image.js

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

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

@@ -1,32 +0,0 @@
-const SVG_DATA_URL_PATTERN = /^data:image\/svg\+xml/;
-const SVG_URL_PATTERN = /\.svg((\?|#).*)?$/;
-export function isSVG(url) {
-  return url && (SVG_DATA_URL_PATTERN.test(url) || SVG_URL_PATTERN.test(url));
-}
-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));
-      }
-    } 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 +0,0 @@
-{"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/async-deep-map.js

@@ -1,39 +0,0 @@
-const isObject = value => value && typeof value === 'object';
-
-export async function asyncDeepMap(tree, func, options = {}) {
-  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);
-  }
-
-  const url = object;
-  return await func(url, 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 => {
-      values[key] = value;
-    });
-    promises.push(promise);
-  }
-
-  await Promise.all(promises);
-  return values;
-}
-
-async function mapArray(urlArray, func, options = {}) {
-  const promises = urlArray.map(url => mapSubtree(url, func, options));
-  return await Promise.all(promises);
-}
-//# sourceMappingURL=async-deep-map.js.map

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

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

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

@@ -1,10 +0,0 @@
-import { asyncDeepMap } from './async-deep-map';
-export async function deepLoad(urlTree, load, options) {
-  return await asyncDeepMap(urlTree, url => shallowLoad(url, load, options));
-}
-export async function shallowLoad(url, load, options) {
-  const response = await fetch(url, options.fetch);
-  const arrayBuffer = await response.arrayBuffer();
-  return await load(arrayBuffer, options);
-}
-//# sourceMappingURL=deep-load.js.map

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

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

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

@@ -1,22 +0,0 @@
-import { resolvePath, assert } from '@loaders.gl/loader-utils';
-export function generateUrl(getUrl, options, urlOptions) {
-  let url = getUrl;
-
-  if (typeof getUrl === 'function') {
-    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 +0,0 @@
-{"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/texture-api/load-image.js

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

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

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

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/lib/utils/version.ts"],"names":["VERSION"],"mappings":"AAGA,OAAO,MAAMA,OAAO,GAAG,mBAAuB,WAAvB,aAAmD,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/esm/types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.js.map

package/dist/esm/types.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"types.js"}