compressorjs 1.1.0 → 1.2.0

package/dist/compressor.common.js

@@ -1,105 +1,27 @@
 /*!
- * Compressor.js v1.1.0
+ * Compressor.js v1.2.0
  * https://fengyuanchen.github.io/compressorjs
  *
  * Copyright 2018-present Chen Fengyuan
  * Released under the MIT license
  *
- * Date: 2021-10-01T06:37:01.455Z
+ * Date: 2023-02-25T11:35:56.625Z
  */
 
 'use strict';
 
-function ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
-
-  if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-
-    if (enumerableOnly) {
-      symbols = symbols.filter(function (sym) {
-        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-      });
-    }
-
-    keys.push.apply(keys, symbols);
-  }
-
-  return keys;
-}
-
-function _objectSpread2(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = arguments[i] != null ? arguments[i] : {};
-
-    if (i % 2) {
-      ownKeys(Object(source), true).forEach(function (key) {
-        _defineProperty(target, key, source[key]);
-      });
-    } else if (Object.getOwnPropertyDescriptors) {
-      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-    } else {
-      ownKeys(Object(source)).forEach(function (key) {
-        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-      });
-    }
-  }
-
-  return target;
-}
-
-function _classCallCheck(instance, Constructor) {
-  if (!(instance instanceof Constructor)) {
-    throw new TypeError("Cannot call a class as a function");
-  }
-}
-
-function _defineProperties(target, props) {
-  for (var i = 0; i < props.length; i++) {
-    var descriptor = props[i];
-    descriptor.enumerable = descriptor.enumerable || false;
-    descriptor.configurable = true;
-    if ("value" in descriptor) descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
-  }
-}
-
-function _createClass(Constructor, protoProps, staticProps) {
-  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-  if (staticProps) _defineProperties(Constructor, staticProps);
-  return Constructor;
-}
-
-function _defineProperty(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-
-  return obj;
-}
-
 function _extends() {
-  _extends = Object.assign || function (target) {
+  _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 target;
   };
-
   return _extends.apply(this, arguments);
 }
 
@@ -118,13 +40,13 @@ var canvasToBlob = {exports: {}};
  * Based on stackoverflow user Stoive's code snippet:
  * http://stackoverflow.com/q/4998908
  */
-
 (function (module) {
-
+  if (typeof window === 'undefined') {
+    return;
+  }
   (function (window) {
 
     var CanvasPrototype = window.HTMLCanvasElement && window.HTMLCanvasElement.prototype;
-
     var hasBlobConstructor = window.Blob && function () {
       try {
         return Boolean(new Blob());
@@ -132,7 +54,6 @@ var canvasToBlob = {exports: {}};
         return false;
       }
     }();
-
     var hasArrayBufferViewSupport = hasBlobConstructor && window.Uint8Array && function () {
       try {
         return new Blob([new Uint8Array(100)]).size === 100;
@@ -140,52 +61,42 @@ var canvasToBlob = {exports: {}};
         return false;
       }
     }();
-
     var BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;
     var dataURIPattern = /^data:((.*?)(;charset=.*?)?)(;base64)?,/;
-
     var dataURLtoBlob = (hasBlobConstructor || BlobBuilder) && window.atob && window.ArrayBuffer && window.Uint8Array && function (dataURI) {
-      var matches, mediaType, isBase64, dataString, byteString, arrayBuffer, intArray, i, bb; // Parse the dataURI components as per RFC 2397
-
+      var matches, mediaType, isBase64, dataString, byteString, arrayBuffer, intArray, i, bb;
+      // Parse the dataURI components as per RFC 2397
       matches = dataURI.match(dataURIPattern);
-
       if (!matches) {
         throw new Error('invalid data URI');
-      } // Default to text/plain;charset=US-ASCII
-
-
+      }
+      // Default to text/plain;charset=US-ASCII
       mediaType = matches[2] ? matches[1] : 'text/plain' + (matches[3] || ';charset=US-ASCII');
       isBase64 = !!matches[4];
       dataString = dataURI.slice(matches[0].length);
-
       if (isBase64) {
         // Convert base64 to raw binary data held in a string:
         byteString = atob(dataString);
       } else {
         // Convert base64/URLEncoded data component to raw binary:
         byteString = decodeURIComponent(dataString);
-      } // Write the bytes of the string to an ArrayBuffer:
-
-
+      }
+      // Write the bytes of the string to an ArrayBuffer:
       arrayBuffer = new ArrayBuffer(byteString.length);
       intArray = new Uint8Array(arrayBuffer);
-
       for (i = 0; i < byteString.length; i += 1) {
         intArray[i] = byteString.charCodeAt(i);
-      } // Write the ArrayBuffer (or ArrayBufferView) to a blob:
-
-
+      }
+      // Write the ArrayBuffer (or ArrayBufferView) to a blob:
       if (hasBlobConstructor) {
         return new Blob([hasArrayBufferViewSupport ? intArray : arrayBuffer], {
           type: mediaType
         });
       }
-
       bb = new BlobBuilder();
       bb.append(arrayBuffer);
       return bb.getBlob(mediaType);
     };
-
     if (window.HTMLCanvasElement && !CanvasPrototype.toBlob) {
       if (CanvasPrototype.mozGetAsFile) {
         CanvasPrototype.toBlob = function (callback, type, quality) {
@@ -220,7 +131,6 @@ var canvasToBlob = {exports: {}};
         }
       }
     }
-
     if (module.exports) {
       module.exports = dataURLtoBlob;
     } else {
@@ -228,14 +138,12 @@ var canvasToBlob = {exports: {}};
     }
   })(window);
 })(canvasToBlob);
-
 var toBlob = canvasToBlob.exports;
 
-var isBlob = function isBlob(value) {
+var isBlob = value => {
   if (typeof Blob === 'undefined') {
     return false;
   }
-
   return value instanceof Blob || Object.prototype.toString.call(value) === '[object Blob]';
 };
 
@@ -246,59 +154,55 @@ var DEFAULTS = {
    * @type {boolean}
    */
   strict: true,
-
   /**
    * Indicates if read the image's Exif Orientation information,
    * and then rotate or flip the image automatically.
    * @type {boolean}
    */
   checkOrientation: true,
-
+  /**
+   * Indicates if retain the image's Exif information after compressed.
+   * @type {boolean}
+  */
+  retainExif: false,
   /**
    * The max width of the output image.
    * @type {number}
    */
   maxWidth: Infinity,
-
   /**
    * The max height of the output image.
    * @type {number}
    */
   maxHeight: Infinity,
-
   /**
    * The min width of the output image.
    * @type {number}
    */
   minWidth: 0,
-
   /**
    * The min height of the output image.
    * @type {number}
    */
   minHeight: 0,
-
   /**
    * The width of the output image.
    * If not specified, the natural width of the source image will be used.
    * @type {number}
    */
   width: undefined,
-
   /**
    * The height of the output image.
    * If not specified, the natural height of the source image will be used.
    * @type {number}
    */
   height: undefined,
-
   /**
    * Sets how the size of the image should be resized to the container
    * specified by the `width` and `height` options.
    * @type {string}
    */
   resize: 'none',
-
   /**
    * The quality of the output image.
    * It must be a number between `0` and `1`,
@@ -307,28 +211,24 @@ var DEFAULTS = {
    * @type {number}
    */
   quality: 0.8,
-
   /**
    * The mime type of the output image.
    * By default, the original mime type of the source image file will be used.
    * @type {string}
    */
   mimeType: 'auto',
-
   /**
    * Files whose file type is included in this list,
    * and whose file size exceeds the `convertSize` value will be converted to JPEGs.
    * @type {string｜Array}
    */
   convertTypes: ['image/png'],
-
   /**
    * PNG files over this size (5 MB by default) will be converted to JPEGs.
    * To disable this, just set the value to `Infinity`.
    * @type {number}
    */
   convertSize: 5000000,
-
   /**
    * The hook function to execute before draw the image into the canvas for compression.
    * @type {Function}
@@ -340,7 +240,6 @@ var DEFAULTS = {
    * }
    */
   beforeDraw: null,
-
   /**
    * The hook function to execute after drew the image into the canvas for compression.
    * @type {Function}
@@ -352,7 +251,6 @@ var DEFAULTS = {
    * }
    */
   drew: null,
-
   /**
    * The hook function to execute when success to compress the image.
    * @type {Function}
@@ -363,7 +261,6 @@ var DEFAULTS = {
    * }
    */
   success: null,
-
   /**
    * The hook function to execute when fail to compress the image.
    * @type {Function}
@@ -376,54 +273,54 @@ var DEFAULTS = {
   error: null
 };
 
-var IS_BROWSER = typeof window !== 'undefined' && typeof window.document !== 'undefined';
-var WINDOW = IS_BROWSER ? window : {};
+const IS_BROWSER = typeof window !== 'undefined' && typeof window.document !== 'undefined';
+const 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.
  * @param {*} value - The value to convert.
  * @returns {Array} Returns a new array.
  */
-
 function toArray(value) {
   return Array.from ? Array.from(value) : slice.call(value);
 }
-var REGEXP_IMAGE_TYPE = /^image\/.+$/;
+const REGEXP_IMAGE_TYPE = /^image\/.+$/;
+
 /**
  * Check if the given value is a mime type of image.
  * @param {*} value - The value to check.
  * @returns {boolean} Returns `true` if the given is a mime type of image, else `false`.
  */
-
 function isImageType(value) {
   return REGEXP_IMAGE_TYPE.test(value);
 }
+
 /**
  * Convert image type to extension.
  * @param {string} value - The image type to convert.
  * @returns {boolean} Returns the image extension.
  */
-
 function imageTypeToExtension(value) {
-  var extension = isImageType(value) ? value.substr(6) : '';
-
+  let extension = isImageType(value) ? value.substr(6) : '';
   if (extension === 'jpeg') {
     extension = 'jpg';
   }
-
-  return ".".concat(extension);
+  return `.${extension}`;
 }
-var fromCharCode = String.fromCharCode;
+const {
+  fromCharCode
+} = String;
+
 /**
  * Get string from char code in data view.
  * @param {DataView} dataView - The data view for read.
@@ -431,83 +328,74 @@ var fromCharCode = String.fromCharCode;
  * @param {number} length - The read length.
  * @returns {string} The read result.
  */
-
 function getStringFromCharCode(dataView, start, length) {
-  var str = '';
-  var i;
+  let str = '';
+  let i;
   length += start;
-
   for (i = start; i < length; i += 1) {
     str += fromCharCode(dataView.getUint8(i));
   }
-
   return str;
 }
-var btoa = WINDOW.btoa;
+const {
+  btoa
+} = WINDOW;
+
 /**
  * Transform array buffer to Data URL.
  * @param {ArrayBuffer} arrayBuffer - The array buffer to transform.
  * @param {string} mimeType - The mime type of the Data URL.
  * @returns {string} The result Data URL.
  */
-
 function arrayBufferToDataURL(arrayBuffer, mimeType) {
-  var chunks = [];
-  var chunkSize = 8192;
-  var uint8 = new Uint8Array(arrayBuffer);
-
+  const chunks = [];
+  const chunkSize = 8192;
+  let 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:".concat(mimeType, ";base64,").concat(btoa(chunks.join('')));
+  return `data:${mimeType};base64,${btoa(chunks.join(''))}`;
 }
+
 /**
  * Get orientation value from given array buffer.
  * @param {ArrayBuffer} arrayBuffer - The array buffer to read.
  * @returns {number} The read orientation value.
  */
-
 function resetAndGetOrientation(arrayBuffer) {
-  var dataView = new DataView(arrayBuffer);
-  var orientation; // Ignores range error when the image does not have correct Exif information
+  const dataView = new DataView(arrayBuffer);
+  let orientation;
 
+  // Ignores range error when the image does not have correct Exif information
   try {
-    var littleEndian;
-    var app1Start;
-    var ifdStart; // Only handle JPEG image (start by 0xFFD8)
+    let littleEndian;
+    let app1Start;
+    let ifdStart;
 
+    // Only handle JPEG image (start by 0xFFD8)
     if (dataView.getUint8(0) === 0xFF && dataView.getUint8(1) === 0xD8) {
-      var length = dataView.byteLength;
-      var offset = 2;
-
+      const length = dataView.byteLength;
+      let offset = 2;
       while (offset + 1 < length) {
         if (dataView.getUint8(offset) === 0xFF && dataView.getUint8(offset + 1) === 0xE1) {
           app1Start = offset;
           break;
         }
-
         offset += 1;
       }
     }
-
     if (app1Start) {
-      var exifIDCode = app1Start + 4;
-      var tiffOffset = app1Start + 10;
-
+      const exifIDCode = app1Start + 4;
+      const tiffOffset = app1Start + 10;
       if (getStringFromCharCode(dataView, exifIDCode, 4) === 'Exif') {
-        var endianness = dataView.getUint16(tiffOffset);
+        const endianness = dataView.getUint16(tiffOffset);
         littleEndian = endianness === 0x4949;
-
-        if (littleEndian || endianness === 0x4D4D
-        /* bigEndian */
-        ) {
+        if (littleEndian || endianness === 0x4D4D /* bigEndian */) {
           if (dataView.getUint16(tiffOffset + 2, littleEndian) === 0x002A) {
-            var firstIFDOffset = dataView.getUint32(tiffOffset + 4, littleEndian);
-
+            const firstIFDOffset = dataView.getUint32(tiffOffset + 4, littleEndian);
             if (firstIFDOffset >= 0x00000008) {
               ifdStart = tiffOffset + firstIFDOffset;
             }
@@ -515,26 +403,21 @@ function resetAndGetOrientation(arrayBuffer) {
         }
       }
     }
-
     if (ifdStart) {
-      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 */
-        ) {
+      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 */) {
           // 8 is the offset of the current tag's value
-          _offset += 8; // Get the original orientation value
+          offset += 8;
 
-          orientation = dataView.getUint16(_offset, littleEndian); // Override the orientation with its default value
+          // Get the original orientation value
+          orientation = dataView.getUint16(offset, littleEndian);
 
-          dataView.setUint16(_offset, 1, littleEndian);
+          // Override the orientation with its default value
+          dataView.setUint16(offset, 1, littleEndian);
           break;
         }
       }
@@ -542,66 +425,64 @@ function resetAndGetOrientation(arrayBuffer) {
   } catch (e) {
     orientation = 1;
   }
-
   return orientation;
 }
+
 /**
  * Parse Exif Orientation value.
  * @param {number} orientation - The orientation to parse.
  * @returns {Object} The parsed result.
  */
-
 function parseOrientation(orientation) {
-  var rotate = 0;
-  var scaleX = 1;
-  var scaleY = 1;
-
+  let rotate = 0;
+  let scaleX = 1;
+  let scaleY = 1;
   switch (orientation) {
     // Flip horizontal
     case 2:
       scaleX = -1;
       break;
-    // Rotate left 180°
 
+    // Rotate left 180°
     case 3:
       rotate = -180;
       break;
-    // Flip vertical
 
+    // Flip vertical
     case 4:
       scaleY = -1;
       break;
-    // Flip vertical and rotate right 90°
 
+    // Flip vertical and rotate right 90°
     case 5:
       rotate = 90;
       scaleY = -1;
       break;
-    // Rotate right 90°
 
+    // Rotate right 90°
     case 6:
       rotate = 90;
       break;
-    // Flip horizontal and rotate right 90°
 
+    // Flip horizontal and rotate right 90°
     case 7:
       rotate = 90;
       scaleX = -1;
       break;
-    // Rotate left 90°
 
+    // Rotate left 90°
     case 8:
       rotate = -90;
       break;
   }
-
   return {
-    rotate: rotate,
-    scaleX: scaleX,
-    scaleY: scaleY
+    rotate,
+    scaleX,
+    scaleY
   };
 }
-var REGEXP_DECIMALS = /\.\d*(?:0|9){12}\d*$/;
+const REGEXP_DECIMALS = /\.\d*(?:0|9){12}\d*$/;
+
 /**
  * Normalize decimal number.
  * Check out {@link https://0.30000000000000004.com/}
@@ -609,29 +490,28 @@ var REGEXP_DECIMALS = /\.\d*(?:0|9){12}\d*$/;
  * @param {number} [times=100000000000] - The times for normalizing.
  * @returns {number} Returns the normalized number.
  */
-
 function normalizeDecimalNumber(value) {
-  var times = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100000000000;
+  let times = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100000000000;
   return REGEXP_DECIMALS.test(value) ? Math.round(value * times) / times : value;
 }
+
 /**
  * Get the max sizes in a rectangle under the given aspect ratio.
  * @param {Object} data - The original sizes.
  * @param {string} [type='contain'] - The adjust type.
  * @returns {Object} The result sizes.
  */
-
 function getAdjustedSizes(_ref) {
-  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);
-
+  let {
+    aspectRatio,
+    height,
+    width
+  } = _ref;
+  let type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'none';
+  const isValidWidth = isPositiveNumber(width);
+  const isValidHeight = isPositiveNumber(height);
   if (isValidWidth && isValidHeight) {
-    var adjustedWidth = height * aspectRatio;
-
+    const adjustedWidth = height * aspectRatio;
     if ((type === 'contain' || type === 'none') && adjustedWidth > width || type === 'cover' && adjustedWidth < width) {
       height = width / aspectRatio;
     } else {
@@ -642,429 +522,467 @@ function getAdjustedSizes(_ref) {
   } else if (isValidHeight) {
     width = height * aspectRatio;
   }
-
   return {
-    width: width,
-    height: height
+    width,
+    height
   };
 }
 
-var ArrayBuffer$1 = WINDOW.ArrayBuffer,
-    FileReader = WINDOW.FileReader;
-var URL = WINDOW.URL || WINDOW.webkitURL;
-var REGEXP_EXTENSION = /\.\w+$/;
-var AnotherCompressor = WINDOW.Compressor;
+/**
+ * Get Exif information from the given array buffer.
+ * @param {ArrayBuffer} arrayBuffer - The array buffer to read.
+ * @returns {Array} The read Exif information.
+ */
+function getExif(arrayBuffer) {
+  const array = toArray(new Uint8Array(arrayBuffer));
+  const {
+    length
+  } = array;
+  const segments = [];
+  let start = 0;
+  while (start + 3 < length) {
+    const value = array[start];
+    const next = array[start + 1];
+
+    // SOS (Start of Scan)
+    if (value === 0xFF && next === 0xDA) {
+      break;
+    }
+
+    // SOI (Start of Image)
+    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);
+      segments.push(segment);
+      start = end;
+    }
+  }
+  return segments.reduce((exifArray, current) => {
+    if (current[0] === 0xFF && current[1] === 0xE1) {
+      return exifArray.concat(current);
+    }
+    return exifArray;
+  }, []);
+}
+
+/**
+ * Insert Exif information into the given array buffer.
+ * @param {ArrayBuffer} arrayBuffer - The array buffer to transform.
+ * @param {Array} exifArray - The Exif information to insert.
+ * @returns {ArrayBuffer} The transformed array buffer.
+ */
+function insertExif(arrayBuffer, exifArray) {
+  const 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));
+  return new Uint8Array(newArrayBuffer);
+}
+
+const {
+  ArrayBuffer: ArrayBuffer$1,
+  FileReader
+} = WINDOW;
+const URL = WINDOW.URL || WINDOW.webkitURL;
+const REGEXP_EXTENSION = /\.\w+$/;
+const AnotherCompressor = WINDOW.Compressor;
+
 /**
  * Creates a new image compressor.
  * @class
  */
-
-var Compressor = /*#__PURE__*/function () {
+class Compressor {
   /**
    * The constructor of Compressor.
    * @param {File|Blob} file - The target image file for compressing.
    * @param {Object} [options] - The options for compressing.
    */
-  function Compressor(file, options) {
-    _classCallCheck(this, Compressor);
-
+  constructor(file, options) {
     this.file = file;
+    this.exif = [];
     this.image = new Image();
-    this.options = _objectSpread2(_objectSpread2({}, DEFAULTS), options);
+    this.options = {
+      ...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));
+          }
+        }
+        if (retainExif) {
+          this.exif = getExif(result);
+        }
+        if (checkOrientation || retainExif) {
+          if (!URL
 
-  _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;
-      }
-
-      if (URL && !options.checkOrientation) {
-        this.load({
-          url: URL.createObjectURL(file)
-        });
-      } else {
-        var reader = new FileReader();
-        var checkOrientation = options.checkOrientation && mimeType === 'image/jpeg';
-        this.reader = reader;
-
-        reader.onload = function (_ref) {
-          var target = _ref.target;
-          var result = target.result;
-          var data = {};
-
-          if (checkOrientation) {
-            // Reset the orientation value to its default value 1
-            // as some iOS browsers will render image with its orientation
-            var orientation = resetAndGetOrientation(result);
-
-            if (orientation > 1 || !URL) {
-              // Generate a new URL which has the default orientation value
-              data.url = arrayBufferToDataURL(result, mimeType);
-
-              if (orientation > 1) {
-                _extends(data, parseOrientation(orientation));
-              }
-            } else {
-              data.url = URL.createObjectURL(file);
-            }
+          // Generate a new URL with the default orientation value 1.
+          || orientation > 1) {
+            data.url = arrayBufferToDataURL(result, mimeType);
           } else {
-            data.url = result;
+            data.url = URL.createObjectURL(file);
           }
-
-          _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) {
-          reader.readAsArrayBuffer(file);
         } else {
-          reader.readAsDataURL(file);
+          data.url = result;
         }
-      }
-    }
-  }, {
-    key: "load",
-    value: function load(data) {
-      var _this2 = this;
-
-      var file = this.file,
-          image = this.image;
-
-      image.onload = function () {
-        _this2.draw(_objectSpread2(_objectSpread2({}, data), {}, {
-          naturalWidth: image.naturalWidth,
-          naturalHeight: image.naturalHeight
-        }));
+        this.load(data);
       };
-
-      image.onabort = function () {
-        _this2.fail(new Error('Aborted to load the image.'));
+      reader.onabort = () => {
+        this.fail(new Error('Aborted to read the image with FileReader.'));
       };
-
-      image.onerror = function () {
-        _this2.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;
-    }
-  }, {
-    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';
-      }
-
-      if (options.mimeType === 'image/jpeg') {
-        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.apply(context, [image].concat(params));
-      context.restore();
-
-      if (options.drew) {
-        options.drew.call(this, context, canvas);
-      }
-
-      if (this.aborted) {
-        return;
-      }
-
-      var done = function done(result) {
-        if (!_this3.aborted) {
-          _this3.done({
-            naturalWidth: naturalWidth,
-            naturalHeight: naturalHeight,
-            result: result
-          });
-        }
+      reader.onerror = () => {
+        this.fail(new Error('Failed to read the image with FileReader.'));
       };
-
-      if (canvas.toBlob) {
-        canvas.toBlob(done, options.mimeType, options.quality);
+      reader.onloadend = () => {
+        this.reader = null;
+      };
+      if (checkOrientation || retainExif) {
+        reader.readAsArrayBuffer(file);
       } else {
-        done(toBlob(canvas.toDataURL(options.mimeType, options.quality)));
+        reader.readAsDataURL(file);
       }
     }
-  }, {
-    key: "done",
-    value: function done(_ref7) {
-      var naturalWidth = _ref7.naturalWidth,
-          naturalHeight = _ref7.naturalHeight,
-          result = _ref7.result;
-      var file = this.file,
-          image = this.image,
-          options = this.options;
+  }
+  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.'));
+    };
 
-      if (URL && !options.checkOrientation) {
-        URL.revokeObjectURL(image.src);
-      }
+    // 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;
+    }
+    let fillStyle = 'transparent';
 
-      if (result) {
-        // Returns original file if the result is greater than it and without size related options
-        if (options.strict && 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 date = new Date();
-          result.lastModified = date.getTime();
-          result.lastModifiedDate = date;
-          result.name = file.name; // Convert the extension to match its type
+    // 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';
+    }
 
-          if (result.name && result.type !== file.type) {
-            result.name = result.name.replace(REGEXP_EXTENSION, imageTypeToExtension(result.type));
+    // 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().'));
+            });
+          } 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;
+            };
+            reader.readAsArrayBuffer(blob);
           }
+        } else {
+          done(blob);
         }
-      } 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);
       }
+    };
+    if (canvas.toBlob) {
+      canvas.toBlob(callback, options.mimeType, options.quality);
+    } else {
+      callback(toBlob(canvas.toDataURL(options.mimeType, options.quality)));
     }
-  }, {
-    key: "fail",
-    value: function fail(err) {
-      var options = this.options;
-
-      if (options.error) {
-        options.error.call(this, err);
-      } else {
-        throw err;
-      }
+  }
+  done(_ref4) {
+    let {
+      naturalWidth,
+      naturalHeight,
+      result
+    } = _ref4;
+    const {
+      file,
+      image,
+      options
+    } = this;
+    if (URL && image.src.indexOf('blob:') === 0) {
+      URL.revokeObjectURL(image.src);
     }
-  }, {
-    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.'));
+    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));
         }
       }
+    } else {
+      // Returns original file if the result is null in some cases.
+      result = file;
     }
-    /**
-     * Get the no conflict compressor class.
-     * @returns {Compressor} The compressor class.
-     */
-
-  }], [{
-    key: "noConflict",
-    value: function noConflict() {
-      window.Compressor = AnotherCompressor;
-      return Compressor;
+    this.result = result;
+    if (options.success) {
+      options.success.call(this, result);
     }
-    /**
-     * Change the default options.
-     * @param {Object} options - The new default options.
-     */
-
-  }, {
-    key: "setDefaults",
-    value: function setDefaults(options) {
-      _extends(DEFAULTS, options);
+  }
+  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();
+      } 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;
+  }
 
-  return Compressor;
-}();
+  /**
+   * Change the default options.
+   * @param {Object} options - The new default options.
+   */
+  static setDefaults(options) {
+    _extends(DEFAULTS, options);
+  }
+}
 
 module.exports = Compressor;