@loaders.gl/images 3.0.13 → 3.0.14

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

@@ -7,46 +7,118 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = parseToImageBitmap;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 var _svgUtils = require("./svg-utils");
 
 var _parseToImage = _interopRequireDefault(require("./parse-to-image"));
 
-const EMPTY_OBJECT = {};
-let imagebitmapOptionsSupported = true;
+var EMPTY_OBJECT = {};
+var imagebitmapOptionsSupported = true;
 
-async function parseToImageBitmap(arrayBuffer, options, url) {
-  let blob;
+function parseToImageBitmap(_x, _x2, _x3) {
+  return _parseToImageBitmap.apply(this, arguments);
+}
 
-  if ((0, _svgUtils.isSVG)(url)) {
-    const image = await (0, _parseToImage.default)(arrayBuffer, options, url);
-    blob = image;
-  } else {
-    blob = (0, _svgUtils.getBlob)(arrayBuffer, url);
-  }
+function _parseToImageBitmap() {
+  _parseToImageBitmap = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(arrayBuffer, options, url) {
+    var blob, image, imagebitmapOptions;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            if (!(0, _svgUtils.isSVG)(url)) {
+              _context.next = 7;
+              break;
+            }
+
+            _context.next = 3;
+            return (0, _parseToImage.default)(arrayBuffer, options, url);
 
-  const imagebitmapOptions = options && options.imagebitmap;
-  return await safeCreateImageBitmap(blob, imagebitmapOptions);
+          case 3:
+            image = _context.sent;
+            blob = image;
+            _context.next = 8;
+            break;
+
+          case 7:
+            blob = (0, _svgUtils.getBlob)(arrayBuffer, url);
+
+          case 8:
+            imagebitmapOptions = options && options.imagebitmap;
+            _context.next = 11;
+            return safeCreateImageBitmap(blob, imagebitmapOptions);
+
+          case 11:
+            return _context.abrupt("return", _context.sent);
+
+          case 12:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _parseToImageBitmap.apply(this, arguments);
 }
 
-async function safeCreateImageBitmap(blob, imagebitmapOptions = null) {
-  if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) {
-    imagebitmapOptions = null;
-  }
+function safeCreateImageBitmap(_x4) {
+  return _safeCreateImageBitmap.apply(this, arguments);
+}
 
-  if (imagebitmapOptions) {
-    try {
-      return await createImageBitmap(blob, imagebitmapOptions);
-    } catch (error) {
-      console.warn(error);
-      imagebitmapOptionsSupported = false;
-    }
-  }
+function _safeCreateImageBitmap() {
+  _safeCreateImageBitmap = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2(blob) {
+    var imagebitmapOptions,
+        _args2 = arguments;
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            imagebitmapOptions = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : null;
+
+            if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) {
+              imagebitmapOptions = null;
+            }
+
+            if (!imagebitmapOptions) {
+              _context2.next = 13;
+              break;
+            }
+
+            _context2.prev = 3;
+            _context2.next = 6;
+            return createImageBitmap(blob, imagebitmapOptions);
+
+          case 6:
+            return _context2.abrupt("return", _context2.sent);
+
+          case 9:
+            _context2.prev = 9;
+            _context2.t0 = _context2["catch"](3);
+            console.warn(_context2.t0);
+            imagebitmapOptionsSupported = false;
+
+          case 13:
+            _context2.next = 15;
+            return createImageBitmap(blob);
+
+          case 15:
+            return _context2.abrupt("return", _context2.sent);
 
-  return await createImageBitmap(blob);
+          case 16:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2, null, [[3, 9]]);
+  }));
+  return _safeCreateImageBitmap.apply(this, arguments);
 }
 
 function isEmptyObject(object) {
-  for (const key in object || EMPTY_OBJECT) {
+  for (var key in object || EMPTY_OBJECT) {
     return false;
   }
 

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/parsers/parse-to-image-bitmap.ts"],"names":["EMPTY_OBJECT","imagebitmapOptionsSupported","parseToImageBitmap","arrayBuffer","options","url","blob","image","imagebitmapOptions","imagebitmap","safeCreateImageBitmap","isEmptyObject","createImageBitmap","error","console","warn","object","key"],"mappings":";;;;;;;;;AAAA;;AACA;;AAEA,MAAMA,YAAY,GAAG,EAArB;AAEA,IAAIC,2BAA2B,GAAG,IAAlC;;AASe,eAAeC,kBAAf,CAAkCC,WAAlC,EAA+CC,OAA/C,EAAwDC,GAAxD,EAA6D;AAC1E,MAAIC,IAAJ;;AAGA,MAAI,qBAAMD,GAAN,CAAJ,EAAgB;AAEd,UAAME,KAAK,GAAG,MAAM,2BAAaJ,WAAb,EAA0BC,OAA1B,EAAmCC,GAAnC,CAApB;AACAC,IAAAA,IAAI,GAAGC,KAAP;AACD,GAJD,MAIO;AAELD,IAAAA,IAAI,GAAG,uBAAQH,WAAR,EAAqBE,GAArB,CAAP;AACD;;AAED,QAAMG,kBAAkB,GAAGJ,OAAO,IAAIA,OAAO,CAACK,WAA9C;AAEA,SAAO,MAAMC,qBAAqB,CAACJ,IAAD,EAAOE,kBAAP,CAAlC;AACD;;AAQD,eAAeE,qBAAf,CAAqCJ,IAArC,EAA2CE,kBAAkB,GAAG,IAAhE,EAAsE;AACpE,MAAIG,aAAa,CAACH,kBAAD,CAAb,IAAqC,CAACP,2BAA1C,EAAuE;AACrEO,IAAAA,kBAAkB,GAAG,IAArB;AACD;;AAED,MAAIA,kBAAJ,EAAwB;AACtB,QAAI;AAEF,aAAO,MAAMI,iBAAiB,CAACN,IAAD,EAAOE,kBAAP,CAA9B;AACD,KAHD,CAGE,OAAOK,KAAP,EAAc;AACdC,MAAAA,OAAO,CAACC,IAAR,CAAaF,KAAb;AACAZ,MAAAA,2BAA2B,GAAG,KAA9B;AACD;AACF;;AAED,SAAO,MAAMW,iBAAiB,CAACN,IAAD,CAA9B;AACD;;AAED,SAASK,aAAT,CAAuBK,MAAvB,EAA+B;AAE7B,OAAK,MAAMC,GAAX,IAAkBD,MAAM,IAAIhB,YAA5B,EAA0C;AACxC,WAAO,KAAP;AACD;;AACD,SAAO,IAAP;AACD","sourcesContent":["import {isSVG, getBlob} from './svg-utils';\nimport parseToImage from './parse-to-image';\n\nconst EMPTY_OBJECT = {};\n\nlet imagebitmapOptionsSupported = true;\n\n/**\n * Asynchronously parses an array buffer into an ImageBitmap - this contains the decoded data\n * ImageBitmaps are supported on worker threads, but not supported on Edge, IE11 and Safari\n * https://developer.mozilla.org/en-US/docs/Web/API/ImageBitmap#Browser_compatibility\n *\n * TODO - createImageBitmap supports source rect (5 param overload), pass through?\n */\nexport default async function parseToImageBitmap(arrayBuffer, options, url) {\n  let blob;\n\n  // Cannot parse SVG directly to ImageBitmap, parse to Image first\n  if (isSVG(url)) {\n    // Note: this only works on main thread\n    const image = await parseToImage(arrayBuffer, options, url);\n    blob = image;\n  } else {\n    // Create blob from the array buffer\n    blob = getBlob(arrayBuffer, url);\n  }\n\n  const imagebitmapOptions = options && options.imagebitmap;\n\n  return await safeCreateImageBitmap(blob, imagebitmapOptions);\n}\n\n/**\n * Safely creates an imageBitmap with options\n * *\n * Firefox crashes if imagebitmapOptions is supplied\n * Avoid supplying if not provided or supported, remember if not supported\n */\nasync function safeCreateImageBitmap(blob, imagebitmapOptions = null) {\n  if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) {\n    imagebitmapOptions = null;\n  }\n\n  if (imagebitmapOptions) {\n    try {\n      // @ts-ignore Options\n      return await createImageBitmap(blob, imagebitmapOptions);\n    } catch (error) {\n      console.warn(error); // eslint-disable-line\n      imagebitmapOptionsSupported = false;\n    }\n  }\n\n  return await createImageBitmap(blob);\n}\n\nfunction isEmptyObject(object) {\n  // @ts-ignore\n  for (const key in object || EMPTY_OBJECT) {\n    return false;\n  }\n  return true;\n}\n"],"file":"parse-to-image-bitmap.js"}
+{"version":3,"sources":["../../../../src/lib/parsers/parse-to-image-bitmap.ts"],"names":["EMPTY_OBJECT","imagebitmapOptionsSupported","parseToImageBitmap","arrayBuffer","options","url","image","blob","imagebitmapOptions","imagebitmap","safeCreateImageBitmap","isEmptyObject","createImageBitmap","console","warn","object","key"],"mappings":";;;;;;;;;;;;;AAAA;;AACA;;AAEA,IAAMA,YAAY,GAAG,EAArB;AAEA,IAAIC,2BAA2B,GAAG,IAAlC;;SAS8BC,kB;;;;;kFAAf,iBAAkCC,WAAlC,EAA+CC,OAA/C,EAAwDC,GAAxD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAIT,qBAAMA,GAAN,CAJS;AAAA;AAAA;AAAA;;AAAA;AAAA,mBAMS,2BAAaF,WAAb,EAA0BC,OAA1B,EAAmCC,GAAnC,CANT;;AAAA;AAMLC,YAAAA,KANK;AAOXC,YAAAA,IAAI,GAAGD,KAAP;AAPW;AAAA;;AAAA;AAUXC,YAAAA,IAAI,GAAG,uBAAQJ,WAAR,EAAqBE,GAArB,CAAP;;AAVW;AAaPG,YAAAA,kBAbO,GAacJ,OAAO,IAAIA,OAAO,CAACK,WAbjC;AAAA;AAAA,mBAeAC,qBAAqB,CAACH,IAAD,EAAOC,kBAAP,CAfrB;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;SAwBAE,qB;;;;;qFAAf,kBAAqCH,IAArC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAA2CC,YAAAA,kBAA3C,8DAAgE,IAAhE;;AACE,gBAAIG,aAAa,CAACH,kBAAD,CAAb,IAAqC,CAACP,2BAA1C,EAAuE;AACrEO,cAAAA,kBAAkB,GAAG,IAArB;AACD;;AAHH,iBAKMA,kBALN;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA,mBAQmBI,iBAAiB,CAACL,IAAD,EAAOC,kBAAP,CARpC;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAUMK,YAAAA,OAAO,CAACC,IAAR;AACAb,YAAAA,2BAA2B,GAAG,KAA9B;;AAXN;AAAA;AAAA,mBAeeW,iBAAiB,CAACL,IAAD,CAfhC;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;AAkBA,SAASI,aAAT,CAAuBI,MAAvB,EAA+B;AAE7B,OAAK,IAAMC,GAAX,IAAkBD,MAAM,IAAIf,YAA5B,EAA0C;AACxC,WAAO,KAAP;AACD;;AACD,SAAO,IAAP;AACD","sourcesContent":["import {isSVG, getBlob} from './svg-utils';\nimport parseToImage from './parse-to-image';\n\nconst EMPTY_OBJECT = {};\n\nlet imagebitmapOptionsSupported = true;\n\n/**\n * Asynchronously parses an array buffer into an ImageBitmap - this contains the decoded data\n * ImageBitmaps are supported on worker threads, but not supported on Edge, IE11 and Safari\n * https://developer.mozilla.org/en-US/docs/Web/API/ImageBitmap#Browser_compatibility\n *\n * TODO - createImageBitmap supports source rect (5 param overload), pass through?\n */\nexport default async function parseToImageBitmap(arrayBuffer, options, url) {\n  let blob;\n\n  // Cannot parse SVG directly to ImageBitmap, parse to Image first\n  if (isSVG(url)) {\n    // Note: this only works on main thread\n    const image = await parseToImage(arrayBuffer, options, url);\n    blob = image;\n  } else {\n    // Create blob from the array buffer\n    blob = getBlob(arrayBuffer, url);\n  }\n\n  const imagebitmapOptions = options && options.imagebitmap;\n\n  return await safeCreateImageBitmap(blob, imagebitmapOptions);\n}\n\n/**\n * Safely creates an imageBitmap with options\n * *\n * Firefox crashes if imagebitmapOptions is supplied\n * Avoid supplying if not provided or supported, remember if not supported\n */\nasync function safeCreateImageBitmap(blob, imagebitmapOptions = null) {\n  if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) {\n    imagebitmapOptions = null;\n  }\n\n  if (imagebitmapOptions) {\n    try {\n      // @ts-ignore Options\n      return await createImageBitmap(blob, imagebitmapOptions);\n    } catch (error) {\n      console.warn(error); // eslint-disable-line\n      imagebitmapOptionsSupported = false;\n    }\n  }\n\n  return await createImageBitmap(blob);\n}\n\nfunction isEmptyObject(object) {\n  // @ts-ignore\n  for (const key in object || EMPTY_OBJECT) {\n    return false;\n  }\n  return true;\n}\n"],"file":"parse-to-image-bitmap.js"}

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

@@ -1,44 +1,110 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = parseToImage;
 exports.loadToImage = loadToImage;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 var _svgUtils = require("./svg-utils");
 
-async function parseToImage(arrayBuffer, options, url) {
-  const blobOrDataUrl = (0, _svgUtils.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);
-    }
-  }
+function parseToImage(_x, _x2, _x3) {
+  return _parseToImage.apply(this, arguments);
+}
+
+function _parseToImage() {
+  _parseToImage = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(arrayBuffer, options, url) {
+    var blobOrDataUrl, URL, objectUrl;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            blobOrDataUrl = (0, _svgUtils.getBlobOrSVGDataUrl)(arrayBuffer, url);
+            URL = self.URL || self.webkitURL;
+            objectUrl = typeof blobOrDataUrl !== 'string' && URL.createObjectURL(blobOrDataUrl);
+            _context.prev = 3;
+            _context.next = 6;
+            return loadToImage(objectUrl || blobOrDataUrl, options);
+
+          case 6:
+            return _context.abrupt("return", _context.sent);
+
+          case 7:
+            _context.prev = 7;
+
+            if (objectUrl) {
+              URL.revokeObjectURL(objectUrl);
+            }
+
+            return _context.finish(7);
+
+          case 10:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[3,, 7, 10]]);
+  }));
+  return _parseToImage.apply(this, arguments);
+}
+
+function loadToImage(_x4, _x5) {
+  return _loadToImage.apply(this, arguments);
 }
 
-async function loadToImage(url, options) {
-  const image = new Image();
-  image.src = url;
+function _loadToImage() {
+  _loadToImage = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2(url, options) {
+    var image;
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            image = new Image();
+            image.src = url;
+
+            if (!(options.image && options.image.decode && image.decode)) {
+              _context2.next = 6;
+              break;
+            }
+
+            _context2.next = 5;
+            return image.decode();
+
+          case 5:
+            return _context2.abrupt("return", image);
+
+          case 6:
+            _context2.next = 8;
+            return new Promise(function (resolve, reject) {
+              try {
+                image.onload = function () {
+                  return resolve(image);
+                };
 
-  if (options.image && options.image.decode && image.decode) {
-    await image.decode();
-    return image;
-  }
+                image.onerror = function (err) {
+                  return reject(new Error("Could not load image ".concat(url, ": ").concat(err)));
+                };
+              } catch (error) {
+                reject(error);
+              }
+            });
 
-  return await new Promise((resolve, reject) => {
-    try {
-      image.onload = () => resolve(image);
+          case 8:
+            return _context2.abrupt("return", _context2.sent);
 
-      image.onerror = err => reject(new Error("Could not load image ".concat(url, ": ").concat(err)));
-    } catch (error) {
-      reject(error);
-    }
-  });
+          case 9:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _loadToImage.apply(this, arguments);
 }
 //# sourceMappingURL=parse-to-image.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/parsers/parse-to-image.ts"],"names":["parseToImage","arrayBuffer","options","url","blobOrDataUrl","URL","self","webkitURL","objectUrl","createObjectURL","loadToImage","revokeObjectURL","image","Image","src","decode","Promise","resolve","reject","onload","onerror","err","Error","error"],"mappings":";;;;;;;;AAAA;;AAGe,eAAeA,YAAf,CAA4BC,WAA5B,EAAyCC,OAAzC,EAAkDC,GAAlD,EAAuD;AAKpE,QAAMC,aAAa,GAAG,mCAAoBH,WAApB,EAAiCE,GAAjC,CAAtB;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;;AAEM,eAAeE,WAAf,CAA2BP,GAA3B,EAAgCD,OAAhC,EAAyC;AAC9C,QAAMU,KAAK,GAAG,IAAIC,KAAJ,EAAd;AACAD,EAAAA,KAAK,CAACE,GAAN,GAAYX,GAAZ;;AASA,MAAID,OAAO,CAACU,KAAR,IAAiBV,OAAO,CAACU,KAAR,CAAcG,MAA/B,IAAyCH,KAAK,CAACG,MAAnD,EAA2D;AACzD,UAAMH,KAAK,CAACG,MAAN,EAAN;AACA,WAAOH,KAAP;AACD;;AAGD,SAAO,MAAM,IAAII,OAAJ,CAAY,CAACC,OAAD,EAAUC,MAAV,KAAqB;AAC5C,QAAI;AACFN,MAAAA,KAAK,CAACO,MAAN,GAAe,MAAMF,OAAO,CAACL,KAAD,CAA5B;;AACAA,MAAAA,KAAK,CAACQ,OAAN,GAAiBC,GAAD,IAASH,MAAM,CAAC,IAAII,KAAJ,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 {getBlobOrSVGDataUrl} from './svg-utils';\n\n// Parses html image from array buffer\nexport default async function parseToImage(arrayBuffer, options, url) {\n  // Note: image parsing requires conversion to Blob (for createObjectURL).\n  // Potentially inefficient for not using `response.blob()` (and for File / Blob inputs)...\n  // But presumably not worth adding 'blob' flag to loader objects?\n\n  const blobOrDataUrl = getBlobOrSVGDataUrl(arrayBuffer, url);\n  const URL = self.URL || self.webkitURL;\n  const objectUrl = typeof blobOrDataUrl !== 'string' && URL.createObjectURL(blobOrDataUrl);\n  try {\n    return await loadToImage(objectUrl || blobOrDataUrl, options);\n  } finally {\n    if (objectUrl) {\n      URL.revokeObjectURL(objectUrl);\n    }\n  }\n}\n\nexport async function loadToImage(url, options) {\n  const image = new Image();\n  image.src = url;\n\n  // The `image.onload()` callback does not guarantee that the image has been decoded\n  // so a main thread \"freeze\" can be incurred when using the image for the first time.\n  // `Image.decode()` returns a promise that completes when image is decoded.\n\n  // https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement/decode\n  // Note: When calling `img.decode()`, we do not need to wait for `img.onload()`\n  // Note: `HTMLImageElement.decode()` is not available in Edge and IE11\n  if (options.image && options.image.decode && image.decode) {\n    await image.decode();\n    return image;\n  }\n\n  // Create a promise that tracks onload/onerror callbacks\n  return await new Promise((resolve, reject) => {\n    try {\n      image.onload = () => resolve(image);\n      image.onerror = (err) => reject(new Error(`Could not load image ${url}: ${err}`));\n    } catch (error) {\n      reject(error);\n    }\n  });\n}\n"],"file":"parse-to-image.js"}
+{"version":3,"sources":["../../../../src/lib/parsers/parse-to-image.ts"],"names":["parseToImage","arrayBuffer","options","url","blobOrDataUrl","URL","self","webkitURL","objectUrl","createObjectURL","loadToImage","revokeObjectURL","image","Image","src","decode","Promise","resolve","reject","onload","onerror","err","Error","error"],"mappings":";;;;;;;;;;;;;;AAAA;;SAG8BA,Y;;;;;4EAAf,iBAA4BC,WAA5B,EAAyCC,OAAzC,EAAkDC,GAAlD;AAAA;AAAA;AAAA;AAAA;AAAA;AAKPC,YAAAA,aALO,GAKS,mCAAoBH,WAApB,EAAiCE,GAAjC,CALT;AAMPE,YAAAA,GANO,GAMDC,IAAI,CAACD,GAAL,IAAYC,IAAI,CAACC,SANhB;AAOPC,YAAAA,SAPO,GAOK,OAAOJ,aAAP,KAAyB,QAAzB,IAAqCC,GAAG,CAACI,eAAJ,CAAoBL,aAApB,CAP1C;AAAA;AAAA;AAAA,mBASEM,WAAW,CAACF,SAAS,IAAIJ,aAAd,EAA6BF,OAA7B,CATb;;AAAA;AAAA;;AAAA;AAAA;;AAWX,gBAAIM,SAAJ,EAAe;AACbH,cAAAA,GAAG,CAACM,eAAJ,CAAoBH,SAApB;AACD;;AAbU;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;SAiBOE,W;;;;;2EAAf,kBAA2BP,GAA3B,EAAgCD,OAAhC;AAAA;AAAA;AAAA;AAAA;AAAA;AACCU,YAAAA,KADD,GACS,IAAIC,KAAJ,EADT;AAELD,YAAAA,KAAK,CAACE,GAAN,GAAYX,GAAZ;;AAFK,kBAWDD,OAAO,CAACU,KAAR,IAAiBV,OAAO,CAACU,KAAR,CAAcG,MAA/B,IAAyCH,KAAK,CAACG,MAX9C;AAAA;AAAA;AAAA;;AAAA;AAAA,mBAYGH,KAAK,CAACG,MAAN,EAZH;;AAAA;AAAA,8CAaIH,KAbJ;;AAAA;AAAA;AAAA,mBAiBQ,IAAII,OAAJ,CAAY,UAACC,OAAD,EAAUC,MAAV,EAAqB;AAC5C,kBAAI;AACFN,gBAAAA,KAAK,CAACO,MAAN,GAAe;AAAA,yBAAMF,OAAO,CAACL,KAAD,CAAb;AAAA,iBAAf;;AACAA,gBAAAA,KAAK,CAACQ,OAAN,GAAgB,UAACC,GAAD;AAAA,yBAASH,MAAM,CAAC,IAAII,KAAJ,gCAAkCnB,GAAlC,eAA0CkB,GAA1C,EAAD,CAAf;AAAA,iBAAhB;AACD,eAHD,CAGE,OAAOE,KAAP,EAAc;AACdL,gBAAAA,MAAM,CAACK,KAAD,CAAN;AACD;AACF,aAPY,CAjBR;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G","sourcesContent":["import {getBlobOrSVGDataUrl} from './svg-utils';\n\n// Parses html image from array buffer\nexport default async function parseToImage(arrayBuffer, options, url) {\n  // Note: image parsing requires conversion to Blob (for createObjectURL).\n  // Potentially inefficient for not using `response.blob()` (and for File / Blob inputs)...\n  // But presumably not worth adding 'blob' flag to loader objects?\n\n  const blobOrDataUrl = getBlobOrSVGDataUrl(arrayBuffer, url);\n  const URL = self.URL || self.webkitURL;\n  const objectUrl = typeof blobOrDataUrl !== 'string' && URL.createObjectURL(blobOrDataUrl);\n  try {\n    return await loadToImage(objectUrl || blobOrDataUrl, options);\n  } finally {\n    if (objectUrl) {\n      URL.revokeObjectURL(objectUrl);\n    }\n  }\n}\n\nexport async function loadToImage(url, options) {\n  const image = new Image();\n  image.src = url;\n\n  // The `image.onload()` callback does not guarantee that the image has been decoded\n  // so a main thread \"freeze\" can be incurred when using the image for the first time.\n  // `Image.decode()` returns a promise that completes when image is decoded.\n\n  // https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement/decode\n  // Note: When calling `img.decode()`, we do not need to wait for `img.onload()`\n  // Note: `HTMLImageElement.decode()` is not available in Edge and IE11\n  if (options.image && options.image.decode && image.decode) {\n    await image.decode();\n    return image;\n  }\n\n  // Create a promise that tracks onload/onerror callbacks\n  return await new Promise((resolve, reject) => {\n    try {\n      image.onload = () => resolve(image);\n      image.onerror = (err) => reject(new Error(`Could not load image ${url}: ${err}`));\n    } catch (error) {\n      reject(error);\n    }\n  });\n}\n"],"file":"parse-to-image.js"}

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

@@ -12,12 +12,10 @@ var _assert = require("../utils/assert");
 var _binaryImageApi = require("../category-api/binary-image-api");
 
 function parseToNodeImage(arrayBuffer, options) {
-  const {
-    mimeType
-  } = (0, _binaryImageApi.getBinaryImageMetadata)(arrayBuffer) || {};
-  const {
-    _parseImageNode
-  } = _globals.global;
+  var _ref = (0, _binaryImageApi.getBinaryImageMetadata)(arrayBuffer) || {},
+      mimeType = _ref.mimeType;
+
+  var _parseImageNode = _globals.global._parseImageNode;
   (0, _assert.assert)(_parseImageNode);
   return _parseImageNode(arrayBuffer, mimeType, options);
 }

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/parsers/parse-to-node-image.ts"],"names":["parseToNodeImage","arrayBuffer","options","mimeType","_parseImageNode","global"],"mappings":";;;;;;;AAAA;;AACA;;AACA;;AAGe,SAASA,gBAAT,CAA0BC,WAA1B,EAAuCC,OAAvC,EAAgD;AAC7D,QAAM;AAACC,IAAAA;AAAD,MAAa,4CAAuBF,WAAvB,KAAuC,EAA1D;AAGA,QAAM;AAACG,IAAAA;AAAD,MAAoBC,eAA1B;AACA,sBAAOD,eAAP;AAEA,SAAOA,eAAe,CAACH,WAAD,EAAcE,QAAd,EAAwBD,OAAxB,CAAtB;AACD","sourcesContent":["import {global} from '../utils/globals';\nimport {assert} from '../utils/assert';\nimport {getBinaryImageMetadata} from '../category-api/binary-image-api';\n\n// Use polyfills if installed to p[arsed image using get-pixels\nexport default function parseToNodeImage(arrayBuffer, options) {\n  const {mimeType} = getBinaryImageMetadata(arrayBuffer) || {};\n\n  // @ts-ignore\n  const {_parseImageNode} = global;\n  assert(_parseImageNode); // '@loaders.gl/polyfills not installed'\n\n  return _parseImageNode(arrayBuffer, mimeType, options);\n}\n"],"file":"parse-to-node-image.js"}
+{"version":3,"sources":["../../../../src/lib/parsers/parse-to-node-image.ts"],"names":["parseToNodeImage","arrayBuffer","options","mimeType","_parseImageNode","global"],"mappings":";;;;;;;AAAA;;AACA;;AACA;;AAGe,SAASA,gBAAT,CAA0BC,WAA1B,EAAuCC,OAAvC,EAAgD;AAC7D,aAAmB,4CAAuBD,WAAvB,KAAuC,EAA1D;AAAA,MAAOE,QAAP,QAAOA,QAAP;;AAGA,MAAOC,eAAP,GAA0BC,eAA1B,CAAOD,eAAP;AACA,sBAAOA,eAAP;AAEA,SAAOA,eAAe,CAACH,WAAD,EAAcE,QAAd,EAAwBD,OAAxB,CAAtB;AACD","sourcesContent":["import {global} from '../utils/globals';\nimport {assert} from '../utils/assert';\nimport {getBinaryImageMetadata} from '../category-api/binary-image-api';\n\n// Use polyfills if installed to p[arsed image using get-pixels\nexport default function parseToNodeImage(arrayBuffer, options) {\n  const {mimeType} = getBinaryImageMetadata(arrayBuffer) || {};\n\n  // @ts-ignore\n  const {_parseImageNode} = global;\n  assert(_parseImageNode); // '@loaders.gl/polyfills not installed'\n\n  return _parseImageNode(arrayBuffer, mimeType, options);\n}\n"],"file":"parse-to-node-image.js"}

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

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", {
 exports.isSVG = isSVG;
 exports.getBlobOrSVGDataUrl = getBlobOrSVGDataUrl;
 exports.getBlob = getBlob;
-const SVG_DATA_URL_PATTERN = /^data:image\/svg\+xml/;
-const SVG_URL_PATTERN = /\.svg((\?|#).*)?$/;
+var SVG_DATA_URL_PATTERN = /^data:image\/svg\+xml/;
+var SVG_URL_PATTERN = /\.svg((\?|#).*)?$/;
 
 function isSVG(url) {
   return url && (SVG_DATA_URL_PATTERN.test(url) || SVG_URL_PATTERN.test(url));
@@ -15,8 +15,8 @@ function isSVG(url) {
 
 function getBlobOrSVGDataUrl(arrayBuffer, url) {
   if (isSVG(url)) {
-    const textDecoder = new TextDecoder();
-    let xmlText = textDecoder.decode(arrayBuffer);
+    var textDecoder = new TextDecoder();
+    var xmlText = textDecoder.decode(arrayBuffer);
 
     try {
       if (typeof unescape === 'function' && typeof encodeURIComponent === 'function') {
@@ -26,7 +26,7 @@ function getBlobOrSVGDataUrl(arrayBuffer, url) {
       throw new Error(error.message);
     }
 
-    const src = "data:image/svg+xml;base64,".concat(btoa(xmlText));
+    var src = "data:image/svg+xml;base64,".concat(btoa(xmlText));
     return src;
   }
 

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

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

@@ -1,48 +1,177 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.asyncDeepMap = asyncDeepMap;
 exports.mapSubtree = mapSubtree;
 
-const isObject = value => value && typeof value === 'object';
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var isObject = function isObject(value) {
+  return value && (0, _typeof2.default)(value) === 'object';
+};
 
-async function asyncDeepMap(tree, func, options = {}) {
-  return await mapSubtree(tree, func, options);
+function asyncDeepMap(_x, _x2) {
+  return _asyncDeepMap.apply(this, arguments);
 }
 
-async function mapSubtree(object, func, options) {
-  if (Array.isArray(object)) {
-    return await mapArray(object, func, options);
-  }
+function _asyncDeepMap() {
+  _asyncDeepMap = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(tree, func) {
+    var options,
+        _args = arguments;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            options = _args.length > 2 && _args[2] !== undefined ? _args[2] : {};
+            _context.next = 3;
+            return mapSubtree(tree, func, options);
+
+          case 3:
+            return _context.abrupt("return", _context.sent);
+
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _asyncDeepMap.apply(this, arguments);
+}
+
+function mapSubtree(_x3, _x4, _x5) {
+  return _mapSubtree.apply(this, arguments);
+}
+
+function _mapSubtree() {
+  _mapSubtree = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2(object, func, options) {
+    var url;
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            if (!Array.isArray(object)) {
+              _context2.next = 4;
+              break;
+            }
+
+            _context2.next = 3;
+            return mapArray(object, func, options);
+
+          case 3:
+            return _context2.abrupt("return", _context2.sent);
+
+          case 4:
+            if (!isObject(object)) {
+              _context2.next = 8;
+              break;
+            }
 
-  if (isObject(object)) {
-    return await mapObject(object, func, options);
-  }
+            _context2.next = 7;
+            return mapObject(object, func, options);
 
-  const url = object;
-  return await func(url, options);
+          case 7:
+            return _context2.abrupt("return", _context2.sent);
+
+          case 8:
+            url = object;
+            _context2.next = 11;
+            return func(url, options);
+
+          case 11:
+            return _context2.abrupt("return", _context2.sent);
+
+          case 12:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _mapSubtree.apply(this, arguments);
 }
 
-async function mapObject(object, func, options) {
-  const promises = [];
-  const values = {};
+function mapObject(_x6, _x7, _x8) {
+  return _mapObject.apply(this, arguments);
+}
+
+function _mapObject() {
+  _mapObject = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee3(object, func, options) {
+    var promises, values, _loop, key;
+
+    return _regenerator.default.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            promises = [];
+            values = {};
+
+            _loop = function _loop(key) {
+              var url = object[key];
+              var promise = mapSubtree(url, func, options).then(function (value) {
+                values[key] = value;
+              });
+              promises.push(promise);
+            };
 
-  for (const key in object) {
-    const url = object[key];
-    const promise = mapSubtree(url, func, options).then(value => {
-      values[key] = value;
-    });
-    promises.push(promise);
-  }
+            for (key in object) {
+              _loop(key);
+            }
 
-  await Promise.all(promises);
-  return values;
+            _context3.next = 6;
+            return Promise.all(promises);
+
+          case 6:
+            return _context3.abrupt("return", values);
+
+          case 7:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+  return _mapObject.apply(this, arguments);
+}
+
+function mapArray(_x9, _x10) {
+  return _mapArray.apply(this, arguments);
 }
 
-async function mapArray(urlArray, func, options = {}) {
-  const promises = urlArray.map(url => mapSubtree(url, func, options));
-  return await Promise.all(promises);
+function _mapArray() {
+  _mapArray = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee4(urlArray, func) {
+    var options,
+        promises,
+        _args4 = arguments;
+    return _regenerator.default.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            options = _args4.length > 2 && _args4[2] !== undefined ? _args4[2] : {};
+            promises = urlArray.map(function (url) {
+              return mapSubtree(url, func, options);
+            });
+            _context4.next = 4;
+            return Promise.all(promises);
+
+          case 4:
+            return _context4.abrupt("return", _context4.sent);
+
+          case 5:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  }));
+  return _mapArray.apply(this, arguments);
 }
 //# sourceMappingURL=async-deep-map.js.map

package/dist/es5/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;;AAKO,eAAeC,YAAf,CAA4BC,IAA5B,EAAkCC,IAAlC,EAAwCC,OAAO,GAAG,EAAlD,EAAsD;AAC3D,SAAO,MAAMC,UAAU,CAACH,IAAD,EAAOC,IAAP,EAAaC,OAAb,CAAvB;AACD;;AAEM,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,"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,IAAMA,QAAQ,GAAG,SAAXA,QAAW,CAACC,KAAD;AAAA,SAAWA,KAAK,IAAI,sBAAOA,KAAP,MAAiB,QAArC;AAAA,CAAjB;;SAKsBC,Y;;;;;4EAAf,iBAA4BC,IAA5B,EAAkCC,IAAlC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAwCC,YAAAA,OAAxC,2DAAkD,EAAlD;AAAA;AAAA,mBACQC,UAAU,CAACH,IAAD,EAAOC,IAAP,EAAaC,OAAb,CADlB;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;SAIeC,U;;;;;0EAAf,kBAA0BC,MAA1B,EAAkCH,IAAlC,EAAwCC,OAAxC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBACDG,KAAK,CAACC,OAAN,CAAcF,MAAd,CADC;AAAA;AAAA;AAAA;;AAAA;AAAA,mBAEUG,QAAQ,CAACH,MAAD,EAASH,IAAT,EAAeC,OAAf,CAFlB;;AAAA;AAAA;;AAAA;AAAA,iBAKDL,QAAQ,CAACO,MAAD,CALP;AAAA;AAAA;AAAA;;AAAA;AAAA,mBAMUI,SAAS,CAACJ,MAAD,EAASH,IAAT,EAAeC,OAAf,CANnB;;AAAA;AAAA;;AAAA;AAUCO,YAAAA,GAVD,GAUOL,MAVP;AAAA;AAAA,mBAWQH,IAAI,CAACQ,GAAD,EAAMP,OAAN,CAXZ;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;SAgBQM,S;;;;;yEAAf,kBAAyBJ,MAAzB,EAAiCH,IAAjC,EAAuCC,OAAvC;AAAA;;AAAA;AAAA;AAAA;AAAA;AACQQ,YAAAA,QADR,GACmC,EADnC;AAEQC,YAAAA,MAFR,GAEiB,EAFjB;;AAAA,mCAIaC,GAJb;AAKI,kBAAMH,GAAG,GAAGL,MAAM,CAACQ,GAAD,CAAlB;AACA,kBAAMC,OAAO,GAAGV,UAAU,CAACM,GAAD,EAAMR,IAAN,EAAYC,OAAZ,CAAV,CAA+BY,IAA/B,CAAoC,UAAChB,KAAD,EAAW;AAC7Da,gBAAAA,MAAM,CAACC,GAAD,CAAN,GAAcd,KAAd;AACD,eAFe,CAAhB;AAGAY,cAAAA,QAAQ,CAACK,IAAT,CAAcF,OAAd;AATJ;;AAIE,iBAAWD,GAAX,IAAkBR,MAAlB,EAA0B;AAAA,oBAAfQ,GAAe;AAMzB;;AAVH;AAAA,mBAYQI,OAAO,CAACC,GAAR,CAAYP,QAAZ,CAZR;;AAAA;AAAA,8CAcSC,MAdT;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;SAiBeJ,Q;;;;;wEAAf,kBAAwBW,QAAxB,EAAkCjB,IAAlC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAwCC,YAAAA,OAAxC,8DAAkD,EAAlD;AACQQ,YAAAA,QADR,GACmBQ,QAAQ,CAACC,GAAT,CAAa,UAACV,GAAD;AAAA,qBAASN,UAAU,CAACM,GAAD,EAAMR,IAAN,EAAYC,OAAZ,CAAnB;AAAA,aAAb,CADnB;AAAA;AAAA,mBAEec,OAAO,CAACC,GAAR,CAAYP,QAAZ,CAFf;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G","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"}