pica 7.0.0 → 9.0.0

package/dist/pica.js

@@ -13,8 +13,6 @@ https://github.com/nodeca/pica
 //
 'use strict';
 
-var inherits = _dereq_('inherits');
-
 var Multimath = _dereq_('multimath');
 
 var mm_unsharp_mask = _dereq_('./mm_unsharp_mask');
@@ -37,7 +35,8 @@ function MathLib(requested_features) {
   this.use(mm_resize);
 }
 
-inherits(MathLib, Multimath);
+MathLib.prototype = Object.create(Multimath.prototype);
+MathLib.prototype.constructor = MathLib;
 
 MathLib.prototype.resizeAndUnsharp = function resizeAndUnsharp(options, cache) {
   var result = this.resize(options, cache);
@@ -51,7 +50,7 @@ MathLib.prototype.resizeAndUnsharp = function resizeAndUnsharp(options, cache) {
 
 module.exports = MathLib;
 
-},{"./mm_resize":4,"./mm_unsharp_mask":9,"inherits":19,"multimath":20}],2:[function(_dereq_,module,exports){
+},{"./mm_resize":4,"./mm_unsharp_mask":9,"multimath":19}],2:[function(_dereq_,module,exports){
 // Resize convolvers, pure JS implementation
 //
 'use strict'; // Precision of fixed FP values
@@ -59,18 +58,23 @@ module.exports = MathLib;
 
 function clampTo8(i) {
   return i < 0 ? 0 : i > 255 ? 255 : i;
-} // Convolve image in horizontal directions and transpose output. In theory,
-// transpose allow:
+}
+
+function clampNegative(i) {
+  return i >= 0 ? i : 0;
+} // Convolve image data in horizontal direction. Can be used for:
+//
+// 1. bitmap with premultiplied alpha
+// 2. bitmap without alpha (all values 255)
 //
-// - use the same convolver for both passes (this fails due different
-//   types of input array and temporary buffer)
-// - making vertical pass by horisonltal lines inprove CPU cache use.
+// Notes:
 //
-// But in real life this doesn't work :)
+// - output is transposed
+// - output resolution is ~15 bits per channel(for better precision).
 //
 
 
-function convolveHorizontally(src, dest, srcW, srcH, destW, filters) {
+function convolveHor(src, dest, srcW, srcH, destW, filters) {
   var r, g, b, a;
   var filterPtr, filterShift, filterSize;
   var srcPtr, srcY, destX, filterVal;
@@ -96,39 +100,26 @@ function convolveHorizontally(src, dest, srcW, srcH, destW, filters) {
         g = g + filterVal * src[srcPtr + 1] | 0;
         r = r + filterVal * src[srcPtr] | 0;
         srcPtr = srcPtr + 4 | 0;
-      } // Bring this value back in range. All of the filter scaling factors
-      // are in fixed point with FIXED_FRAC_BITS bits of fractional part.
-      //
-      // (!) Add 1/2 of value before clamping to get proper rounding. In other
-      // case brightness loss will be noticeable if you resize image with white
-      // border and place it on white background.
+      } // Store 15 bits between passes for better precision
+      // Instead of shift to 14 (FIXED_FRAC_BITS), shift to 7 only
       //
 
 
-      dest[destOffset + 3] = clampTo8(a + (1 << 13) >> 14
-      /*FIXED_FRAC_BITS*/
-      );
-      dest[destOffset + 2] = clampTo8(b + (1 << 13) >> 14
-      /*FIXED_FRAC_BITS*/
-      );
-      dest[destOffset + 1] = clampTo8(g + (1 << 13) >> 14
-      /*FIXED_FRAC_BITS*/
-      );
-      dest[destOffset] = clampTo8(r + (1 << 13) >> 14
-      /*FIXED_FRAC_BITS*/
-      );
+      dest[destOffset + 3] = clampNegative(a >> 7);
+      dest[destOffset + 2] = clampNegative(b >> 7);
+      dest[destOffset + 1] = clampNegative(g >> 7);
+      dest[destOffset] = clampNegative(r >> 7);
       destOffset = destOffset + srcH * 4 | 0;
     }
 
     destOffset = (srcY + 1) * 4 | 0;
     srcOffset = (srcY + 1) * srcW * 4 | 0;
   }
-} // Technically, convolvers are the same. But input array and temporary
-// buffer can be of different type (especially, in old browsers). So,
-// keep code in separate functions to avoid deoptimizations & speed loss.
+} // Supplementary method for `convolveHor()`
+//
 
 
-function convolveVertically(src, dest, srcW, srcH, destW, filters) {
+function convolveVert(src, dest, srcW, srcH, destW, filters) {
   var r, g, b, a;
   var filterPtr, filterShift, filterSize;
   var srcPtr, srcY, destX, filterVal;
@@ -154,27 +145,134 @@ function convolveVertically(src, dest, srcW, srcH, destW, filters) {
         g = g + filterVal * src[srcPtr + 1] | 0;
         r = r + filterVal * src[srcPtr] | 0;
         srcPtr = srcPtr + 4 | 0;
-      } // Bring this value back in range. All of the filter scaling factors
-      // are in fixed point with FIXED_FRAC_BITS bits of fractional part.
+      } // Sync with premultiplied version for exact result match
+
+
+      r >>= 7;
+      g >>= 7;
+      b >>= 7;
+      a >>= 7; // Bring this value back in range + round result.
+      //
+
+      dest[destOffset + 3] = clampTo8(a + (1 << 13) >> 14);
+      dest[destOffset + 2] = clampTo8(b + (1 << 13) >> 14);
+      dest[destOffset + 1] = clampTo8(g + (1 << 13) >> 14);
+      dest[destOffset] = clampTo8(r + (1 << 13) >> 14);
+      destOffset = destOffset + srcH * 4 | 0;
+    }
+
+    destOffset = (srcY + 1) * 4 | 0;
+    srcOffset = (srcY + 1) * srcW * 4 | 0;
+  }
+} // Premultiply & convolve image data in horizontal direction. Can be used for:
+//
+// - Any bitmap data, extracted with `.getImageData()` method (with
+//   non-premultiplied alpha)
+//
+// For images without alpha channel this method is slower than `convolveHor()`
+//
+
+
+function convolveHorWithPre(src, dest, srcW, srcH, destW, filters) {
+  var r, g, b, a, alpha;
+  var filterPtr, filterShift, filterSize;
+  var srcPtr, srcY, destX, filterVal;
+  var srcOffset = 0,
+      destOffset = 0; // For each row
+
+  for (srcY = 0; srcY < srcH; srcY++) {
+    filterPtr = 0; // Apply precomputed filters to each destination row point
+
+    for (destX = 0; destX < destW; destX++) {
+      // Get the filter that determines the current output pixel.
+      filterShift = filters[filterPtr++];
+      filterSize = filters[filterPtr++];
+      srcPtr = srcOffset + filterShift * 4 | 0;
+      r = g = b = a = 0; // Apply the filter to the row to get the destination pixel r, g, b, a
+
+      for (; filterSize > 0; filterSize--) {
+        filterVal = filters[filterPtr++]; // Use reverse order to workaround deopts in old v8 (node v.10)
+        // Big thanks to @mraleph (Vyacheslav Egorov) for the tip.
+
+        alpha = src[srcPtr + 3];
+        a = a + filterVal * alpha | 0;
+        b = b + filterVal * src[srcPtr + 2] * alpha | 0;
+        g = g + filterVal * src[srcPtr + 1] * alpha | 0;
+        r = r + filterVal * src[srcPtr] * alpha | 0;
+        srcPtr = srcPtr + 4 | 0;
+      } // Premultiply is (* alpha / 255).
+      // Postpone division for better performance
+
+
+      b = b / 255 | 0;
+      g = g / 255 | 0;
+      r = r / 255 | 0; // Store 15 bits between passes for better precision
+      // Instead of shift to 14 (FIXED_FRAC_BITS), shift to 7 only
       //
-      // (!) Add 1/2 of value before clamping to get proper rounding. In other
-      // case brightness loss will be noticeable if you resize image with white
-      // border and place it on white background.
+
+      dest[destOffset + 3] = clampNegative(a >> 7);
+      dest[destOffset + 2] = clampNegative(b >> 7);
+      dest[destOffset + 1] = clampNegative(g >> 7);
+      dest[destOffset] = clampNegative(r >> 7);
+      destOffset = destOffset + srcH * 4 | 0;
+    }
+
+    destOffset = (srcY + 1) * 4 | 0;
+    srcOffset = (srcY + 1) * srcW * 4 | 0;
+  }
+} // Supplementary method for `convolveHorWithPre()`
+//
+
+
+function convolveVertWithPre(src, dest, srcW, srcH, destW, filters) {
+  var r, g, b, a;
+  var filterPtr, filterShift, filterSize;
+  var srcPtr, srcY, destX, filterVal;
+  var srcOffset = 0,
+      destOffset = 0; // For each row
+
+  for (srcY = 0; srcY < srcH; srcY++) {
+    filterPtr = 0; // Apply precomputed filters to each destination row point
+
+    for (destX = 0; destX < destW; destX++) {
+      // Get the filter that determines the current output pixel.
+      filterShift = filters[filterPtr++];
+      filterSize = filters[filterPtr++];
+      srcPtr = srcOffset + filterShift * 4 | 0;
+      r = g = b = a = 0; // Apply the filter to the row to get the destination pixel r, g, b, a
+
+      for (; filterSize > 0; filterSize--) {
+        filterVal = filters[filterPtr++]; // Use reverse order to workaround deopts in old v8 (node v.10)
+        // Big thanks to @mraleph (Vyacheslav Egorov) for the tip.
+
+        a = a + filterVal * src[srcPtr + 3] | 0;
+        b = b + filterVal * src[srcPtr + 2] | 0;
+        g = g + filterVal * src[srcPtr + 1] | 0;
+        r = r + filterVal * src[srcPtr] | 0;
+        srcPtr = srcPtr + 4 | 0;
+      } // Downscale to leave room for un-premultiply
+
+
+      r >>= 7;
+      g >>= 7;
+      b >>= 7;
+      a >>= 7; // Un-premultiply
+
+      a = clampTo8(a + (1 << 13) >> 14);
+
+      if (a > 0) {
+        r = r * 255 / a | 0;
+        g = g * 255 / a | 0;
+        b = b * 255 / a | 0;
+      } // Bring this value back in range + round result.
+      // Shift value = FIXED_FRAC_BITS + 7
       //
 
 
-      dest[destOffset + 3] = clampTo8(a + (1 << 13) >> 14
-      /*FIXED_FRAC_BITS*/
-      );
-      dest[destOffset + 2] = clampTo8(b + (1 << 13) >> 14
-      /*FIXED_FRAC_BITS*/
-      );
-      dest[destOffset + 1] = clampTo8(g + (1 << 13) >> 14
-      /*FIXED_FRAC_BITS*/
-      );
-      dest[destOffset] = clampTo8(r + (1 << 13) >> 14
-      /*FIXED_FRAC_BITS*/
-      );
+      dest[destOffset + 3] = a;
+      dest[destOffset + 2] = clampTo8(b + (1 << 13) >> 14);
+      dest[destOffset + 1] = clampTo8(g + (1 << 13) >> 14);
+      dest[destOffset] = clampTo8(r + (1 << 13) >> 14);
       destOffset = destOffset + srcH * 4 | 0;
     }
 
@@ -184,8 +282,10 @@ function convolveVertically(src, dest, srcW, srcH, destW, filters) {
 }
 
 module.exports = {
-  convolveHorizontally: convolveHorizontally,
-  convolveVertically: convolveVertically
+  convolveHor: convolveHor,
+  convolveVert: convolveVert,
+  convolveHorWithPre: convolveHorWithPre,
+  convolveVertWithPre: convolveVertWithPre
 };
 
 },{}],3:[function(_dereq_,module,exports){
@@ -194,7 +294,7 @@ module.exports = {
 'use strict';
 /* eslint-disable max-len */
 
-module.exports = 'AGFzbQEAAAAADAZkeWxpbmsAAAAAAAEXA2AAAGAGf39/f39/AGAHf39/f39/fwACDwEDZW52Bm1lbW9yeQIAAAMEAwABAgYGAX8AQQALB1cFEV9fd2FzbV9jYWxsX2N0b3JzAAAIY29udm9sdmUAAQpjb252b2x2ZUhWAAIMX19kc29faGFuZGxlAwAYX193YXNtX2FwcGx5X2RhdGFfcmVsb2NzAAAK7AMDAwABC8YDAQ9/AkAgA0UNACAERQ0AA0AgDCENQQAhE0EAIQcDQCAHQQJqIQYCfyAHQQF0IAVqIgcuAQIiFEUEQEGAwAAhCEGAwAAhCUGAwAAhCkGAwAAhCyAGDAELIBIgBy4BAGohCEEAIQsgFCEHQQAhDiAGIQlBACEPQQAhEANAIAUgCUEBdGouAQAiESAAIAhBAnRqKAIAIgpBGHZsIBBqIRAgCkH/AXEgEWwgC2ohCyAKQRB2Qf8BcSARbCAPaiEPIApBCHZB/wFxIBFsIA5qIQ4gCEEBaiEIIAlBAWohCSAHQQFrIgcNAAsgC0GAQGshCCAOQYBAayEJIA9BgEBrIQogEEGAQGshCyAGIBRqCyEHIAEgDUECdGogCUEOdSIGQf8BIAZB/wFIGyIGQQAgBkEAShtBCHRBgP4DcSAKQQ51IgZB/wEgBkH/AUgbIgZBACAGQQBKG0EQdEGAgPwHcSALQQ51IgZB/wEgBkH/AUgbIgZBACAGQQBKG0EYdHJyIAhBDnUiBkH/ASAGQf8BSBsiBkEAIAZBAEobcjYCACADIA1qIQ0gE0EBaiITIARHDQALIAxBAWoiDCACbCESIAMgDEcNAAsLCx4AQQAgAiADIAQgBSAAEAEgAkEAIAQgBSAGIAEQAQs=';
+module.exports = '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';
 
 },{}],4:[function(_dereq_,module,exports){
 'use strict';
@@ -211,9 +311,23 @@ module.exports = {
 
 var createFilters = _dereq_('./resize_filter_gen');
 
-var convolveHorizontally = _dereq_('./convolve').convolveHorizontally;
+var _require = _dereq_('./convolve'),
+    convolveHor = _require.convolveHor,
+    convolveVert = _require.convolveVert,
+    convolveHorWithPre = _require.convolveHorWithPre,
+    convolveVertWithPre = _require.convolveVertWithPre;
 
-var convolveVertically = _dereq_('./convolve').convolveVertically;
+function hasAlpha(src, width, height) {
+  var ptr = 3,
+      len = width * height * 4 | 0;
+
+  while (ptr < len) {
+    if (src[ptr] !== 255) return true;
+    ptr = ptr + 4 | 0;
+  }
+
+  return false;
+}
 
 function resetAlpha(dst, width, height) {
   var ptr = 3,
@@ -236,20 +350,20 @@ module.exports = function resize(options) {
   var offsetX = options.offsetX || 0;
   var offsetY = options.offsetY || 0;
   var dest = options.dest || new Uint8Array(destW * destH * 4);
-  var quality = typeof options.quality === 'undefined' ? 3 : options.quality;
-  var alpha = options.alpha || false;
-  var filtersX = createFilters(quality, srcW, destW, scaleX, offsetX),
-      filtersY = createFilters(quality, srcH, destH, scaleY, offsetY);
-  var tmp = new Uint8Array(destW * srcH * 4); // To use single function we need src & tmp of the same type.
-  // But src can be CanvasPixelArray, and tmp - Uint8Array. So, keep
-  // vertical and horizontal passes separately to avoid deoptimization.
-
-  convolveHorizontally(src, tmp, srcW, srcH, destW, filtersX);
-  convolveVertically(tmp, dest, srcH, destW, destH, filtersY); // That's faster than doing checks in convolver.
-  // !!! Note, canvas data is not premultipled. We don't need other
-  // alpha corrections.
-
-  if (!alpha) resetAlpha(dest, destW, destH);
+  var filter = typeof options.filter === 'undefined' ? 'mks2013' : options.filter;
+  var filtersX = createFilters(filter, srcW, destW, scaleX, offsetX),
+      filtersY = createFilters(filter, srcH, destH, scaleY, offsetY);
+  var tmp = new Uint16Array(destW * srcH * 4); // Autodetect if alpha channel exists, and use appropriate method
+
+  if (hasAlpha(src, srcW, srcH)) {
+    convolveHorWithPre(src, tmp, srcW, srcH, destW, filtersX);
+    convolveVertWithPre(tmp, dest, srcH, destW, destH, filtersY);
+  } else {
+    convolveHor(src, tmp, srcW, srcH, destW, filtersX);
+    convolveVert(tmp, dest, srcH, destW, destH, filtersY);
+    resetAlpha(dest, destW, destH);
+  }
+
   return dest;
 };
 
@@ -274,13 +388,13 @@ function toFixedPoint(num) {
   return Math.round(num * ((1 << FIXED_FRAC_BITS) - 1));
 }
 
-module.exports = function resizeFilterGen(quality, srcSize, destSize, scale, offset) {
-  var filterFunction = FILTER_INFO[quality].filter;
+module.exports = function resizeFilterGen(filter, srcSize, destSize, scale, offset) {
+  var filterFunction = FILTER_INFO.filter[filter].fn;
   var scaleInverted = 1.0 / scale;
   var scaleClamped = Math.min(1.0, scale); // For upscale
   // Filter window (averaging interval), scaled to src image
 
-  var srcWindow = FILTER_INFO[quality].win / scaleClamped;
+  var srcWindow = FILTER_INFO.filter[filter].win / scaleClamped;
   var destPixel, srcPixel, srcFirst, srcLast, filterElementSize, floatFilter, fxpFilter, total, pxl, idx, floatVal, filterTotal, filterVal;
   var leftNotEmpty, rightNotEmpty, filterShift, filterSize;
   var maxFilterElementSize = Math.floor((srcWindow + 1) * 2);
@@ -370,64 +484,121 @@ module.exports = function resizeFilterGen(quality, srcSize, destSize, scale, off
 //
 'use strict';
 
-module.exports = [{
-  // Nearest neibor (Box)
-  win: 0.5,
-  filter: function filter(x) {
-    return x >= -0.5 && x < 0.5 ? 1.0 : 0.0;
-  }
-}, {
-  // Hamming
-  win: 1.0,
-  filter: function filter(x) {
-    if (x <= -1.0 || x >= 1.0) {
-      return 0.0;
+var filter = {
+  // Nearest neibor
+  box: {
+    win: 0.5,
+    fn: function fn(x) {
+      if (x < 0) x = -x;
+      return x < 0.5 ? 1.0 : 0.0;
     }
+  },
+  // // Hamming
+  hamming: {
+    win: 1.0,
+    fn: function fn(x) {
+      if (x < 0) x = -x;
+
+      if (x >= 1.0) {
+        return 0.0;
+      }
 
-    if (x > -1.19209290E-07 && x < 1.19209290E-07) {
-      return 1.0;
-    }
+      if (x < 1.19209290E-07) {
+        return 1.0;
+      }
 
-    var xpi = x * Math.PI;
-    return Math.sin(xpi) / xpi * (0.54 + 0.46 * Math.cos(xpi / 1.0));
-  }
-}, {
-  // Lanczos, win = 2
-  win: 2.0,
-  filter: function filter(x) {
-    if (x <= -2.0 || x >= 2.0) {
-      return 0.0;
+      var xpi = x * Math.PI;
+      return Math.sin(xpi) / xpi * (0.54 + 0.46 * Math.cos(xpi / 1.0));
     }
+  },
+  // Lanczos, win = 2
+  lanczos2: {
+    win: 2.0,
+    fn: function fn(x) {
+      if (x < 0) x = -x;
 
-    if (x > -1.19209290E-07 && x < 1.19209290E-07) {
-      return 1.0;
-    }
+      if (x >= 2.0) {
+        return 0.0;
+      }
 
-    var xpi = x * Math.PI;
-    return Math.sin(xpi) / xpi * Math.sin(xpi / 2.0) / (xpi / 2.0);
-  }
-}, {
-  // Lanczos, win = 3
-  win: 3.0,
-  filter: function filter(x) {
-    if (x <= -3.0 || x >= 3.0) {
-      return 0.0;
+      if (x < 1.19209290E-07) {
+        return 1.0;
+      }
+
+      var xpi = x * Math.PI;
+      return Math.sin(xpi) / xpi * Math.sin(xpi / 2.0) / (xpi / 2.0);
     }
+  },
+  // Lanczos, win = 3
+  lanczos3: {
+    win: 3.0,
+    fn: function fn(x) {
+      if (x < 0) x = -x;
+
+      if (x >= 3.0) {
+        return 0.0;
+      }
+
+      if (x < 1.19209290E-07) {
+        return 1.0;
+      }
 
-    if (x > -1.19209290E-07 && x < 1.19209290E-07) {
-      return 1.0;
+      var xpi = x * Math.PI;
+      return Math.sin(xpi) / xpi * Math.sin(xpi / 3.0) / (xpi / 3.0);
     }
+  },
+  // Magic Kernel Sharp 2013, win = 2.5
+  // http://johncostella.com/magic/
+  mks2013: {
+    win: 2.5,
+    fn: function fn(x) {
+      if (x < 0) x = -x;
+
+      if (x >= 2.5) {
+        return 0.0;
+      }
+
+      if (x >= 1.5) {
+        return -0.125 * (x - 2.5) * (x - 2.5);
+      }
 
-    var xpi = x * Math.PI;
-    return Math.sin(xpi) / xpi * Math.sin(xpi / 3.0) / (xpi / 3.0);
+      if (x >= 0.5) {
+        return 0.25 * (4 * x * x - 11 * x + 7);
+      }
+
+      return 1.0625 - 1.75 * x * x;
+    }
   }
-}];
+};
+module.exports = {
+  filter: filter,
+  // Legacy mapping
+  f2q: {
+    box: 0,
+    hamming: 1,
+    lanczos2: 2,
+    lanczos3: 3
+  },
+  q2f: ['box', 'hamming', 'lanczos2', 'lanczos3']
+};
 
 },{}],8:[function(_dereq_,module,exports){
 'use strict';
 
 var createFilters = _dereq_('./resize_filter_gen');
 
+function hasAlpha(src, width, height) {
+  var ptr = 3,
+      len = width * height * 4 | 0;
+
+  while (ptr < len) {
+    if (src[ptr] !== 255) return true;
+    ptr = ptr + 4 | 0;
+  }
+
+  return false;
+}
+
 function resetAlpha(dst, width, height) {
   var ptr = 3,
       len = width * height * 4 | 0;
@@ -472,16 +643,18 @@ module.exports = function resize_wasm(options) {
   var offsetX = options.offsetX || 0.0;
   var offsetY = options.offsetY || 0.0;
   var dest = options.dest || new Uint8Array(destW * destH * 4);
-  var quality = typeof options.quality === 'undefined' ? 3 : options.quality;
-  var alpha = options.alpha || false;
-  var filtersX = createFilters(quality, srcW, destW, scaleX, offsetX),
-      filtersY = createFilters(quality, srcH, destH, scaleY, offsetY); // destination is 0 too.
+  var filter = typeof options.filter === 'undefined' ? 'mks2013' : options.filter;
+  var filtersX = createFilters(filter, srcW, destW, scaleX, offsetX),
+      filtersY = createFilters(filter, srcH, destH, scaleY, offsetY); // destination is 0 too.
+
+  var src_offset = 0;
+  var src_size = Math.max(src.byteLength, dest.byteLength); // buffer between convolve passes
 
-  var src_offset = 0; // buffer between convolve passes
+  var tmp_offset = this.__align(src_offset + src_size);
 
-  var tmp_offset = this.__align(src_offset + Math.max(src.byteLength, dest.byteLength));
+  var tmp_size = srcH * destW * 4 * 2; // 2 bytes per channel
 
-  var filtersX_offset = this.__align(tmp_offset + srcH * destW * 4);
+  var filtersX_offset = this.__align(tmp_offset + tmp_size);
 
   var filtersY_offset = this.__align(filtersX_offset + filtersX.byteLength);
 
@@ -500,22 +673,24 @@ module.exports = function resize_wasm(options) {
   // speed difference is not significant vs direct .set()
 
   copyInt16asLE(filtersX, mem, filtersX_offset);
-  copyInt16asLE(filtersY, mem, filtersY_offset); //
-  // Now call webassembly method
+  copyInt16asLE(filtersY, mem, filtersY_offset); // Now call webassembly method
   // emsdk does method names with '_'
 
   var fn = instance.exports.convolveHV || instance.exports._convolveHV;
-  fn(filtersX_offset, filtersY_offset, tmp_offset, srcW, srcH, destW, destH); //
+
+  if (hasAlpha(src, srcW, srcH)) {
+    fn(filtersX_offset, filtersY_offset, tmp_offset, srcW, srcH, destW, destH, 1);
+  } else {
+    fn(filtersX_offset, filtersY_offset, tmp_offset, srcW, srcH, destW, destH, 0);
+    resetAlpha(dest, destW, destH);
+  } //
   // Copy data back to typed array
   //
   // 32-bit copy is much faster in chrome
 
-  var dest32 = new Uint32Array(dest.buffer);
-  dest32.set(new Uint32Array(this.__memory.buffer, 0, destH * destW)); // That's faster than doing checks in convolver.
-  // !!! Note, canvas data is not premultipled. We don't need other
-  // alpha corrections.
 
-  if (!alpha) resetAlpha(dest, destW, destH);
+  var dest32 = new Uint32Array(dest.buffer);
+  dest32.set(new Uint32Array(this.__memory.buffer, 0, destH * destW));
   return dest;
 };
 
@@ -986,7 +1161,18 @@ module.exports.cib_support = function cib_support(createCanvas) {
 
 module.exports.worker_offscreen_canvas_support = function worker_offscreen_canvas_support() {
   return new Promise(function (resolve, reject) {
+    if (typeof OffscreenCanvas === 'undefined') {
+      // if OffscreenCanvas is present, we assume browser supports Worker and built-in Promise as well
+      resolve(false);
+      return;
+    }
+
     function workerPayload(self) {
+      if (typeof createImageBitmap === 'undefined') {
+        self.postMessage(false);
+        return;
+      }
+
       Promise.resolve().then(function () {
         var canvas = new OffscreenCanvas(10, 10); // test that 2d context can be used in worker
 
@@ -1005,10 +1191,75 @@ module.exports.worker_offscreen_canvas_support = function worker_offscreen_canva
     var w = new Worker("data:text/javascript;base64,".concat(code));
 
     w.onmessage = function (ev) {
-      return ev.data ? resolve() : reject();
+      return resolve(ev.data);
     };
 
     w.onerror = reject;
+  }).then(function (result) {
+    return result;
+  }, function () {
+    return false;
+  });
+}; // Check if canvas.getContext('2d').getImageData can be used,
+// FireFox randomizes the output of that function in `privacy.resistFingerprinting` mode
+
+
+module.exports.can_use_canvas = function can_use_canvas(createCanvas) {
+  var usable = false;
+
+  try {
+    var canvas = createCanvas(2, 1);
+    var ctx = canvas.getContext('2d');
+    var d = ctx.createImageData(2, 1);
+    d.data[0] = 12;
+    d.data[1] = 23;
+    d.data[2] = 34;
+    d.data[3] = 255;
+    d.data[4] = 45;
+    d.data[5] = 56;
+    d.data[6] = 67;
+    d.data[7] = 255;
+    ctx.putImageData(d, 0, 0);
+    d = null;
+    d = ctx.getImageData(0, 0, 2, 1);
+
+    if (d.data[0] === 12 && d.data[1] === 23 && d.data[2] === 34 && d.data[3] === 255 && d.data[4] === 45 && d.data[5] === 56 && d.data[6] === 67 && d.data[7] === 255) {
+      usable = true;
+    }
+  } catch (err) {}
+
+  return usable;
+}; // Check if createImageBitmap(img, sx, sy, sw, sh) signature works correctly
+// with JPEG images oriented with Exif;
+// https://bugs.chromium.org/p/chromium/issues/detail?id=1220671
+// TODO: remove after it's fixed in chrome for at least 2 releases
+
+
+module.exports.cib_can_use_region = function cib_can_use_region() {
+  return new Promise(function (resolve) {
+    if (typeof createImageBitmap === 'undefined') {
+      resolve(false);
+      return;
+    }
+
+    var image = new Image();
+    image.src = 'data:image/jpeg;base64,' + '/9j/4QBiRXhpZgAATU0AKgAAAAgABQESAAMAAAABAAYAAAEaAAUAAAABAAAASgEbAAUAA' + 'AABAAAAUgEoAAMAAAABAAIAAAITAAMAAAABAAEAAAAAAAAAAABIAAAAAQAAAEgAAAAB/9' + 'sAQwAEAwMEAwMEBAMEBQQEBQYKBwYGBgYNCQoICg8NEBAPDQ8OERMYFBESFxIODxUcFRc' + 'ZGRsbGxAUHR8dGh8YGhsa/9sAQwEEBQUGBQYMBwcMGhEPERoaGhoaGhoaGhoaGhoaGhoa' + 'GhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoaGhoa/8IAEQgAAQACAwERAAIRAQMRA' + 'f/EABQAAQAAAAAAAAAAAAAAAAAAAAf/xAAUAQEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAA' + 'IQAxAAAAF/P//EABQQAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQEAAQUCf//EABQRAQAAAAA' + 'AAAAAAAAAAAAAAAD/2gAIAQMBAT8Bf//EABQRAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQIB' + 'AT8Bf//EABQQAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQEABj8Cf//EABQQAQAAAAAAAAAAA' + 'AAAAAAAAAD/2gAIAQEAAT8hf//aAAwDAQACAAMAAAAQH//EABQRAQAAAAAAAAAAAAAAAA' + 'AAAAD/2gAIAQMBAT8Qf//EABQRAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQIBAT8Qf//EABQ' + 'QAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQEAAT8Qf//Z';
+
+    image.onload = function () {
+      createImageBitmap(image, 0, 0, image.width, image.height).then(function (bitmap) {
+        if (bitmap.width === image.width && bitmap.height === image.height) {
+          resolve(true);
+        } else {
+          resolve(false);
+        }
+      }, function () {
+        return resolve(false);
+      });
+    };
+
+    image.onerror = function () {
+      return resolve(false);
+    };
   });
 };
 
@@ -1028,16 +1279,15 @@ module.exports = function () {
 
     if (!tileOpts.src && tileOpts.srcBitmap) {
       var canvas = new OffscreenCanvas(tileOpts.width, tileOpts.height);
-      var ctx = canvas.getContext('2d', {
-        alpha: Boolean(tileOpts.alpha)
-      });
+      var ctx = canvas.getContext('2d');
       ctx.drawImage(tileOpts.srcBitmap, 0, 0);
       tileOpts.src = ctx.getImageData(0, 0, tileOpts.width, tileOpts.height).data;
       canvas.width = canvas.height = 0;
       canvas = null;
       tileOpts.srcBitmap.close();
-      tileOpts.srcBitmap = null;
-      returnBitmap = true;
+      tileOpts.srcBitmap = null; // Temporary force out data to typed array, because Chrome have artefacts
+      // https://github.com/nodeca/pica/issues/223
+      // returnBitmap = true;
     }
 
     if (!mathLib) mathLib = new MathLib(ev.data.features); // Use multimath's sync auto-init. Avoid Promise use in old browsers,
@@ -1050,9 +1300,7 @@ module.exports = function () {
 
       var _canvas = new OffscreenCanvas(tileOpts.toWidth, tileOpts.toHeight);
 
-      var _ctx = _canvas.getContext('2d', {
-        alpha: Boolean(tileOpts.alpha)
-      });
+      var _ctx = _canvas.getContext('2d');
 
       _ctx.putImageData(toImageData, 0, 0);
 
@@ -1191,35 +1439,6 @@ function blurMono16(src, width, height, radius) {
 module.exports = blurMono16;
 
 },{}],19:[function(_dereq_,module,exports){
-if (typeof Object.create === 'function') {
-  // implementation from standard node.js 'util' module
-  module.exports = function inherits(ctor, superCtor) {
-    if (superCtor) {
-      ctor.super_ = superCtor
-      ctor.prototype = Object.create(superCtor.prototype, {
-        constructor: {
-          value: ctor,
-          enumerable: false,
-          writable: true,
-          configurable: true
-        }
-      })
-    }
-  };
-} else {
-  // old school shim for old browsers
-  module.exports = function inherits(ctor, superCtor) {
-    if (superCtor) {
-      ctor.super_ = superCtor
-      var TempCtor = function () {}
-      TempCtor.prototype = superCtor.prototype
-      ctor.prototype = new TempCtor()
-      ctor.prototype.constructor = ctor
-    }
-  }
-}
-
-},{}],20:[function(_dereq_,module,exports){
 'use strict';
 
 
@@ -1378,7 +1597,7 @@ MultiMath.prototype.__align = function align(number, base) {
 
 module.exports = MultiMath;
 
-},{"./lib/base64decode":21,"./lib/wa_detect":22,"object-assign":23}],21:[function(_dereq_,module,exports){
+},{"./lib/base64decode":20,"./lib/wa_detect":21,"object-assign":22}],20:[function(_dereq_,module,exports){
 // base64 decode str -> Uint8Array, to load WA modules
 //
 'use strict';
@@ -1426,7 +1645,7 @@ module.exports = function base64decode(str) {
   return out;
 };
 
-},{}],22:[function(_dereq_,module,exports){
+},{}],21:[function(_dereq_,module,exports){
 // Detect WebAssembly support.
 // - Check global WebAssembly object
 // - Try to load simple module (can be disabled via CSP)
@@ -1465,7 +1684,7 @@ module.exports = function hasWebAssembly() {
   return wa;
 };
 
-},{}],23:[function(_dereq_,module,exports){
+},{}],22:[function(_dereq_,module,exports){
 /*
 object-assign
 (c) Sindre Sorhus
@@ -1557,7 +1776,7 @@ module.exports = shouldUseNative() ? Object.assign : function (target, source) {
 	return to;
 };
 
-},{}],24:[function(_dereq_,module,exports){
+},{}],23:[function(_dereq_,module,exports){
 var bundleFn = arguments[3];
 var sources = arguments[4];
 var cache = arguments[5];
@@ -1650,7 +1869,7 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
 
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-function _iterableToArrayLimit(arr, i) { var _i = arr && (typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]); if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
 
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
@@ -1668,7 +1887,9 @@ var worker = _dereq_('./lib/worker');
 
 var createStages = _dereq_('./lib/stepper');
 
-var createRegions = _dereq_('./lib/tiler'); // Deduplicate pools & limiters with the same configs
+var createRegions = _dereq_('./lib/tiler');
+
+var filter_info = _dereq_('./lib/mm_resize/resize_filter_info'); // Deduplicate pools & limiters with the same configs
 // when user creates multiple pica instances.
 
 
@@ -1700,15 +1921,16 @@ var DEFAULT_PICA_OPTS = {
   }
 };
 var DEFAULT_RESIZE_OPTS = {
-  quality: 3,
-  alpha: false,
+  filter: 'mks2013',
   unsharpAmount: 0,
   unsharpRadius: 0.0,
   unsharpThreshold: 0
 };
-var CAN_NEW_IMAGE_DATA;
-var CAN_CREATE_IMAGE_BITMAP;
-var CAN_USE_OFFSCREEN_CANVAS;
+var CAN_NEW_IMAGE_DATA = false;
+var CAN_CREATE_IMAGE_BITMAP = false;
+var CAN_USE_CANVAS_GET_IMAGE_DATA = false;
+var CAN_USE_OFFSCREEN_CANVAS = false;
+var CAN_USE_CIB_REGION_FOR_IMAGE = false;
 
 function workerFabric() {
   return {
@@ -1759,16 +1981,12 @@ Pica.prototype.init = function () {
 
   if (this.__initPromise) return this.__initPromise; // Test if we can create ImageData without canvas and memory copy
 
-  if (CAN_NEW_IMAGE_DATA !== false && CAN_NEW_IMAGE_DATA !== true) {
-    CAN_NEW_IMAGE_DATA = false;
-
-    if (typeof ImageData !== 'undefined' && typeof Uint8ClampedArray !== 'undefined') {
-      try {
-        /* eslint-disable no-new */
-        new ImageData(new Uint8ClampedArray(400), 10, 10);
-        CAN_NEW_IMAGE_DATA = true;
-      } catch (__) {}
-    }
+  if (typeof ImageData !== 'undefined' && typeof Uint8ClampedArray !== 'undefined') {
+    try {
+      /* eslint-disable no-new */
+      new ImageData(new Uint8ClampedArray(400), 10, 10);
+      CAN_NEW_IMAGE_DATA = true;
+    } catch (__) {}
   } // ImageBitmap can be effective in 2 places:
   //
   // 1. Threaded jpeg unpack (basic)
@@ -1778,15 +1996,11 @@ Pica.prototype.init = function () {
   // see https://developer.mozilla.org/ru/docs/Web/API/ImageBitmap
 
 
-  if (CAN_CREATE_IMAGE_BITMAP !== false && CAN_CREATE_IMAGE_BITMAP !== true) {
-    CAN_CREATE_IMAGE_BITMAP = false;
-
-    if (typeof ImageBitmap !== 'undefined') {
-      if (ImageBitmap.prototype && ImageBitmap.prototype.close) {
-        CAN_CREATE_IMAGE_BITMAP = true;
-      } else {
-        this.debug('ImageBitmap does not support .close(), disabled');
-      }
+  if (typeof ImageBitmap !== 'undefined') {
+    if (ImageBitmap.prototype && ImageBitmap.prototype.close) {
+      CAN_CREATE_IMAGE_BITMAP = true;
+    } else {
+      this.debug('ImageBitmap does not support .close(), disabled');
     }
   }
 
@@ -1842,21 +2056,26 @@ Pica.prototype.init = function () {
     });
   }
 
+  CAN_USE_CANVAS_GET_IMAGE_DATA = utils.can_use_canvas(this.options.createCanvas);
   var checkOffscreenCanvas;
 
   if (CAN_CREATE_IMAGE_BITMAP && CAN_NEW_IMAGE_DATA && features.indexOf('ww') !== -1) {
     checkOffscreenCanvas = utils.worker_offscreen_canvas_support();
   } else {
-    checkOffscreenCanvas = Promise.reject();
+    checkOffscreenCanvas = Promise.resolve(false);
   }
 
-  checkOffscreenCanvas = checkOffscreenCanvas.then(function () {
-    CAN_USE_OFFSCREEN_CANVAS = true;
-  }, function () {
-    CAN_USE_OFFSCREEN_CANVAS = false;
+  checkOffscreenCanvas = checkOffscreenCanvas.then(function (result) {
+    CAN_USE_OFFSCREEN_CANVAS = result;
+  }); // we use createImageBitmap to crop image data and pass it to workers,
+  // so need to check whether function works correctly;
+  // https://bugs.chromium.org/p/chromium/issues/detail?id=1220671
+
+  var checkCibRegion = utils.cib_can_use_region().then(function (result) {
+    CAN_USE_CIB_REGION_FOR_IMAGE = result;
   }); // Init math lib. That's async because can load some
 
-  this.__initPromise = Promise.all([initMath, checkCibResize, checkOffscreenCanvas]).then(function () {
+  this.__initPromise = Promise.all([initMath, checkCibResize, checkOffscreenCanvas, checkCibRegion]).then(function () {
     return _this;
   });
   return this.__initPromise;
@@ -1908,7 +2127,10 @@ Pica.prototype.__invokeResize = function (tileOpts, opts) {
 
 
 Pica.prototype.__extractTileData = function (tile, from, opts, stageEnv, extractTo) {
-  if (this.features.ww && CAN_USE_OFFSCREEN_CANVAS) {
+  if (this.features.ww && CAN_USE_OFFSCREEN_CANVAS && ( // createImageBitmap doesn't work for images (Image, ImageBitmap) with Exif orientation in Chrome,
+  // can use canvas because canvas doesn't have orientation;
+  // see https://bugs.chromium.org/p/chromium/issues/detail?id=1220671
+  utils.isCanvas(from) || CAN_USE_CIB_REGION_FOR_IMAGE)) {
     this.debug('Create tile for OffscreenCanvas');
     return createImageBitmap(stageEnv.srcImageBitmap || from, tile.x, tile.y, tile.width, tile.height).then(function (bitmap) {
       extractTo.srcBitmap = bitmap;
@@ -1918,9 +2140,7 @@ Pica.prototype.__extractTileData = function (tile, from, opts, stageEnv, extract
 
 
   if (utils.isCanvas(from)) {
-    if (!stageEnv.srcCtx) stageEnv.srcCtx = from.getContext('2d', {
-      alpha: Boolean(opts.alpha)
-    }); // If input is Canvas - extract region data directly
+    if (!stageEnv.srcCtx) stageEnv.srcCtx = from.getContext('2d'); // If input is Canvas - extract region data directly
 
     this.debug('Get tile pixel data');
     extractTo.src = stageEnv.srcCtx.getImageData(tile.x, tile.y, tile.width, tile.height).data;
@@ -1934,9 +2154,7 @@ Pica.prototype.__extractTileData = function (tile, from, opts, stageEnv, extract
 
   this.debug('Draw tile imageBitmap/image to temporary canvas');
   var tmpCanvas = this.options.createCanvas(tile.width, tile.height);
-  var tmpCtx = tmpCanvas.getContext('2d', {
-    alpha: Boolean(opts.alpha)
-  });
+  var tmpCtx = tmpCanvas.getContext('2d');
   tmpCtx.globalCompositeOperation = 'copy';
   tmpCtx.drawImage(stageEnv.srcImageBitmap || from, tile.x, tile.y, tile.width, tile.height, 0, 0, tile.width, tile.height);
   this.debug('Get tile pixel data');
@@ -2009,8 +2227,7 @@ Pica.prototype.__tileAndResize = function (from, to, opts) {
         scaleY: tile.scaleY,
         offsetX: tile.offsetX,
         offsetY: tile.offsetY,
-        quality: opts.quality,
-        alpha: opts.alpha,
+        filter: opts.filter,
         unsharpAmount: opts.unsharpAmount,
         unsharpRadius: opts.unsharpRadius,
         unsharpThreshold: opts.unsharpThreshold
@@ -2035,9 +2252,7 @@ Pica.prototype.__tileAndResize = function (from, to, opts) {
 
 
   return Promise.resolve().then(function () {
-    stageEnv.toCtx = to.getContext('2d', {
-      alpha: Boolean(opts.alpha)
-    });
+    stageEnv.toCtx = to.getContext('2d');
     if (utils.isCanvas(from)) return null;
 
     if (utils.isImageBitmap(from)) {
@@ -2117,14 +2332,20 @@ Pica.prototype.__processStages = function (stages, from, to, opts) {
       toWidth = _stages$shift2[0],
       toHeight = _stages$shift2[1];
 
-  var isLastStage = stages.length === 0;
+  var isLastStage = stages.length === 0; // Optimization for legacy filters -
+  // only use user-defined quality for the last stage,
+  // use simpler (Hamming) filter for the first stages where
+  // scale factor is large enough (more than 2-3)
+  //
+  // For advanced filters (mks2013 and custom) - skip optimization,
+  // because need to apply sharpening every time
+
+  var filter;
+  if (isLastStage || filter_info.q2f.indexOf(opts.filter) < 0) filter = opts.filter;else if (opts.filter === 'box') filter = 'box';else filter = 'hamming';
   opts = assign({}, opts, {
     toWidth: toWidth,
     toHeight: toHeight,
-    // only use user-defined quality for the last stage,
-    // use simpler (Hamming) filter for the first stages where
-    // scale factor is large enough (more than 2-3)
-    quality: isLastStage ? opts.quality : Math.min(1, opts.quality)
+    filter: filter
   });
   var tmpCanvas;
 
@@ -2152,14 +2373,12 @@ Pica.prototype.__processStages = function (stages, from, to, opts) {
 Pica.prototype.__resizeViaCreateImageBitmap = function (from, to, opts) {
   var _this5 = this;
 
-  var toCtx = to.getContext('2d', {
-    alpha: Boolean(opts.alpha)
-  });
+  var toCtx = to.getContext('2d');
   this.debug('Resize via createImageBitmap()');
   return createImageBitmap(from, {
     resizeWidth: opts.toWidth,
     resizeHeight: opts.toHeight,
-    resizeQuality: utils.cib_quality_name(opts.quality)
+    resizeQuality: utils.cib_quality_name(filter_info.f2q[opts.filter])
   }).then(function (imageBitmap) {
     if (opts.canceled) return opts.cancelToken; // if no unsharp - draw directly to output canvas
 
@@ -2177,9 +2396,7 @@ Pica.prototype.__resizeViaCreateImageBitmap = function (from, to, opts) {
 
     var tmpCanvas = _this5.options.createCanvas(opts.toWidth, opts.toHeight);
 
-    var tmpCtx = tmpCanvas.getContext('2d', {
-      alpha: Boolean(opts.alpha)
-    });
+    var tmpCtx = tmpCanvas.getContext('2d');
     tmpCtx.drawImage(imageBitmap, 0, 0);
     imageBitmap.close();
     var iData = tmpCtx.getImageData(0, 0, opts.toWidth, opts.toHeight);
@@ -2215,7 +2432,16 @@ Pica.prototype.resize = function (from, to, options) {
   opts.toWidth = to.width;
   opts.toHeight = to.height;
   opts.width = from.naturalWidth || from.width;
-  opts.height = from.naturalHeight || from.height; // Prevent stepper from infinite loop
+  opts.height = from.naturalHeight || from.height; // Legacy `.quality` option
+
+  if (Object.prototype.hasOwnProperty.call(opts, 'quality')) {
+    if (opts.quality < 0 || opts.quality > 3) {
+      throw new Error("Pica: .quality should be [0..3], got ".concat(opts.quality));
+    }
+
+    opts.filter = filter_info.q2f[opts.quality];
+  } // Prevent stepper from infinite loop
+
 
   if (to.width === 0 || to.height === 0) {
     return Promise.reject(new Error("Invalid output size: ".concat(to.width, "x").concat(to.height)));
@@ -2242,7 +2468,17 @@ Pica.prototype.resize = function (from, to, options) {
     if (opts.canceled) return opts.cancelToken; // if createImageBitmap supports resize, just do it and return
 
     if (_this6.features.cib) {
-      return _this6.__resizeViaCreateImageBitmap(from, to, opts);
+      if (filter_info.q2f.indexOf(opts.filter) >= 0) {
+        return _this6.__resizeViaCreateImageBitmap(from, to, opts);
+      }
+
+      _this6.debug('cib is enabled, but not supports provided filter, fallback to manual math');
+    }
+
+    if (!CAN_USE_CANVAS_GET_IMAGE_DATA) {
+      var err = new Error('Pica: cannot use getImageData on canvas, ' + "make sure fingerprinting protection isn't enabled");
+      err.code = 'ERR_GET_IMAGE_DATA';
+      throw err;
     } //
     // No easy way, let's resize manually via arrays
     //
@@ -2258,7 +2494,16 @@ Pica.prototype.resize = function (from, to, options) {
 Pica.prototype.resizeBuffer = function (options) {
   var _this7 = this;
 
-  var opts = assign({}, DEFAULT_RESIZE_OPTS, options);
+  var opts = assign({}, DEFAULT_RESIZE_OPTS, options); // Legacy `.quality` option
+
+  if (Object.prototype.hasOwnProperty.call(opts, 'quality')) {
+    if (opts.quality < 0 || opts.quality > 3) {
+      throw new Error("Pica: .quality should be [0..3], got ".concat(opts.quality));
+    }
+
+    opts.filter = filter_info.q2f[opts.quality];
+  }
+
   return this.init().then(function () {
     return _this7.__mathlib.resizeAndUnsharp(opts);
   });
@@ -2301,5 +2546,5 @@ Pica.prototype.debug = function () {};
 
 module.exports = Pica;
 
-},{"./lib/mathlib":1,"./lib/pool":13,"./lib/stepper":14,"./lib/tiler":15,"./lib/utils":16,"./lib/worker":17,"object-assign":23,"webworkify":24}]},{},[])("/index.js")
+},{"./lib/mathlib":1,"./lib/mm_resize/resize_filter_info":7,"./lib/pool":13,"./lib/stepper":14,"./lib/tiler":15,"./lib/utils":16,"./lib/worker":17,"object-assign":22,"webworkify":23}]},{},[])("/index.js")
 });