compressorjs 1.2.0 → 1.3.0

package/dist/compressor.js

@@ -1,11 +1,11 @@
 /*!
- * Compressor.js v1.2.0
+ * Compressor.js v1.3.0
  * https://fengyuanchen.github.io/compressorjs
  *
  * Copyright 2018-present Chen Fengyuan
  * Released under the MIT license
  *
- * Date: 2023-02-25T11:35:56.625Z
+ * Date: 2026-04-06T07:12:45.816Z
  */
 
 (function (global, factory) {
@@ -14,19 +14,71 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Compressor = factory());
 })(this, (function () { 'use strict';
 
+  function _classCallCheck(a, n) {
+    if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+  }
+  function _defineProperties(e, r) {
+    for (var t = 0; t < r.length; t++) {
+      var o = r[t];
+      o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
+    }
+  }
+  function _createClass(e, r, t) {
+    return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
+      writable: !1
+    }), e;
+  }
+  function _defineProperty(e, r, t) {
+    return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+      value: t,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }) : e[r] = t, e;
+  }
   function _extends() {
-    _extends = Object.assign ? Object.assign.bind() : function (target) {
-      for (var i = 1; i < arguments.length; i++) {
-        var source = arguments[i];
-        for (var key in source) {
-          if (Object.prototype.hasOwnProperty.call(source, key)) {
-            target[key] = source[key];
-          }
-        }
+    return _extends = Object.assign ? Object.assign.bind() : function (n) {
+      for (var e = 1; e < arguments.length; e++) {
+        var t = arguments[e];
+        for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
       }
-      return target;
-    };
-    return _extends.apply(this, arguments);
+      return n;
+    }, _extends.apply(null, arguments);
+  }
+  function ownKeys(e, r) {
+    var t = Object.keys(e);
+    if (Object.getOwnPropertySymbols) {
+      var o = Object.getOwnPropertySymbols(e);
+      r && (o = o.filter(function (r) {
+        return Object.getOwnPropertyDescriptor(e, r).enumerable;
+      })), t.push.apply(t, o);
+    }
+    return t;
+  }
+  function _objectSpread2(e) {
+    for (var r = 1; r < arguments.length; r++) {
+      var t = null != arguments[r] ? arguments[r] : {};
+      r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
+        _defineProperty(e, r, t[r]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+        Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+      });
+    }
+    return e;
+  }
+  function _toPrimitive(t, r) {
+    if ("object" != typeof t || !t) return t;
+    var e = t[Symbol.toPrimitive];
+    if (void 0 !== e) {
+      var i = e.call(t, r || "default");
+      if ("object" != typeof i) return i;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === r ? String : Number)(t);
+  }
+  function _toPropertyKey(t) {
+    var i = _toPrimitive(t, "string");
+    return "symbol" == typeof i ? i : i + "";
   }
 
   var canvasToBlob = {exports: {}};
@@ -144,7 +196,7 @@
   })(canvasToBlob);
   var toBlob = canvasToBlob.exports;
 
-  var isBlob = value => {
+  var isBlob = function isBlob(value) {
     if (typeof Blob === 'undefined') {
       return false;
     }
@@ -277,18 +329,18 @@
     error: null
   };
 
-  const IS_BROWSER = typeof window !== 'undefined' && typeof window.document !== 'undefined';
-  const WINDOW = IS_BROWSER ? window : {};
+  var IS_BROWSER = typeof window !== 'undefined' && typeof window.document !== 'undefined';
+  var WINDOW = IS_BROWSER ? window : {};
 
   /**
    * Check if the given value is a positive number.
    * @param {*} value - The value to check.
    * @returns {boolean} Returns `true` if the given value is a positive number, else `false`.
    */
-  const isPositiveNumber = value => value > 0 && value < Infinity;
-  const {
-    slice
-  } = Array.prototype;
+  var isPositiveNumber = function isPositiveNumber(value) {
+    return value > 0 && value < Infinity;
+  };
+  var slice = Array.prototype.slice;
 
   /**
    * Convert array-like or iterable object to an array.
@@ -298,7 +350,7 @@
   function toArray(value) {
     return Array.from ? Array.from(value) : slice.call(value);
   }
-  const REGEXP_IMAGE_TYPE = /^image\/.+$/;
+  var REGEXP_IMAGE_TYPE = /^image\/.+$/;
 
   /**
    * Check if the given value is a mime type of image.
@@ -315,15 +367,13 @@
    * @returns {boolean} Returns the image extension.
    */
   function imageTypeToExtension(value) {
-    let extension = isImageType(value) ? value.substr(6) : '';
+    var extension = isImageType(value) ? value.substr(6) : '';
     if (extension === 'jpeg') {
       extension = 'jpg';
     }
-    return `.${extension}`;
+    return ".".concat(extension);
   }
-  const {
-    fromCharCode
-  } = String;
+  var fromCharCode = String.fromCharCode;
 
   /**
    * Get string from char code in data view.
@@ -333,17 +383,58 @@
    * @returns {string} The read result.
    */
   function getStringFromCharCode(dataView, start, length) {
-    let str = '';
-    let i;
+    var str = '';
+    var i;
     length += start;
     for (i = start; i < length; i += 1) {
       str += fromCharCode(dataView.getUint8(i));
     }
     return str;
   }
-  const {
-    btoa
-  } = WINDOW;
+
+  /**
+   * Check if `canvas.getContext('2d').getImageData` is available,
+   * FireFox randomizes the output of that function in `privacy.resistFingerprinting` mode (#137)
+   * @link https://github.com/nodeca/pica/blob/master/lib/utils.js
+   * @returns {boolean} Returns `true` if it is available, else `false`.
+   */
+  function isCanvasAvailable() {
+    try {
+      var canvas = document.createElement('canvas');
+      canvas.width = 2;
+      canvas.height = 1;
+      var context = canvas.getContext('2d');
+      if (!context) return false;
+
+      // Create 2x1 image data containing RGBA values for two pixels
+      var imageData = context.createImageData(2, 1);
+
+      // First pixel: R=12, G=23, B=34, A=255
+      imageData.data[0] = 12;
+      imageData.data[1] = 23;
+      imageData.data[2] = 34;
+      imageData.data[3] = 255;
+
+      // Second pixel: R=45, G=56, B=67, A=255
+      imageData.data[4] = 45;
+      imageData.data[5] = 56;
+      imageData.data[6] = 67;
+      imageData.data[7] = 255;
+      context.putImageData(imageData, 0, 0);
+      var readBack = context.getImageData(0, 0, 2, 1);
+
+      // Expected pixel data (matching the written values)
+      var expected = [12, 23, 34, 255, 45, 56, 67, 255];
+
+      // Compare element by element to ensure write and read consistency
+      return readBack.data.every(function (value, index) {
+        return value === expected[index];
+      });
+    } catch (error) {
+      return false;
+    }
+  }
+  var btoa = WINDOW.btoa;
 
   /**
    * Transform array buffer to Data URL.
@@ -352,16 +443,16 @@
    * @returns {string} The result Data URL.
    */
   function arrayBufferToDataURL(arrayBuffer, mimeType) {
-    const chunks = [];
-    const chunkSize = 8192;
-    let uint8 = new Uint8Array(arrayBuffer);
+    var chunks = [];
+    var chunkSize = 8192;
+    var uint8 = new Uint8Array(arrayBuffer);
     while (uint8.length > 0) {
       // XXX: Babel's `toConsumableArray` helper will throw error in IE or Safari 9
       // eslint-disable-next-line prefer-spread
       chunks.push(fromCharCode.apply(null, toArray(uint8.subarray(0, chunkSize))));
       uint8 = uint8.subarray(chunkSize);
     }
-    return `data:${mimeType};base64,${btoa(chunks.join(''))}`;
+    return "data:".concat(mimeType, ";base64,").concat(btoa(chunks.join('')));
   }
 
   /**
@@ -370,19 +461,19 @@
    * @returns {number} The read orientation value.
    */
   function resetAndGetOrientation(arrayBuffer) {
-    const dataView = new DataView(arrayBuffer);
-    let orientation;
+    var dataView = new DataView(arrayBuffer);
+    var orientation;
 
     // Ignores range error when the image does not have correct Exif information
     try {
-      let littleEndian;
-      let app1Start;
-      let ifdStart;
+      var littleEndian;
+      var app1Start;
+      var ifdStart;
 
       // Only handle JPEG image (start by 0xFFD8)
       if (dataView.getUint8(0) === 0xFF && dataView.getUint8(1) === 0xD8) {
-        const length = dataView.byteLength;
-        let offset = 2;
+        var length = dataView.byteLength;
+        var offset = 2;
         while (offset + 1 < length) {
           if (dataView.getUint8(offset) === 0xFF && dataView.getUint8(offset + 1) === 0xE1) {
             app1Start = offset;
@@ -392,14 +483,14 @@
         }
       }
       if (app1Start) {
-        const exifIDCode = app1Start + 4;
-        const tiffOffset = app1Start + 10;
+        var exifIDCode = app1Start + 4;
+        var tiffOffset = app1Start + 10;
         if (getStringFromCharCode(dataView, exifIDCode, 4) === 'Exif') {
-          const endianness = dataView.getUint16(tiffOffset);
+          var endianness = dataView.getUint16(tiffOffset);
           littleEndian = endianness === 0x4949;
           if (littleEndian || endianness === 0x4D4D /* bigEndian */) {
             if (dataView.getUint16(tiffOffset + 2, littleEndian) === 0x002A) {
-              const firstIFDOffset = dataView.getUint32(tiffOffset + 4, littleEndian);
+              var firstIFDOffset = dataView.getUint32(tiffOffset + 4, littleEndian);
               if (firstIFDOffset >= 0x00000008) {
                 ifdStart = tiffOffset + firstIFDOffset;
               }
@@ -408,20 +499,20 @@
         }
       }
       if (ifdStart) {
-        const length = dataView.getUint16(ifdStart, littleEndian);
-        let offset;
-        let i;
-        for (i = 0; i < length; i += 1) {
-          offset = ifdStart + i * 12 + 2;
-          if (dataView.getUint16(offset, littleEndian) === 0x0112 /* Orientation */) {
+        var _length = dataView.getUint16(ifdStart, littleEndian);
+        var _offset;
+        var i;
+        for (i = 0; i < _length; i += 1) {
+          _offset = ifdStart + i * 12 + 2;
+          if (dataView.getUint16(_offset, littleEndian) === 0x0112 /* Orientation */) {
             // 8 is the offset of the current tag's value
-            offset += 8;
+            _offset += 8;
 
             // Get the original orientation value
-            orientation = dataView.getUint16(offset, littleEndian);
+            orientation = dataView.getUint16(_offset, littleEndian);
 
             // Override the orientation with its default value
-            dataView.setUint16(offset, 1, littleEndian);
+            dataView.setUint16(_offset, 1, littleEndian);
             break;
           }
         }
@@ -438,9 +529,9 @@
    * @returns {Object} The parsed result.
    */
   function parseOrientation(orientation) {
-    let rotate = 0;
-    let scaleX = 1;
-    let scaleY = 1;
+    var rotate = 0;
+    var scaleX = 1;
+    var scaleY = 1;
     switch (orientation) {
       // Flip horizontal
       case 2:
@@ -480,12 +571,12 @@
         break;
     }
     return {
-      rotate,
-      scaleX,
-      scaleY
+      rotate: rotate,
+      scaleX: scaleX,
+      scaleY: scaleY
     };
   }
-  const REGEXP_DECIMALS = /\.\d*(?:0|9){12}\d*$/;
+  var REGEXP_DECIMALS = /\.\d*(?:0|9){12}\d*$/;
 
   /**
    * Normalize decimal number.
@@ -495,7 +586,7 @@
    * @returns {number} Returns the normalized number.
    */
   function normalizeDecimalNumber(value) {
-    let times = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100000000000;
+    var times = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100000000000;
     return REGEXP_DECIMALS.test(value) ? Math.round(value * times) / times : value;
   }
 
@@ -506,16 +597,14 @@
    * @returns {Object} The result sizes.
    */
   function getAdjustedSizes(_ref) {
-    let {
-      aspectRatio,
-      height,
-      width
-    } = _ref;
-    let type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'none';
-    const isValidWidth = isPositiveNumber(width);
-    const isValidHeight = isPositiveNumber(height);
+    var aspectRatio = _ref.aspectRatio,
+      height = _ref.height,
+      width = _ref.width;
+    var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'none';
+    var isValidWidth = isPositiveNumber(width);
+    var isValidHeight = isPositiveNumber(height);
     if (isValidWidth && isValidHeight) {
-      const adjustedWidth = height * aspectRatio;
+      var adjustedWidth = height * aspectRatio;
       if ((type === 'contain' || type === 'none') && adjustedWidth > width || type === 'cover' && adjustedWidth < width) {
         height = width / aspectRatio;
       } else {
@@ -527,8 +616,8 @@
       width = height * aspectRatio;
     }
     return {
-      width,
-      height
+      width: width,
+      height: height
     };
   }
 
@@ -538,15 +627,13 @@
    * @returns {Array} The read Exif information.
    */
   function getExif(arrayBuffer) {
-    const array = toArray(new Uint8Array(arrayBuffer));
-    const {
-      length
-    } = array;
-    const segments = [];
-    let start = 0;
+    var array = toArray(new Uint8Array(arrayBuffer));
+    var length = array.length;
+    var segments = [];
+    var start = 0;
     while (start + 3 < length) {
-      const value = array[start];
-      const next = array[start + 1];
+      var value = array[start];
+      var next = array[start + 1];
 
       // SOS (Start of Scan)
       if (value === 0xFF && next === 0xDA) {
@@ -557,14 +644,14 @@
       if (value === 0xFF && next === 0xD8) {
         start += 2;
       } else {
-        const offset = array[start + 2] * 256 + array[start + 3];
-        const end = start + offset + 2;
-        const segment = array.slice(start, end);
+        var offset = array[start + 2] * 256 + array[start + 3];
+        var end = start + offset + 2;
+        var segment = array.slice(start, end);
         segments.push(segment);
         start = end;
       }
     }
-    return segments.reduce((exifArray, current) => {
+    return segments.reduce(function (exifArray, current) {
       if (current[0] === 0xFF && current[1] === 0xE1) {
         return exifArray.concat(current);
       }
@@ -579,415 +666,439 @@
    * @returns {ArrayBuffer} The transformed array buffer.
    */
   function insertExif(arrayBuffer, exifArray) {
-    const array = toArray(new Uint8Array(arrayBuffer));
+    var array = toArray(new Uint8Array(arrayBuffer));
     if (array[2] !== 0xFF || array[3] !== 0xE0) {
       return arrayBuffer;
     }
-    const app0Length = array[4] * 256 + array[5];
-    const newArrayBuffer = [0xFF, 0xD8].concat(exifArray, array.slice(4 + app0Length));
+    var app0Length = array[4] * 256 + array[5];
+    var newArrayBuffer = [0xFF, 0xD8].concat(exifArray, array.slice(4 + app0Length));
     return new Uint8Array(newArrayBuffer);
   }
 
-  const {
-    ArrayBuffer: ArrayBuffer$1,
-    FileReader
-  } = WINDOW;
-  const URL = WINDOW.URL || WINDOW.webkitURL;
-  const REGEXP_EXTENSION = /\.\w+$/;
-  const AnotherCompressor = WINDOW.Compressor;
+  var ArrayBuffer$1 = WINDOW.ArrayBuffer,
+    FileReader = WINDOW.FileReader;
+  var URL = WINDOW.URL || WINDOW.webkitURL;
+  var REGEXP_EXTENSION = /\.\w+$/;
+  var AnotherCompressor = WINDOW.Compressor;
 
   /**
    * Creates a new image compressor.
    * @class
    */
-  class Compressor {
+  var Compressor = /*#__PURE__*/function () {
     /**
      * The constructor of Compressor.
      * @param {File|Blob} file - The target image file for compressing.
      * @param {Object} [options] - The options for compressing.
      */
-    constructor(file, options) {
+    function Compressor(file, options) {
+      _classCallCheck(this, Compressor);
       this.file = file;
       this.exif = [];
       this.image = new Image();
-      this.options = {
-        ...DEFAULTS,
-        ...options
-      };
+      this.options = _objectSpread2(_objectSpread2({}, DEFAULTS), options);
       this.aborted = false;
       this.result = null;
       this.init();
     }
-    init() {
-      const {
-        file,
-        options
-      } = this;
-      if (!isBlob(file)) {
-        this.fail(new Error('The first argument must be a File or Blob object.'));
-        return;
-      }
-      const mimeType = file.type;
-      if (!isImageType(mimeType)) {
-        this.fail(new Error('The first argument must be an image File or Blob object.'));
-        return;
-      }
-      if (!URL || !FileReader) {
-        this.fail(new Error('The current browser does not support image compression.'));
-        return;
-      }
-      if (!ArrayBuffer$1) {
-        options.checkOrientation = false;
-        options.retainExif = false;
-      }
-      const isJPEGImage = mimeType === 'image/jpeg';
-      const checkOrientation = isJPEGImage && options.checkOrientation;
-      const retainExif = isJPEGImage && options.retainExif;
-      if (URL && !checkOrientation && !retainExif) {
-        this.load({
-          url: URL.createObjectURL(file)
-        });
-      } else {
-        const reader = new FileReader();
-        this.reader = reader;
-        reader.onload = _ref => {
-          let {
-            target
-          } = _ref;
-          const {
-            result
-          } = target;
-          const data = {};
-          let orientation = 1;
-          if (checkOrientation) {
-            // Reset the orientation value to its default value 1
-            // as some iOS browsers will render image with its orientation
-            orientation = resetAndGetOrientation(result);
-            if (orientation > 1) {
-              _extends(data, parseOrientation(orientation));
+    return _createClass(Compressor, [{
+      key: "init",
+      value: function init() {
+        var _this = this;
+        var file = this.file,
+          options = this.options;
+        if (!isBlob(file)) {
+          this.fail(new Error('The first argument must be a File or Blob object.'));
+          return;
+        }
+        var mimeType = file.type;
+        if (!isImageType(mimeType)) {
+          this.fail(new Error('The first argument must be an image File or Blob object.'));
+          return;
+        }
+        if (!URL || !FileReader) {
+          this.fail(new Error('The current browser does not support image compression.'));
+          return;
+        }
+        if (!ArrayBuffer$1) {
+          options.checkOrientation = false;
+          options.retainExif = false;
+        }
+        var isJPEGImage = mimeType === 'image/jpeg';
+        var checkOrientation = isJPEGImage && options.checkOrientation;
+        var retainExif = isJPEGImage && options.retainExif;
+        if (URL && !checkOrientation && !retainExif) {
+          this.load({
+            url: URL.createObjectURL(file)
+          });
+        } else {
+          var reader = new FileReader();
+          this.reader = reader;
+          reader.onload = function (_ref) {
+            var target = _ref.target;
+            var result = target.result;
+            var data = {};
+            var orientation = 1;
+            if (checkOrientation) {
+              // Reset the orientation value to its default value 1
+              // as some iOS browsers will render image with its orientation
+              orientation = resetAndGetOrientation(result);
+              if (orientation > 1) {
+                _extends(data, parseOrientation(orientation));
+              }
             }
-          }
-          if (retainExif) {
-            this.exif = getExif(result);
-          }
-          if (checkOrientation || retainExif) {
-            if (!URL
+            if (retainExif) {
+              _this.exif = getExif(result);
+            }
+            if (checkOrientation || retainExif) {
+              if (!URL
 
-            // Generate a new URL with the default orientation value 1.
-            || orientation > 1) {
-              data.url = arrayBufferToDataURL(result, mimeType);
+              // Generate a new URL with the default orientation value 1.
+              || orientation > 1) {
+                data.url = arrayBufferToDataURL(result, mimeType);
+              } else {
+                data.url = URL.createObjectURL(file);
+              }
             } else {
-              data.url = URL.createObjectURL(file);
+              data.url = result;
             }
+            _this.load(data);
+          };
+          reader.onabort = function () {
+            _this.fail(new Error('Aborted to read the image with FileReader.'));
+          };
+          reader.onerror = function () {
+            _this.fail(new Error('Failed to read the image with FileReader.'));
+          };
+          reader.onloadend = function () {
+            _this.reader = null;
+          };
+          if (checkOrientation || retainExif) {
+            reader.readAsArrayBuffer(file);
           } else {
-            data.url = result;
+            reader.readAsDataURL(file);
+          }
+        }
+      }
+    }, {
+      key: "load",
+      value: function load(data) {
+        var _this2 = this;
+        var file = this.file,
+          image = this.image;
+        image.onload = function () {
+          if (isCanvasAvailable()) {
+            _this2.draw(_objectSpread2(_objectSpread2({}, data), {}, {
+              naturalWidth: image.naturalWidth,
+              naturalHeight: image.naturalHeight
+            }));
+          } else {
+            _this2.done({
+              naturalWidth: image.naturalWidth,
+              naturalHeight: image.naturalHeight,
+              result: null
+            });
           }
-          this.load(data);
-        };
-        reader.onabort = () => {
-          this.fail(new Error('Aborted to read the image with FileReader.'));
         };
-        reader.onerror = () => {
-          this.fail(new Error('Failed to read the image with FileReader.'));
+        image.onabort = function () {
+          _this2.fail(new Error('Aborted to load the image.'));
         };
-        reader.onloadend = () => {
-          this.reader = null;
+        image.onerror = function () {
+          _this2.fail(new Error('Failed to load the image.'));
         };
-        if (checkOrientation || retainExif) {
-          reader.readAsArrayBuffer(file);
-        } else {
-          reader.readAsDataURL(file);
-        }
-      }
-    }
-    load(data) {
-      const {
-        file,
-        image
-      } = this;
-      image.onload = () => {
-        this.draw({
-          ...data,
-          naturalWidth: image.naturalWidth,
-          naturalHeight: image.naturalHeight
-        });
-      };
-      image.onabort = () => {
-        this.fail(new Error('Aborted to load the image.'));
-      };
-      image.onerror = () => {
-        this.fail(new Error('Failed to load the image.'));
-      };
 
-      // Match all browsers that use WebKit as the layout engine in iOS devices,
-      // such as Safari for iOS, Chrome for iOS, and in-app browsers.
-      if (WINDOW.navigator && /(?:iPad|iPhone|iPod).*?AppleWebKit/i.test(WINDOW.navigator.userAgent)) {
-        // Fix the `The operation is insecure` error (#57)
-        image.crossOrigin = 'anonymous';
-      }
-      image.alt = file.name;
-      image.src = data.url;
-    }
-    draw(_ref2) {
-      let {
-        naturalWidth,
-        naturalHeight,
-        rotate = 0,
-        scaleX = 1,
-        scaleY = 1
-      } = _ref2;
-      const {
-        file,
-        image,
-        options
-      } = this;
-      const canvas = document.createElement('canvas');
-      const context = canvas.getContext('2d');
-      const is90DegreesRotated = Math.abs(rotate) % 180 === 90;
-      const resizable = (options.resize === 'contain' || options.resize === 'cover') && isPositiveNumber(options.width) && isPositiveNumber(options.height);
-      let maxWidth = Math.max(options.maxWidth, 0) || Infinity;
-      let maxHeight = Math.max(options.maxHeight, 0) || Infinity;
-      let minWidth = Math.max(options.minWidth, 0) || 0;
-      let minHeight = Math.max(options.minHeight, 0) || 0;
-      let aspectRatio = naturalWidth / naturalHeight;
-      let {
-        width,
-        height
-      } = options;
-      if (is90DegreesRotated) {
-        [maxWidth, maxHeight] = [maxHeight, maxWidth];
-        [minWidth, minHeight] = [minHeight, minWidth];
-        [width, height] = [height, width];
-      }
-      if (resizable) {
-        aspectRatio = width / height;
-      }
-      ({
-        width: maxWidth,
-        height: maxHeight
-      } = getAdjustedSizes({
-        aspectRatio,
-        width: maxWidth,
-        height: maxHeight
-      }, 'contain'));
-      ({
-        width: minWidth,
-        height: minHeight
-      } = getAdjustedSizes({
-        aspectRatio,
-        width: minWidth,
-        height: minHeight
-      }, 'cover'));
-      if (resizable) {
-        ({
-          width,
-          height
-        } = getAdjustedSizes({
-          aspectRatio,
-          width,
-          height
-        }, options.resize));
-      } else {
-        ({
-          width = naturalWidth,
-          height = naturalHeight
-        } = getAdjustedSizes({
-          aspectRatio,
-          width,
-          height
-        }));
-      }
-      width = Math.floor(normalizeDecimalNumber(Math.min(Math.max(width, minWidth), maxWidth)));
-      height = Math.floor(normalizeDecimalNumber(Math.min(Math.max(height, minHeight), maxHeight)));
-      const destX = -width / 2;
-      const destY = -height / 2;
-      const destWidth = width;
-      const destHeight = height;
-      const params = [];
-      if (resizable) {
-        let srcX = 0;
-        let srcY = 0;
-        let srcWidth = naturalWidth;
-        let srcHeight = naturalHeight;
-        ({
-          width: srcWidth,
-          height: srcHeight
-        } = getAdjustedSizes({
-          aspectRatio,
-          width: naturalWidth,
-          height: naturalHeight
-        }, {
-          contain: 'cover',
-          cover: 'contain'
-        }[options.resize]));
-        srcX = (naturalWidth - srcWidth) / 2;
-        srcY = (naturalHeight - srcHeight) / 2;
-        params.push(srcX, srcY, srcWidth, srcHeight);
-      }
-      params.push(destX, destY, destWidth, destHeight);
-      if (is90DegreesRotated) {
-        [width, height] = [height, width];
-      }
-      canvas.width = width;
-      canvas.height = height;
-      if (!isImageType(options.mimeType)) {
-        options.mimeType = file.type;
+        // Match all browsers that use WebKit as the layout engine in iOS devices,
+        // such as Safari for iOS, Chrome for iOS, and in-app browsers.
+        if (WINDOW.navigator && /(?:iPad|iPhone|iPod).*?AppleWebKit/i.test(WINDOW.navigator.userAgent)) {
+          // Fix the `The operation is insecure` error (#57)
+          image.crossOrigin = 'anonymous';
+        }
+        image.alt = file.name;
+        image.src = data.url;
       }
-      let fillStyle = 'transparent';
+    }, {
+      key: "draw",
+      value: function draw(_ref2) {
+        var _this3 = this;
+        var naturalWidth = _ref2.naturalWidth,
+          naturalHeight = _ref2.naturalHeight,
+          _ref2$rotate = _ref2.rotate,
+          rotate = _ref2$rotate === void 0 ? 0 : _ref2$rotate,
+          _ref2$scaleX = _ref2.scaleX,
+          scaleX = _ref2$scaleX === void 0 ? 1 : _ref2$scaleX,
+          _ref2$scaleY = _ref2.scaleY,
+          scaleY = _ref2$scaleY === void 0 ? 1 : _ref2$scaleY;
+        var file = this.file,
+          image = this.image,
+          options = this.options;
+        var canvas = document.createElement('canvas');
+        var context = canvas.getContext('2d');
+        var is90DegreesRotated = Math.abs(rotate) % 180 === 90;
+        var resizable = (options.resize === 'contain' || options.resize === 'cover') && isPositiveNumber(options.width) && isPositiveNumber(options.height);
+        var maxWidth = Math.max(options.maxWidth, 0) || Infinity;
+        var maxHeight = Math.max(options.maxHeight, 0) || Infinity;
+        var minWidth = Math.max(options.minWidth, 0) || 0;
+        var minHeight = Math.max(options.minHeight, 0) || 0;
+        var aspectRatio = naturalWidth / naturalHeight;
+        var width = options.width,
+          height = options.height;
+        if (is90DegreesRotated) {
+          var _ref3 = [maxHeight, maxWidth];
+          maxWidth = _ref3[0];
+          maxHeight = _ref3[1];
+          var _ref4 = [minHeight, minWidth];
+          minWidth = _ref4[0];
+          minHeight = _ref4[1];
+          var _ref5 = [height, width];
+          width = _ref5[0];
+          height = _ref5[1];
+        }
+        if (resizable) {
+          aspectRatio = width / height;
+        }
+        var _getAdjustedSizes = getAdjustedSizes({
+          aspectRatio: aspectRatio,
+          width: maxWidth,
+          height: maxHeight
+        }, 'contain');
+        maxWidth = _getAdjustedSizes.width;
+        maxHeight = _getAdjustedSizes.height;
+        var _getAdjustedSizes2 = getAdjustedSizes({
+          aspectRatio: aspectRatio,
+          width: minWidth,
+          height: minHeight
+        }, 'cover');
+        minWidth = _getAdjustedSizes2.width;
+        minHeight = _getAdjustedSizes2.height;
+        if (resizable) {
+          var _getAdjustedSizes3 = getAdjustedSizes({
+            aspectRatio: aspectRatio,
+            width: width,
+            height: height
+          }, options.resize);
+          width = _getAdjustedSizes3.width;
+          height = _getAdjustedSizes3.height;
+        } else {
+          var _getAdjustedSizes4 = getAdjustedSizes({
+            aspectRatio: aspectRatio,
+            width: width,
+            height: height
+          });
+          var _getAdjustedSizes4$wi = _getAdjustedSizes4.width;
+          width = _getAdjustedSizes4$wi === void 0 ? naturalWidth : _getAdjustedSizes4$wi;
+          var _getAdjustedSizes4$he = _getAdjustedSizes4.height;
+          height = _getAdjustedSizes4$he === void 0 ? naturalHeight : _getAdjustedSizes4$he;
+        }
+        width = Math.floor(normalizeDecimalNumber(Math.min(Math.max(width, minWidth), maxWidth)));
+        height = Math.floor(normalizeDecimalNumber(Math.min(Math.max(height, minHeight), maxHeight)));
+        var destX = -width / 2;
+        var destY = -height / 2;
+        var destWidth = width;
+        var destHeight = height;
+        var params = [];
+        if (resizable) {
+          var srcX = 0;
+          var srcY = 0;
+          var srcWidth = naturalWidth;
+          var srcHeight = naturalHeight;
+          var _getAdjustedSizes5 = getAdjustedSizes({
+            aspectRatio: aspectRatio,
+            width: naturalWidth,
+            height: naturalHeight
+          }, {
+            contain: 'cover',
+            cover: 'contain'
+          }[options.resize]);
+          srcWidth = _getAdjustedSizes5.width;
+          srcHeight = _getAdjustedSizes5.height;
+          srcX = (naturalWidth - srcWidth) / 2;
+          srcY = (naturalHeight - srcHeight) / 2;
+          params.push(srcX, srcY, srcWidth, srcHeight);
+        }
+        params.push(destX, destY, destWidth, destHeight);
+        if (is90DegreesRotated) {
+          var _ref6 = [height, width];
+          width = _ref6[0];
+          height = _ref6[1];
+        }
+        canvas.width = width;
+        canvas.height = height;
+        if (!isImageType(options.mimeType)) {
+          options.mimeType = file.type;
+        }
+        var fillStyle = 'transparent';
 
-      // Converts PNG files over the `convertSize` to JPEGs.
-      if (file.size > options.convertSize && options.convertTypes.indexOf(options.mimeType) >= 0) {
-        options.mimeType = 'image/jpeg';
-      }
-      const isJPEGImage = options.mimeType === 'image/jpeg';
-      if (isJPEGImage) {
-        fillStyle = '#fff';
-      }
+        // Converts PNG files over the `convertSize` to JPEGs.
+        if (file.size > options.convertSize && options.convertTypes.indexOf(options.mimeType) >= 0) {
+          options.mimeType = 'image/jpeg';
+        }
+        var isJPEGImage = options.mimeType === 'image/jpeg';
+        if (isJPEGImage) {
+          fillStyle = '#fff';
+        }
 
-      // Override the default fill color (#000, black)
-      context.fillStyle = fillStyle;
-      context.fillRect(0, 0, width, height);
-      if (options.beforeDraw) {
-        options.beforeDraw.call(this, context, canvas);
-      }
-      if (this.aborted) {
-        return;
-      }
-      context.save();
-      context.translate(width / 2, height / 2);
-      context.rotate(rotate * Math.PI / 180);
-      context.scale(scaleX, scaleY);
-      context.drawImage(image, ...params);
-      context.restore();
-      if (options.drew) {
-        options.drew.call(this, context, canvas);
-      }
-      if (this.aborted) {
-        return;
-      }
-      const callback = blob => {
-        if (!this.aborted) {
-          const done = result => this.done({
-            naturalWidth,
-            naturalHeight,
-            result
-          });
-          if (blob && isJPEGImage && options.retainExif && this.exif && this.exif.length > 0) {
-            const next = arrayBuffer => done(toBlob(arrayBufferToDataURL(insertExif(arrayBuffer, this.exif), options.mimeType)));
-            if (blob.arrayBuffer) {
-              blob.arrayBuffer().then(next).catch(() => {
-                this.fail(new Error('Failed to read the compressed image with Blob.arrayBuffer().'));
+        // Override the default fill color (#000, black)
+        context.fillStyle = fillStyle;
+        context.fillRect(0, 0, width, height);
+        if (options.beforeDraw) {
+          options.beforeDraw.call(this, context, canvas);
+        }
+        if (this.aborted) {
+          return;
+        }
+        context.save();
+        context.translate(width / 2, height / 2);
+        context.rotate(rotate * Math.PI / 180);
+        context.scale(scaleX, scaleY);
+        context.drawImage.apply(context, [image].concat(params));
+        context.restore();
+        if (options.drew) {
+          options.drew.call(this, context, canvas);
+        }
+        if (this.aborted) {
+          return;
+        }
+        var callback = function callback(blob) {
+          if (!_this3.aborted) {
+            var done = function done(result) {
+              return _this3.done({
+                naturalWidth: naturalWidth,
+                naturalHeight: naturalHeight,
+                result: result
               });
-            } else {
-              const reader = new FileReader();
-              this.reader = reader;
-              reader.onload = _ref3 => {
-                let {
-                  target
-                } = _ref3;
-                next(target.result);
-              };
-              reader.onabort = () => {
-                this.fail(new Error('Aborted to read the compressed image with FileReader.'));
-              };
-              reader.onerror = () => {
-                this.fail(new Error('Failed to read the compressed image with FileReader.'));
-              };
-              reader.onloadend = () => {
-                this.reader = null;
+            };
+            if (blob && isJPEGImage && options.retainExif && _this3.exif && _this3.exif.length > 0) {
+              var next = function next(arrayBuffer) {
+                return done(toBlob(arrayBufferToDataURL(insertExif(arrayBuffer, _this3.exif), options.mimeType)));
               };
-              reader.readAsArrayBuffer(blob);
+              if (blob.arrayBuffer) {
+                blob.arrayBuffer().then(next).catch(function () {
+                  _this3.fail(new Error('Failed to read the compressed image with Blob.arrayBuffer().'));
+                });
+              } else {
+                var reader = new FileReader();
+                _this3.reader = reader;
+                reader.onload = function (_ref7) {
+                  var target = _ref7.target;
+                  next(target.result);
+                };
+                reader.onabort = function () {
+                  _this3.fail(new Error('Aborted to read the compressed image with FileReader.'));
+                };
+                reader.onerror = function () {
+                  _this3.fail(new Error('Failed to read the compressed image with FileReader.'));
+                };
+                reader.onloadend = function () {
+                  _this3.reader = null;
+                };
+                reader.readAsArrayBuffer(blob);
+              }
+            } else {
+              done(blob);
             }
-          } else {
-            done(blob);
           }
+        };
+        if (canvas.toBlob) {
+          canvas.toBlob(callback, options.mimeType, options.quality);
+        } else {
+          callback(toBlob(canvas.toDataURL(options.mimeType, options.quality)));
         }
-      };
-      if (canvas.toBlob) {
-        canvas.toBlob(callback, options.mimeType, options.quality);
-      } else {
-        callback(toBlob(canvas.toDataURL(options.mimeType, options.quality)));
-      }
-    }
-    done(_ref4) {
-      let {
-        naturalWidth,
-        naturalHeight,
-        result
-      } = _ref4;
-      const {
-        file,
-        image,
-        options
-      } = this;
-      if (URL && image.src.indexOf('blob:') === 0) {
-        URL.revokeObjectURL(image.src);
       }
-      if (result) {
-        // Returns original file if the result is greater than it and without size related options
-        if (options.strict && !options.retainExif && result.size > file.size && options.mimeType === file.type && !(options.width > naturalWidth || options.height > naturalHeight || options.minWidth > naturalWidth || options.minHeight > naturalHeight || options.maxWidth < naturalWidth || options.maxHeight < naturalHeight)) {
-          result = file;
-        } else {
-          const date = new Date();
-          result.lastModified = date.getTime();
-          result.lastModifiedDate = date;
-          result.name = file.name;
-
-          // Convert the extension to match its type
-          if (result.name && result.type !== file.type) {
-            result.name = result.name.replace(REGEXP_EXTENSION, imageTypeToExtension(result.type));
+    }, {
+      key: "done",
+      value: function done(_ref8) {
+        var naturalWidth = _ref8.naturalWidth,
+          naturalHeight = _ref8.naturalHeight,
+          result = _ref8.result;
+        var file = this.file,
+          image = this.image,
+          options = this.options;
+        if (URL && image.src.indexOf('blob:') === 0) {
+          URL.revokeObjectURL(image.src);
+        }
+        if (result) {
+          // Returns original file if the result is greater than it and without size related options
+          if (options.strict && !options.retainExif && result.size > file.size && options.mimeType === file.type && !(options.width > naturalWidth || options.height > naturalHeight || options.minWidth > naturalWidth || options.minHeight > naturalHeight || options.maxWidth < naturalWidth || options.maxHeight < naturalHeight)) {
+            result = file;
+          } else {
+            var fileName = file.name;
+
+            // Convert the extension to match its type
+            if (fileName && result.type !== file.type) {
+              fileName = fileName.replace(REGEXP_EXTENSION, imageTypeToExtension(result.type));
+            }
+            try {
+              // Convert the resulting Blob object into a File object for modern browsers.
+              result = new File([result], fileName, {
+                type: result.type
+              });
+            } catch (error) {
+              // Fallback to Blob if the File constructor is not supported.
+              var date = new Date();
+              result.name = fileName;
+
+              // The last modified date is not accurate, but it's better than nothing.
+              result.lastModified = date.getTime();
+              result.lastModifiedDate = date;
+            }
           }
+        } else {
+          // Returns original file if the result is null in some cases.
+          result = file;
+        }
+        this.result = result;
+        if (options.success) {
+          options.success.call(this, result);
         }
-      } else {
-        // Returns original file if the result is null in some cases.
-        result = file;
-      }
-      this.result = result;
-      if (options.success) {
-        options.success.call(this, result);
-      }
-    }
-    fail(err) {
-      const {
-        options
-      } = this;
-      if (options.error) {
-        options.error.call(this, err);
-      } else {
-        throw err;
       }
-    }
-    abort() {
-      if (!this.aborted) {
-        this.aborted = true;
-        if (this.reader) {
-          this.reader.abort();
-        } else if (!this.image.complete) {
-          this.image.onload = null;
-          this.image.onabort();
+    }, {
+      key: "fail",
+      value: function fail(err) {
+        var options = this.options;
+        if (options.error) {
+          options.error.call(this, err);
         } else {
-          this.fail(new Error('The compression process has been aborted.'));
+          throw err;
+        }
+      }
+    }, {
+      key: "abort",
+      value: function abort() {
+        if (!this.aborted) {
+          this.aborted = true;
+          if (this.reader) {
+            this.reader.abort();
+          } else if (!this.image.complete) {
+            this.image.onload = null;
+            this.image.onabort();
+          } else {
+            this.fail(new Error('The compression process has been aborted.'));
+          }
         }
       }
-    }
 
-    /**
-     * Get the no conflict compressor class.
-     * @returns {Compressor} The compressor class.
-     */
-    static noConflict() {
-      window.Compressor = AnotherCompressor;
-      return Compressor;
-    }
+      /**
+       * Get the no conflict compressor class.
+       * @returns {Compressor} The compressor class.
+       */
+    }], [{
+      key: "noConflict",
+      value: function noConflict() {
+        window.Compressor = AnotherCompressor;
+        return Compressor;
+      }
 
-    /**
-     * Change the default options.
-     * @param {Object} options - The new default options.
-     */
-    static setDefaults(options) {
-      _extends(DEFAULTS, options);
-    }
-  }
+      /**
+       * Change the default options.
+       * @param {Object} options - The new default options.
+       */
+    }, {
+      key: "setDefaults",
+      value: function setDefaults(options) {
+        _extends(DEFAULTS, options);
+      }
+    }]);
+  }();
 
   return Compressor;