@loaders.gl/images 3.1.0-beta.7 → 3.1.3

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

@@ -1,74 +1,126 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.encodeImage = encodeImage;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 var _parsedImageApi = require("../category-api/parsed-image-api");
 
-const {
-  _encodeImageNode
-} = globalThis;
+var _encodeImageNode = globalThis._encodeImageNode;
 
-async function encodeImage(image, options) {
-  options = options || {};
-  options.image = options.image || {};
-  return _encodeImageNode ? _encodeImageNode(image, {
-    type: options.image.mimeType
-  }) : encodeImageInBrowser(image, options);
+function encodeImage(_x, _x2) {
+  return _encodeImage.apply(this, arguments);
 }
 
-let qualityParamSupported = true;
-
-async function encodeImageInBrowser(image, options) {
-  const {
-    mimeType,
-    jpegQuality
-  } = options.image;
-  const {
-    width,
-    height
-  } = (0, _parsedImageApi.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;
+function _encodeImage() {
+  _encodeImage = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(image, options) {
+    return _regenerator.default.wrap(function _callee$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            options = options || {};
+            options.image = options.image || {};
+            return _context2.abrupt("return", _encodeImageNode ? _encodeImageNode(image, {
+              type: options.image.mimeType
+            }) : encodeImageInBrowser(image, options));
+
+          case 3:
+          case "end":
+            return _context2.stop();
+        }
       }
-    }
+    }, _callee);
+  }));
+  return _encodeImage.apply(this, arguments);
+}
 
-    canvas.toBlob(resolve, mimeType);
-  });
+var qualityParamSupported = true;
 
-  if (!blob) {
-    throw new Error('image encoding failed');
-  }
+function encodeImageInBrowser(_x3, _x4) {
+  return _encodeImageInBrowser.apply(this, arguments);
+}
+
+function _encodeImageInBrowser() {
+  _encodeImageInBrowser = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2(image, options) {
+    var _options$image, mimeType, jpegQuality, _getImageSize, width, height, canvas, blob;
+
+    return _regenerator.default.wrap(function _callee2$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            _options$image = options.image, mimeType = _options$image.mimeType, jpegQuality = _options$image.jpegQuality;
+            _getImageSize = (0, _parsedImageApi.getImageSize)(image), width = _getImageSize.width, height = _getImageSize.height;
+            canvas = document.createElement('canvas');
+            canvas.width = width;
+            canvas.height = height;
+            drawImageToCanvas(image, canvas);
+            _context3.next = 8;
+            return new Promise(function (resolve) {
+              if (jpegQuality && qualityParamSupported) {
+                try {
+                  canvas.toBlob(resolve, mimeType, jpegQuality);
+                  return;
+                } catch (error) {
+                  qualityParamSupported = false;
+                }
+              }
 
-  return await blob.arrayBuffer();
+              canvas.toBlob(resolve, mimeType);
+            });
+
+          case 8:
+            blob = _context3.sent;
+
+            if (blob) {
+              _context3.next = 11;
+              break;
+            }
+
+            throw new Error('image encoding failed');
+
+          case 11:
+            _context3.next = 13;
+            return blob.arrayBuffer();
+
+          case 13:
+            return _context3.abrupt("return", _context3.sent);
+
+          case 14:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _encodeImageInBrowser.apply(this, arguments);
 }
 
-function drawImageToCanvas(image, canvas, x = 0, y = 0) {
+function drawImageToCanvas(image, canvas) {
+  var x = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var y = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+
   if (x === 0 && y === 0 && typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap) {
-    const context = canvas.getContext('bitmaprenderer');
+    var _context = canvas.getContext('bitmaprenderer');
+
+    if (_context) {
+      _context.transferFromImageBitmap(image);
 
-    if (context) {
-      context.transferFromImageBitmap(image);
       return canvas;
     }
   }
 
-  const context = canvas.getContext('2d');
+  var context = canvas.getContext('2d');
 
   if (image.data) {
-    const clampedArray = new Uint8ClampedArray(image.data);
-    const imageData = new ImageData(clampedArray, image.width, image.height);
+    var clampedArray = new Uint8ClampedArray(image.data);
+    var imageData = new ImageData(clampedArray, image.width, image.height);
     context.putImageData(imageData, 0, 0);
     return canvas;
   }

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/encoders/encode-image.ts"],"names":["_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;;AAGA,MAAM;AAACA,EAAAA;AAAD,IAAqBC,UAA3B;;AAUO,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,MAAkB,kCAAaR,KAAb,CAAxB;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"}
+{"version":3,"sources":["../../../../src/lib/encoders/encode-image.ts"],"names":["_encodeImageNode","globalThis","encodeImage","image","options","type","mimeType","encodeImageInBrowser","qualityParamSupported","jpegQuality","width","height","canvas","document","createElement","drawImageToCanvas","Promise","resolve","toBlob","error","blob","Error","arrayBuffer","x","y","ImageBitmap","context","getContext","transferFromImageBitmap","data","clampedArray","Uint8ClampedArray","imageData","ImageData","putImageData","drawImage"],"mappings":"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","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/es5/lib/parsers/parse-image.js

@@ -7,6 +7,10 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = parseImage;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 var _loaderUtils = require("@loaders.gl/loader-utils");
 
 var _imageType = require("../category-api/image-type");
@@ -19,38 +23,69 @@ var _parseToImageBitmap = _interopRequireDefault(require("./parse-to-image-bitma
 
 var _parseToNodeImage = _interopRequireDefault(require("./parse-to-node-image"));
 
-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 (0, _parseToImageBitmap.default)(arrayBuffer, options, url);
-      break;
-
-    case 'image':
-      image = await (0, _parseToImage.default)(arrayBuffer, options, url);
-      break;
-
-    case 'data':
-      image = await (0, _parseToNodeImage.default)(arrayBuffer, options);
-      break;
-
-    default:
-      (0, _loaderUtils.assert)(false);
-  }
-
-  if (imageType === 'data') {
-    image = (0, _parsedImageApi.getImageData)(image);
-  }
+function parseImage(_x, _x2, _x3) {
+  return _parseImage.apply(this, arguments);
+}
 
-  return image;
+function _parseImage() {
+  _parseImage = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(arrayBuffer, options, context) {
+    var imageOptions, imageType, _ref, url, loadType, image;
+
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            options = options || {};
+            imageOptions = options.image || {};
+            imageType = imageOptions.type || 'auto';
+            _ref = context || {}, url = _ref.url;
+            loadType = getLoadableImageType(imageType);
+            _context.t0 = loadType;
+            _context.next = _context.t0 === 'imagebitmap' ? 8 : _context.t0 === 'image' ? 12 : _context.t0 === 'data' ? 16 : 20;
+            break;
+
+          case 8:
+            _context.next = 10;
+            return (0, _parseToImageBitmap.default)(arrayBuffer, options, url);
+
+          case 10:
+            image = _context.sent;
+            return _context.abrupt("break", 21);
+
+          case 12:
+            _context.next = 14;
+            return (0, _parseToImage.default)(arrayBuffer, options, url);
+
+          case 14:
+            image = _context.sent;
+            return _context.abrupt("break", 21);
+
+          case 16:
+            _context.next = 18;
+            return (0, _parseToNodeImage.default)(arrayBuffer, options);
+
+          case 18:
+            image = _context.sent;
+            return _context.abrupt("break", 21);
+
+          case 20:
+            (0, _loaderUtils.assert)(false);
+
+          case 21:
+            if (imageType === 'data') {
+              image = (0, _parsedImageApi.getImageData)(image);
+            }
+
+            return _context.abrupt("return", image);
+
+          case 23:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _parseImage.apply(this, arguments);
 }
 
 function getLoadableImageType(type) {

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/parsers/parse-image.ts"],"names":["parseImage","arrayBuffer","options","context","imageOptions","image","imageType","type","url","loadType","getLoadableImageType"],"mappings":";;;;;;;;;AACA;;AAGA;;AACA;;AACA;;AACA;;AACA;;AAIe,eAAeA,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,MAAM,iCAAmBJ,WAAnB,EAAgCC,OAAhC,EAAyCM,GAAzC,CAAd;AACA;;AACF,SAAK,OAAL;AACEH,MAAAA,KAAK,GAAG,MAAM,2BAAaJ,WAAb,EAA0BC,OAA1B,EAAmCM,GAAnC,CAAd;AACA;;AACF,SAAK,MAAL;AAEEH,MAAAA,KAAK,GAAG,MAAM,+BAAiBJ,WAAjB,EAA8BC,OAA9B,CAAd;AACA;;AACF;AACE,+BAAO,KAAP;AAZJ;;AAgBA,MAAII,SAAS,KAAK,MAAlB,EAA0B;AACxBD,IAAAA,KAAK,GAAG,kCAAaA,KAAb,CAAR;AACD;;AAED,SAAOA,KAAP;AACD;;AAGD,SAASK,oBAAT,CAA8BH,IAA9B,EAAoC;AAClC,UAAQA,IAAR;AACE,SAAK,MAAL;AACA,SAAK,MAAL;AAGE,aAAO,qCAAP;;AACF;AAEE,2CAAqBA,IAArB;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"}
+{"version":3,"sources":["../../../../src/lib/parsers/parse-image.ts"],"names":["parseImage","arrayBuffer","options","context","imageOptions","image","imageType","type","url","loadType","getLoadableImageType"],"mappings":";;;;;;;;;;;;;AACA;;AAGA;;AACA;;AACA;;AACA;;AACA;;SAI8BA,U;;;;;0EAAf,iBACbC,WADa,EAEbC,OAFa,EAGbC,OAHa;AAAA;;AAAA;AAAA;AAAA;AAAA;AAKbD,YAAAA,OAAO,GAAGA,OAAO,IAAI,EAArB;AACME,YAAAA,YANO,GAMQF,OAAO,CAACG,KAAR,IAAiB,EANzB;AASPC,YAAAA,SATO,GASKF,YAAY,CAACG,IAAb,IAAqB,MAT1B;AAAA,mBAWCJ,OAAO,IAAI,EAXZ,EAWNK,GAXM,QAWNA,GAXM;AAcPC,YAAAA,QAdO,GAcIC,oBAAoB,CAACJ,SAAD,CAdxB;AAAA,0BAiBLG,QAjBK;AAAA,4CAkBN,aAlBM,uBAqBN,OArBM,wBAwBN,MAxBM;AAAA;;AAAA;AAAA;AAAA,mBAmBK,iCAAmBR,WAAnB,EAAgCC,OAAhC,EAAyCM,GAAzC,CAnBL;;AAAA;AAmBTH,YAAAA,KAnBS;AAAA;;AAAA;AAAA;AAAA,mBAsBK,2BAAaJ,WAAb,EAA0BC,OAA1B,EAAmCM,GAAnC,CAtBL;;AAAA;AAsBTH,YAAAA,KAtBS;AAAA;;AAAA;AAAA;AAAA,mBA0BK,+BAAiBJ,WAAjB,EAA8BC,OAA9B,CA1BL;;AAAA;AA0BTG,YAAAA,KA1BS;AAAA;;AAAA;AA6BT,qCAAO,KAAP;;AA7BS;AAiCb,gBAAIC,SAAS,KAAK,MAAlB,EAA0B;AACxBD,cAAAA,KAAK,GAAG,kCAAaA,KAAb,CAAR;AACD;;AAnCY,6CAqCNA,KArCM;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;AAyCf,SAASK,oBAAT,CAA8BH,IAA9B,EAAoC;AAClC,UAAQA,IAAR;AACE,SAAK,MAAL;AACA,SAAK,MAAL;AAGE,aAAO,qCAAP;;AACF;AAEE,2CAAqBA,IAArB;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/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":";;;;;;;;;AACA;;AACA;;AAEA,MAAMA,YAAY,GAAG,EAArB;AAEA,IAAIC,2BAA2B,GAAG,IAAlC;;AASe,eAAeC,kBAAf,CACbC,WADa,EAEbC,OAFa,EAGbC,GAHa,EAIS;AACtB,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,CACEJ,IADF,EAEEE,kBAA6C,GAAG,IAFlD,EAGwB;AACtB,MAAIG,aAAa,CAACH,kBAAD,CAAb,IAAqC,CAACP,2BAA1C,EAAuE;AACrEO,IAAAA,kBAAkB,GAAG,IAArB;AACD;;AAED,MAAIA,kBAAJ,EAAwB;AACtB,QAAI;AAEF,aAAO,MAAMI,iBAAiB,CAACN,IAAD,EAAOE,kBAAP,CAA9B;AACD,KAHD,CAGE,OAAOK,KAAP,EAAc;AACdC,MAAAA,OAAO,CAACC,IAAR,CAAaF,KAAb;AACAZ,MAAAA,2BAA2B,GAAG,KAA9B;AACD;AACF;;AAED,SAAO,MAAMW,iBAAiB,CAACN,IAAD,CAA9B;AACD;;AAED,SAASK,aAAT,CAAuBK,MAAvB,EAA+B;AAE7B,OAAK,MAAMC,GAAX,IAAkBD,MAAM,IAAIhB,YAA5B,EAA0C;AACxC,WAAO,KAAP;AACD;;AACD,SAAO,IAAP;AACD","sourcesContent":["import type {ImageLoaderOptions} from '../../image-loader';\nimport {isSVG, getBlob} from './svg-utils';\nimport parseToImage from './parse-to-image';\n\nconst EMPTY_OBJECT = {};\n\nlet imagebitmapOptionsSupported = true;\n\n/**\n * Asynchronously parses an array buffer into an ImageBitmap - this contains the decoded data\n * ImageBitmaps are supported on worker threads, but not supported on Edge, IE11 and Safari\n * https://developer.mozilla.org/en-US/docs/Web/API/ImageBitmap#Browser_compatibility\n *\n * TODO - createImageBitmap supports source rect (5 param overload), pass through?\n */\nexport default async function parseToImageBitmap(\n  arrayBuffer: ArrayBuffer,\n  options: ImageLoaderOptions,\n  url?: string\n): Promise<ImageBitmap> {\n  let blob;\n\n  // Cannot parse SVG directly to ImageBitmap, parse to Image first\n  if (isSVG(url)) {\n    // Note: this only works on main thread\n    const image = await parseToImage(arrayBuffer, options, url);\n    blob = image;\n  } else {\n    // Create blob from the array buffer\n    blob = getBlob(arrayBuffer, url);\n  }\n\n  const imagebitmapOptions = options && options.imagebitmap;\n\n  return await safeCreateImageBitmap(blob, imagebitmapOptions);\n}\n\n/**\n * Safely creates an imageBitmap with options\n * *\n * Firefox crashes if imagebitmapOptions is supplied\n * Avoid supplying if not provided or supported, remember if not supported\n */\nasync function safeCreateImageBitmap(\n  blob: Blob,\n  imagebitmapOptions: ImageBitmapOptions | null = null\n): Promise<ImageBitmap> {\n  if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) {\n    imagebitmapOptions = null;\n  }\n\n  if (imagebitmapOptions) {\n    try {\n      // @ts-ignore Options\n      return await createImageBitmap(blob, imagebitmapOptions);\n    } catch (error) {\n      console.warn(error); // eslint-disable-line\n      imagebitmapOptionsSupported = false;\n    }\n  }\n\n  return await createImageBitmap(blob);\n}\n\nfunction isEmptyObject(object) {\n  // @ts-ignore\n  for (const key in object || EMPTY_OBJECT) {\n    return false;\n  }\n  return true;\n}\n"],"file":"parse-to-image-bitmap.js"}
+{"version":3,"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":";;;;;;;;;;;;;AACA;;AACA;;AAEA,IAAMA,YAAY,GAAG,EAArB;AAEA,IAAIC,2BAA2B,GAAG,IAAlC;;SAS8BC,kB;;;;;kFAAf,iBACbC,WADa,EAEbC,OAFa,EAGbC,GAHa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAQT,qBAAMA,GAAN,CARS;AAAA;AAAA;AAAA;;AAAA;AAAA,mBAUS,2BAAaF,WAAb,EAA0BC,OAA1B,EAAmCC,GAAnC,CAVT;;AAAA;AAULC,YAAAA,KAVK;AAWXC,YAAAA,IAAI,GAAGD,KAAP;AAXW;AAAA;;AAAA;AAcXC,YAAAA,IAAI,GAAG,uBAAQJ,WAAR,EAAqBE,GAArB,CAAP;;AAdW;AAiBPG,YAAAA,kBAjBO,GAiBcJ,OAAO,IAAIA,OAAO,CAACK,WAjBjC;AAAA;AAAA,mBAmBAC,qBAAqB,CAACH,IAAD,EAAOC,kBAAP,CAnBrB;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;SA4BAE,qB;;;;;qFAAf,kBACEH,IADF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAEEC,YAAAA,kBAFF,8DAEkD,IAFlD;;AAIE,gBAAIG,aAAa,CAACH,kBAAD,CAAb,IAAqC,CAACP,2BAA1C,EAAuE;AACrEO,cAAAA,kBAAkB,GAAG,IAArB;AACD;;AANH,iBAQMA,kBARN;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA,mBAWmBI,iBAAiB,CAACL,IAAD,EAAOC,kBAAP,CAXpC;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAaMK,YAAAA,OAAO,CAACC,IAAR;AACAb,YAAAA,2BAA2B,GAAG,KAA9B;;AAdN;AAAA;AAAA,mBAkBeW,iBAAiB,CAACL,IAAD,CAlBhC;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;AAqBA,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 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/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