@jimp/plugin-resize - npm Package Compare versions

Comparing version 0.20.2 to 0.21.0--canary.1149.3239903.0

dist/index.js

 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports["default"] = void 0;
-
+exports.default = void 0;
 var _utils = require("@jimp/utils");
-
 var _resize = _interopRequireDefault(require("./modules/resize"));
-
 var _resize2 = _interopRequireDefault(require("./modules/resize2"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _default = () => ({
+  constants: {
+    RESIZE_NEAREST_NEIGHBOR: "nearestNeighbor",
+    RESIZE_BILINEAR: "bilinearInterpolation",
+    RESIZE_BICUBIC: "bicubicInterpolation",
+    RESIZE_HERMITE: "hermiteInterpolation",
+    RESIZE_BEZIER: "bezierInterpolation"
+  },
+  class: {
+    /**
+     * Resizes the image to a set width and height using a 2-pass bilinear algorithm
+     * @param {number} w the width to resize the image to (or Jimp.AUTO)
+     * @param {number} h the height to resize the image to (or Jimp.AUTO)
+     * @param {string} mode (optional) a scaling method (e.g. Jimp.RESIZE_BEZIER)
+     * @param {function(Error, Jimp)} cb (optional) a callback for when complete
+     * @returns {Jimp} this for chaining of methods
+     */
+    resize(w, h, mode, cb) {
+      if (typeof w !== "number" || typeof h !== "number") {
+        return _utils.throwError.call(this, "w and h must be numbers", cb);
+      }
+      if (typeof mode === "function" && typeof cb === "undefined") {
+        cb = mode;
+        mode = null;
+      }
+      if (w === this.constructor.AUTO && h === this.constructor.AUTO) {
+        return _utils.throwError.call(this, "w and h cannot both be set to auto", cb);
+      }
+      if (w === this.constructor.AUTO) {
+        w = this.bitmap.width * (h / this.bitmap.height);
+      }
+      if (h === this.constructor.AUTO) {
+        h = this.bitmap.height * (w / this.bitmap.width);
+      }
+      if (w < 0 || h < 0) {
+        return _utils.throwError.call(this, "w and h must be positive numbers", cb);
+      }
 
-var _default = function _default() {
-  return {
-    constants: {
-      RESIZE_NEAREST_NEIGHBOR: "nearestNeighbor",
-      RESIZE_BILINEAR: "bilinearInterpolation",
-      RESIZE_BICUBIC: "bicubicInterpolation",
-      RESIZE_HERMITE: "hermiteInterpolation",
-      RESIZE_BEZIER: "bezierInterpolation"
-    },
-    "class": {
-      /**
-       * Resizes the image to a set width and height using a 2-pass bilinear algorithm
-       * @param {number} w the width to resize the image to (or Jimp.AUTO)
-       * @param {number} h the height to resize the image to (or Jimp.AUTO)
-       * @param {string} mode (optional) a scaling method (e.g. Jimp.RESIZE_BEZIER)
-       * @param {function(Error, Jimp)} cb (optional) a callback for when complete
-       * @returns {Jimp} this for chaining of methods
-       */
-      resize: function resize(w, h, mode, cb) {
-        if (typeof w !== "number" || typeof h !== "number") {
-          return _utils.throwError.call(this, "w and h must be numbers", cb);
-        }
-
-        if (typeof mode === "function" && typeof cb === "undefined") {
-          cb = mode;
-          mode = null;
-        }
-
-        if (w === this.constructor.AUTO && h === this.constructor.AUTO) {
-          return _utils.throwError.call(this, "w and h cannot both be set to auto", cb);
-        }
-
-        if (w === this.constructor.AUTO) {
-          w = this.bitmap.width * (h / this.bitmap.height);
-        }
-
-        if (h === this.constructor.AUTO) {
-          h = this.bitmap.height * (w / this.bitmap.width);
-        }
-
-        if (w < 0 || h < 0) {
-          return _utils.throwError.call(this, "w and h must be positive numbers", cb);
-        } // round inputs
-
-
-        w = Math.round(w);
-        h = Math.round(h);
-
-        if (typeof _resize2["default"][mode] === "function") {
-          var dst = {
-            data: Buffer.alloc(w * h * 4),
-            width: w,
-            height: h
-          };
-
-          _resize2["default"][mode](this.bitmap, dst);
-
-          this.bitmap = dst;
-        } else {
-          var image = this;
-          var resize = new _resize["default"](this.bitmap.width, this.bitmap.height, w, h, true, true, function (buffer) {
-            image.bitmap.data = Buffer.from(buffer);
-            image.bitmap.width = w;
-            image.bitmap.height = h;
-          });
-          resize.resize(this.bitmap.data);
-        }
-
-        if ((0, _utils.isNodePattern)(cb)) {
-          cb.call(this, null, this);
-        }
-
-        return this;
+      // round inputs
+      w = Math.round(w);
+      h = Math.round(h);
+      if (typeof _resize2.default[mode] === "function") {
+        const dst = {
+          data: Buffer.alloc(w * h * 4),
+          width: w,
+          height: h
+        };
+        _resize2.default[mode](this.bitmap, dst);
+        this.bitmap = dst;
+      } else {
+        const image = this;
+        const resize = new _resize.default(this.bitmap.width, this.bitmap.height, w, h, true, true, buffer => {
+          image.bitmap.data = Buffer.from(buffer);
+          image.bitmap.width = w;
+          image.bitmap.height = h;
+        });
+        resize.resize(this.bitmap.data);
       }
+      if ((0, _utils.isNodePattern)(cb)) {
+        cb.call(this, null, this);
+      }
+      return this;
     }
-  };
-};
-
-exports["default"] = _default;
+  }
+});
+exports.default = _default;
 module.exports = exports.default;
 //# sourceMappingURL=index.js.map

dist/modules/resize.js

@@ -5,2 +5,3 @@ "use strict";
 // Released to public domain 29 July 2013: https://github.com/grantgalitz/JS-Image-Resizer/issues/4
+
 function Resize(widthOriginal, heightOriginal, targetWidth, targetHeight, blendAlpha, interpolationPass, resizeCallback) {
@@ -21,3 +22,2 @@ this.widthOriginal = Math.abs(Math.floor(widthOriginal) || 0);
 }
-
 Resize.prototype.initialize = function () {
@@ -31,3 +31,2 @@ // Perform some checks:
 };
-
 Resize.prototype.configurePasses = function () {
@@ -40,3 +39,2 @@ if (this.widthOriginal === this.targetWidth) {
     this.ratioWeightWidthPass = this.widthOriginal / this.targetWidth;
-
     if (this.ratioWeightWidthPass < 1 && this.interpolationPass) {
@@ -50,3 +48,2 @@ this.initializeFirstPassBuffers(true);
   }
-
   if (this.heightOriginal === this.targetHeight) {
@@ -58,3 +55,2 @@ // Bypass the height resizer pass:
     this.ratioWeightHeightPass = this.heightOriginal / this.targetHeight;
-
     if (this.ratioWeightHeightPass < 1 && this.interpolationPass) {
@@ -69,14 +65,14 @@ this.initializeSecondPassBuffers(true);
 };
-
 Resize.prototype._resizeWidthInterpolatedRGBChannels = function (buffer, fourthChannel) {
-  var channelsNum = fourthChannel ? 4 : 3;
-  var ratioWeight = this.ratioWeightWidthPass;
-  var outputBuffer = this.widthBuffer;
-  var weight = 0;
-  var finalOffset = 0;
-  var pixelOffset = 0;
-  var firstWeight = 0;
-  var secondWeight = 0;
-  var targetPosition; // Handle for only one interpolation input being valid for start calculation:
+  const channelsNum = fourthChannel ? 4 : 3;
+  const ratioWeight = this.ratioWeightWidthPass;
+  const outputBuffer = this.widthBuffer;
+  let weight = 0;
+  let finalOffset = 0;
+  let pixelOffset = 0;
+  let firstWeight = 0;
+  let secondWeight = 0;
+  let targetPosition;
 
+  // Handle for only one interpolation input being valid for start calculation:
   for (targetPosition = 0; weight < 1 / 3; targetPosition += channelsNum, weight += ratioWeight) {
@@ -89,13 +85,12 @@ for (finalOffset = targetPosition, pixelOffset = 0; finalOffset < this.widthPassResultSize; pixelOffset += this.originalWidthMultipliedByChannels, finalOffset += this.targetWidthMultipliedByChannels) {
     }
-  } // Adjust for overshoot of the last pass's counter:
+  }
 
-
+  // Adjust for overshoot of the last pass's counter:
   weight -= 1 / 3;
-  var interpolationWidthSourceReadStop;
-
+  let interpolationWidthSourceReadStop;
   for (interpolationWidthSourceReadStop = this.widthOriginal - 1; weight < interpolationWidthSourceReadStop; targetPosition += channelsNum, weight += ratioWeight) {
     // Calculate weightings:
     secondWeight = weight % 1;
-    firstWeight = 1 - secondWeight; // Interpolate:
-
+    firstWeight = 1 - secondWeight;
+    // Interpolate:
     for (finalOffset = targetPosition, pixelOffset = Math.floor(weight) * channelsNum; finalOffset < this.widthPassResultSize; pixelOffset += this.originalWidthMultipliedByChannels, finalOffset += this.targetWidthMultipliedByChannels) {
@@ -107,5 +102,5 @@ outputBuffer[finalOffset + 0] = buffer[pixelOffset + 0] * firstWeight + buffer[pixelOffset + channelsNum + 0] * secondWeight;
     }
-  } // Handle for only one interpolation input being valid for end calculation:
+  }
 
-
+  // Handle for only one interpolation input being valid for end calculation:
   for (interpolationWidthSourceReadStop = this.originalWidthMultipliedByChannels - channelsNum; targetPosition < this.targetWidthMultipliedByChannels; targetPosition += channelsNum) {
@@ -119,28 +114,25 @@ for (finalOffset = targetPosition, pixelOffset = interpolationWidthSourceReadStop; finalOffset < this.widthPassResultSize; pixelOffset += this.originalWidthMultipliedByChannels, finalOffset += this.targetWidthMultipliedByChannels) {
   }
-
   return outputBuffer;
 };
-
 Resize.prototype._resizeWidthRGBChannels = function (buffer, fourthChannel) {
-  var channelsNum = fourthChannel ? 4 : 3;
-  var ratioWeight = this.ratioWeightWidthPass;
-  var ratioWeightDivisor = 1 / ratioWeight;
-  var nextLineOffsetOriginalWidth = this.originalWidthMultipliedByChannels - channelsNum + 1;
-  var nextLineOffsetTargetWidth = this.targetWidthMultipliedByChannels - channelsNum + 1;
-  var output = this.outputWidthWorkBench;
-  var outputBuffer = this.widthBuffer;
-  var trustworthyColorsCount = this.outputWidthWorkBenchOpaquePixelsCount;
-  var weight = 0;
-  var amountToNext = 0;
-  var actualPosition = 0;
-  var currentPosition = 0;
-  var line = 0;
-  var pixelOffset = 0;
-  var outputOffset = 0;
-  var multiplier = 1;
-  var r = 0;
-  var g = 0;
-  var b = 0;
-  var a = 0;
-
+  const channelsNum = fourthChannel ? 4 : 3;
+  const ratioWeight = this.ratioWeightWidthPass;
+  const ratioWeightDivisor = 1 / ratioWeight;
+  const nextLineOffsetOriginalWidth = this.originalWidthMultipliedByChannels - channelsNum + 1;
+  const nextLineOffsetTargetWidth = this.targetWidthMultipliedByChannels - channelsNum + 1;
+  const output = this.outputWidthWorkBench;
+  const outputBuffer = this.widthBuffer;
+  const trustworthyColorsCount = this.outputWidthWorkBenchOpaquePixelsCount;
+  let weight = 0;
+  let amountToNext = 0;
+  let actualPosition = 0;
+  let currentPosition = 0;
+  let line = 0;
+  let pixelOffset = 0;
+  let outputOffset = 0;
+  let multiplier = 1;
+  let r = 0;
+  let g = 0;
+  let b = 0;
+  let a = 0;
   do {
@@ -151,3 +143,2 @@ for (line = 0; line < this.originalHeightMultipliedByChannels;) {
       output[line++] = 0;
-
       if (fourthChannel) {
@@ -158,9 +149,6 @@ output[line++] = 0;
     }
-
     weight = ratioWeight;
-
     do {
       amountToNext = 1 + actualPosition - currentPosition;
       multiplier = Math.min(weight, amountToNext);
-
       for (line = 0, pixelOffset = actualPosition; line < this.originalHeightMultipliedByChannels; pixelOffset += nextLineOffsetOriginalWidth) {
@@ -170,8 +158,7 @@ r = buffer[pixelOffset];
         b = buffer[++pixelOffset];
-        a = fourthChannel ? buffer[++pixelOffset] : 255; // Ignore RGB values if pixel is completely transparent
-
+        a = fourthChannel ? buffer[++pixelOffset] : 255;
+        // Ignore RGB values if pixel is completely transparent
         output[line++] += (a ? r : 0) * multiplier;
         output[line++] += (a ? g : 0) * multiplier;
         output[line++] += (a ? b : 0) * multiplier;
-
         if (fourthChannel) {
@@ -182,3 +169,2 @@ output[line++] += a * multiplier;
       }
-
       if (weight >= amountToNext) {
@@ -193,3 +179,2 @@ actualPosition += channelsNum;
     } while (weight > 0 && actualPosition < this.originalWidthMultipliedByChannels);
-
     for (line = 0, pixelOffset = outputOffset; line < this.originalHeightMultipliedByChannels; pixelOffset += nextLineOffsetTargetWidth) {
@@ -203,28 +188,24 @@ weight = fourthChannel ? trustworthyColorsCount[line / channelsNum] : 1;
     }
-
     outputOffset += channelsNum;
   } while (outputOffset < this.targetWidthMultipliedByChannels);
-
   return outputBuffer;
 };
-
 Resize.prototype._resizeHeightRGBChannels = function (buffer, fourthChannel) {
-  var ratioWeight = this.ratioWeightHeightPass;
-  var ratioWeightDivisor = 1 / ratioWeight;
-  var output = this.outputHeightWorkBench;
-  var outputBuffer = this.heightBuffer;
-  var trustworthyColorsCount = this.outputHeightWorkBenchOpaquePixelsCount;
-  var weight = 0;
-  var amountToNext = 0;
-  var actualPosition = 0;
-  var currentPosition = 0;
-  var pixelOffset = 0;
-  var outputOffset = 0;
-  var caret = 0;
-  var multiplier = 1;
-  var r = 0;
-  var g = 0;
-  var b = 0;
-  var a = 0;
-
+  const ratioWeight = this.ratioWeightHeightPass;
+  const ratioWeightDivisor = 1 / ratioWeight;
+  const output = this.outputHeightWorkBench;
+  const outputBuffer = this.heightBuffer;
+  const trustworthyColorsCount = this.outputHeightWorkBenchOpaquePixelsCount;
+  let weight = 0;
+  let amountToNext = 0;
+  let actualPosition = 0;
+  let currentPosition = 0;
+  let pixelOffset = 0;
+  let outputOffset = 0;
+  let caret = 0;
+  let multiplier = 1;
+  let r = 0;
+  let g = 0;
+  let b = 0;
+  let a = 0;
   do {
@@ -235,3 +216,2 @@ for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
       output[pixelOffset++] = 0;
-
       if (fourthChannel) {
@@ -242,5 +222,3 @@ output[pixelOffset++] = 0;
     }
-
     weight = ratioWeight;
-
     do {
@@ -250,3 +228,2 @@ amountToNext = 1 + actualPosition - currentPosition;
       caret = actualPosition;
-
       for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
@@ -256,8 +233,7 @@ r = buffer[caret++];
         b = buffer[caret++];
-        a = fourthChannel ? buffer[caret++] : 255; // Ignore RGB values if pixel is completely transparent
-
+        a = fourthChannel ? buffer[caret++] : 255;
+        // Ignore RGB values if pixel is completely transparent
         output[pixelOffset++] += (a ? r : 0) * multiplier;
         output[pixelOffset++] += (a ? g : 0) * multiplier;
         output[pixelOffset++] += (a ? b : 0) * multiplier;
-
         if (fourthChannel) {
@@ -268,3 +244,2 @@ output[pixelOffset++] += a * multiplier;
       }
-
       if (weight >= amountToNext) {
@@ -279,3 +254,2 @@ actualPosition = caret;
     } while (weight > 0 && actualPosition < this.widthPassResultSize);
-
     for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
@@ -287,3 +261,2 @@ weight = fourthChannel ? trustworthyColorsCount[pixelOffset / 4] : 1;
       outputBuffer[outputOffset++] = Math.round(output[pixelOffset++] * multiplier);
-
       if (fourthChannel) {
@@ -294,34 +267,29 @@ outputBuffer[outputOffset++] = Math.round(output[pixelOffset++] * ratioWeightDivisor);
   } while (outputOffset < this.finalResultSize);
-
   return outputBuffer;
 };
-
 Resize.prototype.resizeWidthInterpolatedRGB = function (buffer) {
   return this._resizeWidthInterpolatedRGBChannels(buffer, false);
 };
-
 Resize.prototype.resizeWidthInterpolatedRGBA = function (buffer) {
   return this._resizeWidthInterpolatedRGBChannels(buffer, true);
 };
-
 Resize.prototype.resizeWidthRGB = function (buffer) {
   return this._resizeWidthRGBChannels(buffer, false);
 };
-
 Resize.prototype.resizeWidthRGBA = function (buffer) {
   return this._resizeWidthRGBChannels(buffer, true);
 };
-
 Resize.prototype.resizeHeightInterpolated = function (buffer) {
-  var ratioWeight = this.ratioWeightHeightPass;
-  var outputBuffer = this.heightBuffer;
-  var weight = 0;
-  var finalOffset = 0;
-  var pixelOffset = 0;
-  var pixelOffsetAccumulated = 0;
-  var pixelOffsetAccumulated2 = 0;
-  var firstWeight = 0;
-  var secondWeight = 0;
-  var interpolationHeightSourceReadStop; // Handle for only one interpolation input being valid for start calculation:
+  const ratioWeight = this.ratioWeightHeightPass;
+  const outputBuffer = this.heightBuffer;
+  let weight = 0;
+  let finalOffset = 0;
+  let pixelOffset = 0;
+  let pixelOffsetAccumulated = 0;
+  let pixelOffsetAccumulated2 = 0;
+  let firstWeight = 0;
+  let secondWeight = 0;
+  let interpolationHeightSourceReadStop;
 
+  // Handle for only one interpolation input being valid for start calculation:
   for (; weight < 1 / 3; weight += ratioWeight) {
@@ -331,21 +299,19 @@ for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
     }
-  } // Adjust for overshoot of the last pass's counter:
+  }
 
-
+  // Adjust for overshoot of the last pass's counter:
   weight -= 1 / 3;
-
   for (interpolationHeightSourceReadStop = this.heightOriginal - 1; weight < interpolationHeightSourceReadStop; weight += ratioWeight) {
     // Calculate weightings:
     secondWeight = weight % 1;
-    firstWeight = 1 - secondWeight; // Interpolate:
-
+    firstWeight = 1 - secondWeight;
+    // Interpolate:
     pixelOffsetAccumulated = Math.floor(weight) * this.targetWidthMultipliedByChannels;
     pixelOffsetAccumulated2 = pixelOffsetAccumulated + this.targetWidthMultipliedByChannels;
-
     for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels; ++pixelOffset) {
       outputBuffer[finalOffset++] = Math.round(buffer[pixelOffsetAccumulated++] * firstWeight + buffer[pixelOffsetAccumulated2++] * secondWeight);
     }
-  } // Handle for only one interpolation input being valid for end calculation:
+  }
 
-
+  // Handle for only one interpolation input being valid for end calculation:
   while (finalOffset < this.finalResultSize) {
@@ -356,18 +322,13 @@ for (pixelOffset = 0, pixelOffsetAccumulated = interpolationHeightSourceReadStop * this.targetWidthMultipliedByChannels; pixelOffset < this.targetWidthMultipliedByChannels; ++pixelOffset) {
   }
-
   return outputBuffer;
 };
-
 Resize.prototype.resizeHeightRGB = function (buffer) {
   return this._resizeHeightRGBChannels(buffer, false);
 };
-
 Resize.prototype.resizeHeightRGBA = function (buffer) {
   return this._resizeHeightRGBChannels(buffer, true);
 };
-
 Resize.prototype.resize = function (buffer) {
   this.resizeCallback(this.resizeHeight(this.resizeWidth(buffer)));
 };
-
 Resize.prototype.bypassResizer = function (buffer) {
@@ -377,10 +338,7 @@ // Just return the buffer passed:
 };
-
 Resize.prototype.initializeFirstPassBuffers = function (BILINEARAlgo) {
   // Initialize the internal width pass buffers:
   this.widthBuffer = this.generateFloatBuffer(this.widthPassResultSize);
-
   if (!BILINEARAlgo) {
     this.outputWidthWorkBench = this.generateFloatBuffer(this.originalHeightMultipliedByChannels);
-
     if (this.colorChannels > 3) {
@@ -391,10 +349,7 @@ this.outputWidthWorkBenchOpaquePixelsCount = this.generateFloat64Buffer(this.heightOriginal);
 };
-
 Resize.prototype.initializeSecondPassBuffers = function (BILINEARAlgo) {
   // Initialize the internal height pass buffers:
   this.heightBuffer = this.generateUint8Buffer(this.finalResultSize);
-
   if (!BILINEARAlgo) {
     this.outputHeightWorkBench = this.generateFloatBuffer(this.targetWidthMultipliedByChannels);
-
     if (this.colorChannels > 3) {
@@ -405,3 +360,2 @@ this.outputHeightWorkBenchOpaquePixelsCount = this.generateFloat64Buffer(this.targetWidth);
 };
-
 Resize.prototype.generateFloatBuffer = function (bufferLength) {
@@ -415,3 +369,2 @@ // Generate a float32 typed array buffer:
 };
-
 Resize.prototype.generateFloat64Buffer = function (bufferLength) {
@@ -425,3 +378,2 @@ // Generate a float64 typed array buffer:
 };
-
 Resize.prototype.generateUint8Buffer = function (bufferLength) {
@@ -435,4 +387,3 @@ // Generate a uint8 typed array buffer:
 };
-
 module.exports = Resize;
 //# sourceMappingURL=resize.js.map

dist/modules/resize2.js

@@ -24,17 +24,17 @@ "use strict";
  */
+
 module.exports = {
-  nearestNeighbor: function nearestNeighbor(src, dst) {
-    var wSrc = src.width;
-    var hSrc = src.height;
-    var wDst = dst.width;
-    var hDst = dst.height;
-    var bufSrc = src.data;
-    var bufDst = dst.data;
-
-    for (var i = 0; i < hDst; i++) {
-      for (var j = 0; j < wDst; j++) {
-        var posDst = (i * wDst + j) * 4;
-        var iSrc = Math.floor(i * hSrc / hDst);
-        var jSrc = Math.floor(j * wSrc / wDst);
-        var posSrc = (iSrc * wSrc + jSrc) * 4;
+  nearestNeighbor(src, dst) {
+    const wSrc = src.width;
+    const hSrc = src.height;
+    const wDst = dst.width;
+    const hDst = dst.height;
+    const bufSrc = src.data;
+    const bufDst = dst.data;
+    for (let i = 0; i < hDst; i++) {
+      for (let j = 0; j < wDst; j++) {
+        let posDst = (i * wDst + j) * 4;
+        const iSrc = Math.floor(i * hSrc / hDst);
+        const jSrc = Math.floor(j * wSrc / wDst);
+        let posSrc = (iSrc * wSrc + jSrc) * 4;
         bufDst[posDst++] = bufSrc[posSrc++];
@@ -47,11 +47,10 @@ bufDst[posDst++] = bufSrc[posSrc++];
   },
-  bilinearInterpolation: function bilinearInterpolation(src, dst) {
-    var wSrc = src.width;
-    var hSrc = src.height;
-    var wDst = dst.width;
-    var hDst = dst.height;
-    var bufSrc = src.data;
-    var bufDst = dst.data;
-
-    var interpolate = function interpolate(k, kMin, vMin, kMax, vMax) {
+  bilinearInterpolation(src, dst) {
+    const wSrc = src.width;
+    const hSrc = src.height;
+    const wDst = dst.width;
+    const hDst = dst.height;
+    const bufSrc = src.data;
+    const bufDst = dst.data;
+    const interpolate = function (k, kMin, vMin, kMax, vMax) {
       // special case - k is integer
@@ -61,11 +60,10 @@ if (kMin === kMax) {
       }
-
       return Math.round((k - kMin) * vMax + (kMax - k) * vMin);
     };
+    const assign = function (pos, offset, x, xMin, xMax, y, yMin, yMax) {
+      let posMin = (yMin * wSrc + xMin) * 4 + offset;
+      let posMax = (yMin * wSrc + xMax) * 4 + offset;
+      const vMin = interpolate(x, xMin, bufSrc[posMin], xMax, bufSrc[posMax]);
 
-    var assign = function assign(pos, offset, x, xMin, xMax, y, yMin, yMax) {
-      var posMin = (yMin * wSrc + xMin) * 4 + offset;
-      var posMax = (yMin * wSrc + xMax) * 4 + offset;
-      var vMin = interpolate(x, xMin, bufSrc[posMin], xMax, bufSrc[posMax]); // special case, y is integer
-
+      // special case, y is integer
       if (yMax === yMin) {
@@ -76,17 +74,16 @@ bufDst[pos + offset] = vMin;
         posMax = (yMax * wSrc + xMax) * 4 + offset;
-        var vMax = interpolate(x, xMin, bufSrc[posMin], xMax, bufSrc[posMax]);
+        const vMax = interpolate(x, xMin, bufSrc[posMin], xMax, bufSrc[posMax]);
         bufDst[pos + offset] = interpolate(y, yMin, vMin, yMax, vMax);
       }
     };
-
-    for (var i = 0; i < hDst; i++) {
-      for (var j = 0; j < wDst; j++) {
-        var posDst = (i * wDst + j) * 4; // x & y in src coordinates
-
-        var x = j * wSrc / wDst;
-        var xMin = Math.floor(x);
-        var xMax = Math.min(Math.ceil(x), wSrc - 1);
-        var y = i * hSrc / hDst;
-        var yMin = Math.floor(y);
-        var yMax = Math.min(Math.ceil(y), hSrc - 1);
+    for (let i = 0; i < hDst; i++) {
+      for (let j = 0; j < wDst; j++) {
+        const posDst = (i * wDst + j) * 4;
+        // x & y in src coordinates
+        const x = j * wSrc / wDst;
+        const xMin = Math.floor(x);
+        const xMax = Math.min(Math.ceil(x), wSrc - 1);
+        const y = i * hSrc / hDst;
+        const yMin = Math.floor(y);
+        const yMax = Math.min(Math.ceil(y), hSrc - 1);
         assign(posDst, 0, x, xMin, xMax, y, yMin, yMax);
@@ -99,22 +96,24 @@ assign(posDst, 1, x, xMin, xMax, y, yMin, yMax);
   },
-  _interpolate2D: function _interpolate2D(src, dst, options, interpolate) {
-    var bufSrc = src.data;
-    var bufDst = dst.data;
-    var wSrc = src.width;
-    var hSrc = src.height;
-    var wDst = dst.width;
-    var hDst = dst.height; // when dst smaller than src/2, interpolate first to a multiple between 0.5 and 1.0 src, then sum squares
+  _interpolate2D(src, dst, options, interpolate) {
+    const bufSrc = src.data;
+    const bufDst = dst.data;
+    const wSrc = src.width;
+    const hSrc = src.height;
+    const wDst = dst.width;
+    const hDst = dst.height;
 
-    var wM = Math.max(1, Math.floor(wSrc / wDst));
-    var wDst2 = wDst * wM;
-    var hM = Math.max(1, Math.floor(hSrc / hDst));
-    var hDst2 = hDst * hM; // ===========================================================
+    // when dst smaller than src/2, interpolate first to a multiple between 0.5 and 1.0 src, then sum squares
+    const wM = Math.max(1, Math.floor(wSrc / wDst));
+    const wDst2 = wDst * wM;
+    const hM = Math.max(1, Math.floor(hSrc / hDst));
+    const hDst2 = hDst * hM;
+
+    // ===========================================================
     // Pass 1 - interpolate rows
     // buf1 has width of dst2 and height of src
+    const buf1 = Buffer.alloc(wDst2 * hSrc * 4);
+    for (let i = 0; i < hSrc; i++) {
+      for (let j = 0; j < wDst2; j++) {
+        // i in src coords, j in dst coords
 
-    var buf1 = Buffer.alloc(wDst2 * hSrc * 4);
-
-    for (var i = 0; i < hSrc; i++) {
-      for (var j = 0; j < wDst2; j++) {
-        // i in src coords, j in dst coords
         // calculate x in src coords
@@ -124,28 +123,27 @@ // this interpolation requires 4 sample points and the two inner ones must be real
         // therefore (wSrc-1)/wDst2
-        var x = j * (wSrc - 1) / wDst2;
-        var xPos = Math.floor(x);
-        var t = x - xPos;
-        var srcPos = (i * wSrc + xPos) * 4;
-        var buf1Pos = (i * wDst2 + j) * 4;
-
-        for (var k = 0; k < 4; k++) {
-          var kPos = srcPos + k;
-          var x0 = xPos > 0 ? bufSrc[kPos - 4] : 2 * bufSrc[kPos] - bufSrc[kPos + 4];
-          var x1 = bufSrc[kPos];
-          var x2 = bufSrc[kPos + 4];
-          var x3 = xPos < wSrc - 2 ? bufSrc[kPos + 8] : 2 * bufSrc[kPos + 4] - bufSrc[kPos];
+        const x = j * (wSrc - 1) / wDst2;
+        const xPos = Math.floor(x);
+        const t = x - xPos;
+        const srcPos = (i * wSrc + xPos) * 4;
+        const buf1Pos = (i * wDst2 + j) * 4;
+        for (let k = 0; k < 4; k++) {
+          const kPos = srcPos + k;
+          const x0 = xPos > 0 ? bufSrc[kPos - 4] : 2 * bufSrc[kPos] - bufSrc[kPos + 4];
+          const x1 = bufSrc[kPos];
+          const x2 = bufSrc[kPos + 4];
+          const x3 = xPos < wSrc - 2 ? bufSrc[kPos + 8] : 2 * bufSrc[kPos + 4] - bufSrc[kPos];
           buf1[buf1Pos + k] = interpolate(x0, x1, x2, x3, t);
         }
       }
-    } // this._writeFile(wDst2, hSrc, buf1, "out/buf1.jpg");
+    }
+    // this._writeFile(wDst2, hSrc, buf1, "out/buf1.jpg");
+
     // ===========================================================
     // Pass 2 - interpolate columns
     // buf2 has width and height of dst2
+    const buf2 = Buffer.alloc(wDst2 * hDst2 * 4);
+    for (let i = 0; i < hDst2; i++) {
+      for (let j = 0; j < wDst2; j++) {
+        // i&j in dst2 coords
 
-
-    var buf2 = Buffer.alloc(wDst2 * hDst2 * 4);
-
-    for (var _i = 0; _i < hDst2; _i++) {
-      for (var _j = 0; _j < wDst2; _j++) {
-        // i&j in dst2 coords
         // calculate y in buf1 coords
@@ -155,47 +153,37 @@ // this interpolation requires 4 sample points and the two inner ones must be real
         // therefore (hSrc-1)/hDst2
-        var y = _i * (hSrc - 1) / hDst2;
-        var yPos = Math.floor(y);
-
-        var _t = y - yPos;
-
-        var _buf1Pos = (yPos * wDst2 + _j) * 4;
-
-        var buf2Pos = (_i * wDst2 + _j) * 4;
-
-        for (var _k = 0; _k < 4; _k++) {
-          var _kPos = _buf1Pos + _k;
-
-          var y0 = yPos > 0 ? buf1[_kPos - wDst2 * 4] : 2 * buf1[_kPos] - buf1[_kPos + wDst2 * 4];
-          var y1 = buf1[_kPos];
-          var y2 = buf1[_kPos + wDst2 * 4];
-          var y3 = yPos < hSrc - 2 ? buf1[_kPos + wDst2 * 8] : 2 * buf1[_kPos + wDst2 * 4] - buf1[_kPos];
-          buf2[buf2Pos + _k] = interpolate(y0, y1, y2, y3, _t);
+        const y = i * (hSrc - 1) / hDst2;
+        const yPos = Math.floor(y);
+        const t = y - yPos;
+        const buf1Pos = (yPos * wDst2 + j) * 4;
+        const buf2Pos = (i * wDst2 + j) * 4;
+        for (let k = 0; k < 4; k++) {
+          const kPos = buf1Pos + k;
+          const y0 = yPos > 0 ? buf1[kPos - wDst2 * 4] : 2 * buf1[kPos] - buf1[kPos + wDst2 * 4];
+          const y1 = buf1[kPos];
+          const y2 = buf1[kPos + wDst2 * 4];
+          const y3 = yPos < hSrc - 2 ? buf1[kPos + wDst2 * 8] : 2 * buf1[kPos + wDst2 * 4] - buf1[kPos];
+          buf2[buf2Pos + k] = interpolate(y0, y1, y2, y3, t);
         }
       }
-    } // this._writeFile(wDst2, hDst2, buf2, "out/buf2.jpg");
+    }
+    // this._writeFile(wDst2, hDst2, buf2, "out/buf2.jpg");
+
     // ===========================================================
     // Pass 3 - scale to dst
-
-
-    var m = wM * hM;
-
+    const m = wM * hM;
     if (m > 1) {
-      for (var _i2 = 0; _i2 < hDst; _i2++) {
-        for (var _j2 = 0; _j2 < wDst; _j2++) {
+      for (let i = 0; i < hDst; i++) {
+        for (let j = 0; j < wDst; j++) {
           // i&j in dst bounded coords
-          var r = 0;
-          var g = 0;
-          var b = 0;
-          var a = 0;
-          var realColors = 0;
-
-          for (var _y = 0; _y < hM; _y++) {
-            var _yPos = _i2 * hM + _y;
-
-            for (var _x = 0; _x < wM; _x++) {
-              var _xPos = _j2 * wM + _x;
-
-              var xyPos = (_yPos * wDst2 + _xPos) * 4;
-              var pixelAlpha = buf2[xyPos + 3];
-
+          let r = 0;
+          let g = 0;
+          let b = 0;
+          let a = 0;
+          let realColors = 0;
+          for (let y = 0; y < hM; y++) {
+            const yPos = i * hM + y;
+            for (let x = 0; x < wM; x++) {
+              const xPos = j * wM + x;
+              const xyPos = (yPos * wDst2 + xPos) * 4;
+              const pixelAlpha = buf2[xyPos + 3];
               if (pixelAlpha) {
@@ -207,8 +195,6 @@ r += buf2[xyPos];
               }
-
               a += pixelAlpha;
             }
           }
-
-          var pos = (_i2 * wDst + _j2) * 4;
+          const pos = (i * wDst + j) * 4;
           bufDst[pos] = realColors ? Math.round(r / realColors) : 0;
@@ -225,25 +211,23 @@ bufDst[pos + 1] = realColors ? Math.round(g / realColors) : 0;
   },
-  bicubicInterpolation: function bicubicInterpolation(src, dst, options) {
-    var interpolateCubic = function interpolateCubic(x0, x1, x2, x3, t) {
-      var a0 = x3 - x2 - x0 + x1;
-      var a1 = x0 - x1 - a0;
-      var a2 = x2 - x0;
-      var a3 = x1;
+  bicubicInterpolation(src, dst, options) {
+    const interpolateCubic = function (x0, x1, x2, x3, t) {
+      const a0 = x3 - x2 - x0 + x1;
+      const a1 = x0 - x1 - a0;
+      const a2 = x2 - x0;
+      const a3 = x1;
       return Math.max(0, Math.min(255, a0 * (t * t * t) + a1 * (t * t) + a2 * t + a3));
     };
-
     return this._interpolate2D(src, dst, options, interpolateCubic);
   },
-  hermiteInterpolation: function hermiteInterpolation(src, dst, options) {
-    var interpolateHermite = function interpolateHermite(x0, x1, x2, x3, t) {
-      var c0 = x1;
-      var c1 = 0.5 * (x2 - x0);
-      var c2 = x0 - 2.5 * x1 + 2 * x2 - 0.5 * x3;
-      var c3 = 0.5 * (x3 - x0) + 1.5 * (x1 - x2);
+  hermiteInterpolation(src, dst, options) {
+    const interpolateHermite = function (x0, x1, x2, x3, t) {
+      const c0 = x1;
+      const c1 = 0.5 * (x2 - x0);
+      const c2 = x0 - 2.5 * x1 + 2 * x2 - 0.5 * x3;
+      const c3 = 0.5 * (x3 - x0) + 1.5 * (x1 - x2);
       return Math.max(0, Math.min(255, Math.round(((c3 * t + c2) * t + c1) * t + c0)));
     };
-
     return this._interpolate2D(src, dst, options, interpolateHermite);
   },
-  bezierInterpolation: function bezierInterpolation(src, dst, options) {
+  bezierInterpolation(src, dst, options) {
     // between 2 points y(n), y(n+1), use next points out, y(n-1), y(n+2)
@@ -260,14 +244,13 @@ // to predict control points (a & b) to be placed at n+0.5
     // but can go with y(-1) = y(0) and y(w) = y(w-1)
-    var interpolateBezier = function interpolateBezier(x0, x1, x2, x3, t) {
+    const interpolateBezier = function (x0, x1, x2, x3, t) {
       // x1, x2 are the knots, use x0 and x3 to calculate control points
-      var cp1 = x1 + (x2 - x0) / 4;
-      var cp2 = x2 - (x3 - x1) / 4;
-      var nt = 1 - t;
-      var c0 = x1 * nt * nt * nt;
-      var c1 = 3 * cp1 * nt * nt * t;
-      var c2 = 3 * cp2 * nt * t * t;
-      var c3 = x2 * t * t * t;
+      const cp1 = x1 + (x2 - x0) / 4;
+      const cp2 = x2 - (x3 - x1) / 4;
+      const nt = 1 - t;
+      const c0 = x1 * nt * nt * nt;
+      const c1 = 3 * cp1 * nt * nt * t;
+      const c2 = 3 * cp2 * nt * t * t;
+      const c3 = x2 * t * t * t;
       return Math.max(0, Math.min(255, Math.round(c0 + c1 + c2 + c3)));
     };
-
     return this._interpolate2D(src, dst, options, interpolateBezier);
@@ -274,0 +257,0 @@ }

es/index.js

@@ -1,95 +0,69 @@
-"use strict";
+import { throwError, isNodePattern } from "@jimp/utils";
+import Resize from "./modules/resize";
+import Resize2 from "./modules/resize2";
+export default (() => ({
+  constants: {
+    RESIZE_NEAREST_NEIGHBOR: "nearestNeighbor",
+    RESIZE_BILINEAR: "bilinearInterpolation",
+    RESIZE_BICUBIC: "bicubicInterpolation",
+    RESIZE_HERMITE: "hermiteInterpolation",
+    RESIZE_BEZIER: "bezierInterpolation"
+  },
+  class: {
+    /**
+     * Resizes the image to a set width and height using a 2-pass bilinear algorithm
+     * @param {number} w the width to resize the image to (or Jimp.AUTO)
+     * @param {number} h the height to resize the image to (or Jimp.AUTO)
+     * @param {string} mode (optional) a scaling method (e.g. Jimp.RESIZE_BEZIER)
+     * @param {function(Error, Jimp)} cb (optional) a callback for when complete
+     * @returns {Jimp} this for chaining of methods
+     */
+    resize(w, h, mode, cb) {
+      if (typeof w !== "number" || typeof h !== "number") {
+        return throwError.call(this, "w and h must be numbers", cb);
+      }
+      if (typeof mode === "function" && typeof cb === "undefined") {
+        cb = mode;
+        mode = null;
+      }
+      if (w === this.constructor.AUTO && h === this.constructor.AUTO) {
+        return throwError.call(this, "w and h cannot both be set to auto", cb);
+      }
+      if (w === this.constructor.AUTO) {
+        w = this.bitmap.width * (h / this.bitmap.height);
+      }
+      if (h === this.constructor.AUTO) {
+        h = this.bitmap.height * (w / this.bitmap.width);
+      }
+      if (w < 0 || h < 0) {
+        return throwError.call(this, "w and h must be positive numbers", cb);
+      }
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports["default"] = void 0;
-
-var _utils = require("@jimp/utils");
-
-var _resize = _interopRequireDefault(require("./modules/resize"));
-
-var _resize2 = _interopRequireDefault(require("./modules/resize2"));
-
-var _default = function _default() {
-  return {
-    constants: {
-      RESIZE_NEAREST_NEIGHBOR: "nearestNeighbor",
-      RESIZE_BILINEAR: "bilinearInterpolation",
-      RESIZE_BICUBIC: "bicubicInterpolation",
-      RESIZE_HERMITE: "hermiteInterpolation",
-      RESIZE_BEZIER: "bezierInterpolation"
-    },
-    "class": {
-      /**
-       * Resizes the image to a set width and height using a 2-pass bilinear algorithm
-       * @param {number} w the width to resize the image to (or Jimp.AUTO)
-       * @param {number} h the height to resize the image to (or Jimp.AUTO)
-       * @param {string} mode (optional) a scaling method (e.g. Jimp.RESIZE_BEZIER)
-       * @param {function(Error, Jimp)} cb (optional) a callback for when complete
-       * @returns {Jimp} this for chaining of methods
-       */
-      resize: function resize(w, h, mode, cb) {
-        if (typeof w !== "number" || typeof h !== "number") {
-          return _utils.throwError.call(this, "w and h must be numbers", cb);
-        }
-
-        if (typeof mode === "function" && typeof cb === "undefined") {
-          cb = mode;
-          mode = null;
-        }
-
-        if (w === this.constructor.AUTO && h === this.constructor.AUTO) {
-          return _utils.throwError.call(this, "w and h cannot both be set to auto", cb);
-        }
-
-        if (w === this.constructor.AUTO) {
-          w = this.bitmap.width * (h / this.bitmap.height);
-        }
-
-        if (h === this.constructor.AUTO) {
-          h = this.bitmap.height * (w / this.bitmap.width);
-        }
-
-        if (w < 0 || h < 0) {
-          return _utils.throwError.call(this, "w and h must be positive numbers", cb);
-        } // round inputs
-
-
-        w = Math.round(w);
-        h = Math.round(h);
-
-        if (typeof _resize2["default"][mode] === "function") {
-          var dst = {
-            data: Buffer.alloc(w * h * 4),
-            width: w,
-            height: h
-          };
-
-          _resize2["default"][mode](this.bitmap, dst);
-
-          this.bitmap = dst;
-        } else {
-          var image = this;
-          var resize = new _resize["default"](this.bitmap.width, this.bitmap.height, w, h, true, true, function (buffer) {
-            image.bitmap.data = Buffer.from(buffer);
-            image.bitmap.width = w;
-            image.bitmap.height = h;
-          });
-          resize.resize(this.bitmap.data);
-        }
-
-        if ((0, _utils.isNodePattern)(cb)) {
-          cb.call(this, null, this);
-        }
-
-        return this;
+      // round inputs
+      w = Math.round(w);
+      h = Math.round(h);
+      if (typeof Resize2[mode] === "function") {
+        const dst = {
+          data: Buffer.alloc(w * h * 4),
+          width: w,
+          height: h
+        };
+        Resize2[mode](this.bitmap, dst);
+        this.bitmap = dst;
+      } else {
+        const image = this;
+        const resize = new Resize(this.bitmap.width, this.bitmap.height, w, h, true, true, buffer => {
+          image.bitmap.data = Buffer.from(buffer);
+          image.bitmap.width = w;
+          image.bitmap.height = h;
+        });
+        resize.resize(this.bitmap.data);
       }
+      if (isNodePattern(cb)) {
+        cb.call(this, null, this);
+      }
+      return this;
     }
-  };
-};
-
-exports["default"] = _default;
+  }
+}));
 //# sourceMappingURL=index.js.map

es/modules/resize.js

@@ -1,5 +0,4 @@
-"use strict";
-
 // JavaScript Image Resizer (c) 2012 - Grant Galitz
 // Released to public domain 29 July 2013: https://github.com/grantgalitz/JS-Image-Resizer/issues/4
+
 function Resize(widthOriginal, heightOriginal, targetWidth, targetHeight, blendAlpha, interpolationPass, resizeCallback) {
@@ -20,3 +19,2 @@ this.widthOriginal = Math.abs(Math.floor(widthOriginal) || 0);
 }
-
 Resize.prototype.initialize = function () {
@@ -30,3 +28,2 @@ // Perform some checks:
 };
-
 Resize.prototype.configurePasses = function () {
@@ -39,3 +36,2 @@ if (this.widthOriginal === this.targetWidth) {
     this.ratioWeightWidthPass = this.widthOriginal / this.targetWidth;
-
     if (this.ratioWeightWidthPass < 1 && this.interpolationPass) {
@@ -49,3 +45,2 @@ this.initializeFirstPassBuffers(true);
   }
-
   if (this.heightOriginal === this.targetHeight) {
@@ -57,3 +52,2 @@ // Bypass the height resizer pass:
     this.ratioWeightHeightPass = this.heightOriginal / this.targetHeight;
-
     if (this.ratioWeightHeightPass < 1 && this.interpolationPass) {
@@ -68,14 +62,14 @@ this.initializeSecondPassBuffers(true);
 };
-
 Resize.prototype._resizeWidthInterpolatedRGBChannels = function (buffer, fourthChannel) {
-  var channelsNum = fourthChannel ? 4 : 3;
-  var ratioWeight = this.ratioWeightWidthPass;
-  var outputBuffer = this.widthBuffer;
-  var weight = 0;
-  var finalOffset = 0;
-  var pixelOffset = 0;
-  var firstWeight = 0;
-  var secondWeight = 0;
-  var targetPosition; // Handle for only one interpolation input being valid for start calculation:
+  const channelsNum = fourthChannel ? 4 : 3;
+  const ratioWeight = this.ratioWeightWidthPass;
+  const outputBuffer = this.widthBuffer;
+  let weight = 0;
+  let finalOffset = 0;
+  let pixelOffset = 0;
+  let firstWeight = 0;
+  let secondWeight = 0;
+  let targetPosition;
 
+  // Handle for only one interpolation input being valid for start calculation:
   for (targetPosition = 0; weight < 1 / 3; targetPosition += channelsNum, weight += ratioWeight) {
@@ -88,13 +82,12 @@ for (finalOffset = targetPosition, pixelOffset = 0; finalOffset < this.widthPassResultSize; pixelOffset += this.originalWidthMultipliedByChannels, finalOffset += this.targetWidthMultipliedByChannels) {
     }
-  } // Adjust for overshoot of the last pass's counter:
+  }
 
-
+  // Adjust for overshoot of the last pass's counter:
   weight -= 1 / 3;
-  var interpolationWidthSourceReadStop;
-
+  let interpolationWidthSourceReadStop;
   for (interpolationWidthSourceReadStop = this.widthOriginal - 1; weight < interpolationWidthSourceReadStop; targetPosition += channelsNum, weight += ratioWeight) {
     // Calculate weightings:
     secondWeight = weight % 1;
-    firstWeight = 1 - secondWeight; // Interpolate:
-
+    firstWeight = 1 - secondWeight;
+    // Interpolate:
     for (finalOffset = targetPosition, pixelOffset = Math.floor(weight) * channelsNum; finalOffset < this.widthPassResultSize; pixelOffset += this.originalWidthMultipliedByChannels, finalOffset += this.targetWidthMultipliedByChannels) {
@@ -106,5 +99,5 @@ outputBuffer[finalOffset + 0] = buffer[pixelOffset + 0] * firstWeight + buffer[pixelOffset + channelsNum + 0] * secondWeight;
     }
-  } // Handle for only one interpolation input being valid for end calculation:
+  }
 
-
+  // Handle for only one interpolation input being valid for end calculation:
   for (interpolationWidthSourceReadStop = this.originalWidthMultipliedByChannels - channelsNum; targetPosition < this.targetWidthMultipliedByChannels; targetPosition += channelsNum) {
@@ -118,28 +111,25 @@ for (finalOffset = targetPosition, pixelOffset = interpolationWidthSourceReadStop; finalOffset < this.widthPassResultSize; pixelOffset += this.originalWidthMultipliedByChannels, finalOffset += this.targetWidthMultipliedByChannels) {
   }
-
   return outputBuffer;
 };
-
 Resize.prototype._resizeWidthRGBChannels = function (buffer, fourthChannel) {
-  var channelsNum = fourthChannel ? 4 : 3;
-  var ratioWeight = this.ratioWeightWidthPass;
-  var ratioWeightDivisor = 1 / ratioWeight;
-  var nextLineOffsetOriginalWidth = this.originalWidthMultipliedByChannels - channelsNum + 1;
-  var nextLineOffsetTargetWidth = this.targetWidthMultipliedByChannels - channelsNum + 1;
-  var output = this.outputWidthWorkBench;
-  var outputBuffer = this.widthBuffer;
-  var trustworthyColorsCount = this.outputWidthWorkBenchOpaquePixelsCount;
-  var weight = 0;
-  var amountToNext = 0;
-  var actualPosition = 0;
-  var currentPosition = 0;
-  var line = 0;
-  var pixelOffset = 0;
-  var outputOffset = 0;
-  var multiplier = 1;
-  var r = 0;
-  var g = 0;
-  var b = 0;
-  var a = 0;
-
+  const channelsNum = fourthChannel ? 4 : 3;
+  const ratioWeight = this.ratioWeightWidthPass;
+  const ratioWeightDivisor = 1 / ratioWeight;
+  const nextLineOffsetOriginalWidth = this.originalWidthMultipliedByChannels - channelsNum + 1;
+  const nextLineOffsetTargetWidth = this.targetWidthMultipliedByChannels - channelsNum + 1;
+  const output = this.outputWidthWorkBench;
+  const outputBuffer = this.widthBuffer;
+  const trustworthyColorsCount = this.outputWidthWorkBenchOpaquePixelsCount;
+  let weight = 0;
+  let amountToNext = 0;
+  let actualPosition = 0;
+  let currentPosition = 0;
+  let line = 0;
+  let pixelOffset = 0;
+  let outputOffset = 0;
+  let multiplier = 1;
+  let r = 0;
+  let g = 0;
+  let b = 0;
+  let a = 0;
   do {
@@ -150,3 +140,2 @@ for (line = 0; line < this.originalHeightMultipliedByChannels;) {
       output[line++] = 0;
-
       if (fourthChannel) {
@@ -157,9 +146,6 @@ output[line++] = 0;
     }
-
     weight = ratioWeight;
-
     do {
       amountToNext = 1 + actualPosition - currentPosition;
       multiplier = Math.min(weight, amountToNext);
-
       for (line = 0, pixelOffset = actualPosition; line < this.originalHeightMultipliedByChannels; pixelOffset += nextLineOffsetOriginalWidth) {
@@ -169,8 +155,7 @@ r = buffer[pixelOffset];
         b = buffer[++pixelOffset];
-        a = fourthChannel ? buffer[++pixelOffset] : 255; // Ignore RGB values if pixel is completely transparent
-
+        a = fourthChannel ? buffer[++pixelOffset] : 255;
+        // Ignore RGB values if pixel is completely transparent
         output[line++] += (a ? r : 0) * multiplier;
         output[line++] += (a ? g : 0) * multiplier;
         output[line++] += (a ? b : 0) * multiplier;
-
         if (fourthChannel) {
@@ -181,3 +166,2 @@ output[line++] += a * multiplier;
       }
-
       if (weight >= amountToNext) {
@@ -192,3 +176,2 @@ actualPosition += channelsNum;
     } while (weight > 0 && actualPosition < this.originalWidthMultipliedByChannels);
-
     for (line = 0, pixelOffset = outputOffset; line < this.originalHeightMultipliedByChannels; pixelOffset += nextLineOffsetTargetWidth) {
@@ -202,28 +185,24 @@ weight = fourthChannel ? trustworthyColorsCount[line / channelsNum] : 1;
     }
-
     outputOffset += channelsNum;
   } while (outputOffset < this.targetWidthMultipliedByChannels);
-
   return outputBuffer;
 };
-
 Resize.prototype._resizeHeightRGBChannels = function (buffer, fourthChannel) {
-  var ratioWeight = this.ratioWeightHeightPass;
-  var ratioWeightDivisor = 1 / ratioWeight;
-  var output = this.outputHeightWorkBench;
-  var outputBuffer = this.heightBuffer;
-  var trustworthyColorsCount = this.outputHeightWorkBenchOpaquePixelsCount;
-  var weight = 0;
-  var amountToNext = 0;
-  var actualPosition = 0;
-  var currentPosition = 0;
-  var pixelOffset = 0;
-  var outputOffset = 0;
-  var caret = 0;
-  var multiplier = 1;
-  var r = 0;
-  var g = 0;
-  var b = 0;
-  var a = 0;
-
+  const ratioWeight = this.ratioWeightHeightPass;
+  const ratioWeightDivisor = 1 / ratioWeight;
+  const output = this.outputHeightWorkBench;
+  const outputBuffer = this.heightBuffer;
+  const trustworthyColorsCount = this.outputHeightWorkBenchOpaquePixelsCount;
+  let weight = 0;
+  let amountToNext = 0;
+  let actualPosition = 0;
+  let currentPosition = 0;
+  let pixelOffset = 0;
+  let outputOffset = 0;
+  let caret = 0;
+  let multiplier = 1;
+  let r = 0;
+  let g = 0;
+  let b = 0;
+  let a = 0;
   do {
@@ -234,3 +213,2 @@ for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
       output[pixelOffset++] = 0;
-
       if (fourthChannel) {
@@ -241,5 +219,3 @@ output[pixelOffset++] = 0;
     }
-
     weight = ratioWeight;
-
     do {
@@ -249,3 +225,2 @@ amountToNext = 1 + actualPosition - currentPosition;
       caret = actualPosition;
-
       for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
@@ -255,8 +230,7 @@ r = buffer[caret++];
         b = buffer[caret++];
-        a = fourthChannel ? buffer[caret++] : 255; // Ignore RGB values if pixel is completely transparent
-
+        a = fourthChannel ? buffer[caret++] : 255;
+        // Ignore RGB values if pixel is completely transparent
         output[pixelOffset++] += (a ? r : 0) * multiplier;
         output[pixelOffset++] += (a ? g : 0) * multiplier;
         output[pixelOffset++] += (a ? b : 0) * multiplier;
-
         if (fourthChannel) {
@@ -267,3 +241,2 @@ output[pixelOffset++] += a * multiplier;
       }
-
       if (weight >= amountToNext) {
@@ -278,3 +251,2 @@ actualPosition = caret;
     } while (weight > 0 && actualPosition < this.widthPassResultSize);
-
     for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
@@ -286,3 +258,2 @@ weight = fourthChannel ? trustworthyColorsCount[pixelOffset / 4] : 1;
       outputBuffer[outputOffset++] = Math.round(output[pixelOffset++] * multiplier);
-
       if (fourthChannel) {
@@ -293,34 +264,29 @@ outputBuffer[outputOffset++] = Math.round(output[pixelOffset++] * ratioWeightDivisor);
   } while (outputOffset < this.finalResultSize);
-
   return outputBuffer;
 };
-
 Resize.prototype.resizeWidthInterpolatedRGB = function (buffer) {
   return this._resizeWidthInterpolatedRGBChannels(buffer, false);
 };
-
 Resize.prototype.resizeWidthInterpolatedRGBA = function (buffer) {
   return this._resizeWidthInterpolatedRGBChannels(buffer, true);
 };
-
 Resize.prototype.resizeWidthRGB = function (buffer) {
   return this._resizeWidthRGBChannels(buffer, false);
 };
-
 Resize.prototype.resizeWidthRGBA = function (buffer) {
   return this._resizeWidthRGBChannels(buffer, true);
 };
-
 Resize.prototype.resizeHeightInterpolated = function (buffer) {
-  var ratioWeight = this.ratioWeightHeightPass;
-  var outputBuffer = this.heightBuffer;
-  var weight = 0;
-  var finalOffset = 0;
-  var pixelOffset = 0;
-  var pixelOffsetAccumulated = 0;
-  var pixelOffsetAccumulated2 = 0;
-  var firstWeight = 0;
-  var secondWeight = 0;
-  var interpolationHeightSourceReadStop; // Handle for only one interpolation input being valid for start calculation:
+  const ratioWeight = this.ratioWeightHeightPass;
+  const outputBuffer = this.heightBuffer;
+  let weight = 0;
+  let finalOffset = 0;
+  let pixelOffset = 0;
+  let pixelOffsetAccumulated = 0;
+  let pixelOffsetAccumulated2 = 0;
+  let firstWeight = 0;
+  let secondWeight = 0;
+  let interpolationHeightSourceReadStop;
 
+  // Handle for only one interpolation input being valid for start calculation:
   for (; weight < 1 / 3; weight += ratioWeight) {
@@ -330,21 +296,19 @@ for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels;) {
     }
-  } // Adjust for overshoot of the last pass's counter:
+  }
 
-
+  // Adjust for overshoot of the last pass's counter:
   weight -= 1 / 3;
-
   for (interpolationHeightSourceReadStop = this.heightOriginal - 1; weight < interpolationHeightSourceReadStop; weight += ratioWeight) {
     // Calculate weightings:
     secondWeight = weight % 1;
-    firstWeight = 1 - secondWeight; // Interpolate:
-
+    firstWeight = 1 - secondWeight;
+    // Interpolate:
     pixelOffsetAccumulated = Math.floor(weight) * this.targetWidthMultipliedByChannels;
     pixelOffsetAccumulated2 = pixelOffsetAccumulated + this.targetWidthMultipliedByChannels;
-
     for (pixelOffset = 0; pixelOffset < this.targetWidthMultipliedByChannels; ++pixelOffset) {
       outputBuffer[finalOffset++] = Math.round(buffer[pixelOffsetAccumulated++] * firstWeight + buffer[pixelOffsetAccumulated2++] * secondWeight);
     }
-  } // Handle for only one interpolation input being valid for end calculation:
+  }
 
-
+  // Handle for only one interpolation input being valid for end calculation:
   while (finalOffset < this.finalResultSize) {
@@ -355,18 +319,13 @@ for (pixelOffset = 0, pixelOffsetAccumulated = interpolationHeightSourceReadStop * this.targetWidthMultipliedByChannels; pixelOffset < this.targetWidthMultipliedByChannels; ++pixelOffset) {
   }
-
   return outputBuffer;
 };
-
 Resize.prototype.resizeHeightRGB = function (buffer) {
   return this._resizeHeightRGBChannels(buffer, false);
 };
-
 Resize.prototype.resizeHeightRGBA = function (buffer) {
   return this._resizeHeightRGBChannels(buffer, true);
 };
-
 Resize.prototype.resize = function (buffer) {
   this.resizeCallback(this.resizeHeight(this.resizeWidth(buffer)));
 };
-
 Resize.prototype.bypassResizer = function (buffer) {
@@ -376,10 +335,7 @@ // Just return the buffer passed:
 };
-
 Resize.prototype.initializeFirstPassBuffers = function (BILINEARAlgo) {
   // Initialize the internal width pass buffers:
   this.widthBuffer = this.generateFloatBuffer(this.widthPassResultSize);
-
   if (!BILINEARAlgo) {
     this.outputWidthWorkBench = this.generateFloatBuffer(this.originalHeightMultipliedByChannels);
-
     if (this.colorChannels > 3) {
@@ -390,10 +346,7 @@ this.outputWidthWorkBenchOpaquePixelsCount = this.generateFloat64Buffer(this.heightOriginal);
 };
-
 Resize.prototype.initializeSecondPassBuffers = function (BILINEARAlgo) {
   // Initialize the internal height pass buffers:
   this.heightBuffer = this.generateUint8Buffer(this.finalResultSize);
-
   if (!BILINEARAlgo) {
     this.outputHeightWorkBench = this.generateFloatBuffer(this.targetWidthMultipliedByChannels);
-
     if (this.colorChannels > 3) {
@@ -404,3 +357,2 @@ this.outputHeightWorkBenchOpaquePixelsCount = this.generateFloat64Buffer(this.targetWidth);
 };
-
 Resize.prototype.generateFloatBuffer = function (bufferLength) {
@@ -414,3 +366,2 @@ // Generate a float32 typed array buffer:
 };
-
 Resize.prototype.generateFloat64Buffer = function (bufferLength) {
@@ -424,3 +375,2 @@ // Generate a float64 typed array buffer:
 };
-
 Resize.prototype.generateUint8Buffer = function (bufferLength) {
@@ -434,4 +384,3 @@ // Generate a uint8 typed array buffer:
 };
-
 module.exports = Resize;
 //# sourceMappingURL=resize.js.map

es/modules/resize2.js

@@ -1,3 +0,1 @@
-"use strict";
-
 /**
@@ -24,17 +22,17 @@ * Copyright (c) 2015 Guyon Roche
  */
+
 module.exports = {
-  nearestNeighbor: function nearestNeighbor(src, dst) {
-    var wSrc = src.width;
-    var hSrc = src.height;
-    var wDst = dst.width;
-    var hDst = dst.height;
-    var bufSrc = src.data;
-    var bufDst = dst.data;
-
-    for (var i = 0; i < hDst; i++) {
-      for (var j = 0; j < wDst; j++) {
-        var posDst = (i * wDst + j) * 4;
-        var iSrc = Math.floor(i * hSrc / hDst);
-        var jSrc = Math.floor(j * wSrc / wDst);
-        var posSrc = (iSrc * wSrc + jSrc) * 4;
+  nearestNeighbor(src, dst) {
+    const wSrc = src.width;
+    const hSrc = src.height;
+    const wDst = dst.width;
+    const hDst = dst.height;
+    const bufSrc = src.data;
+    const bufDst = dst.data;
+    for (let i = 0; i < hDst; i++) {
+      for (let j = 0; j < wDst; j++) {
+        let posDst = (i * wDst + j) * 4;
+        const iSrc = Math.floor(i * hSrc / hDst);
+        const jSrc = Math.floor(j * wSrc / wDst);
+        let posSrc = (iSrc * wSrc + jSrc) * 4;
         bufDst[posDst++] = bufSrc[posSrc++];
@@ -47,11 +45,10 @@ bufDst[posDst++] = bufSrc[posSrc++];
   },
-  bilinearInterpolation: function bilinearInterpolation(src, dst) {
-    var wSrc = src.width;
-    var hSrc = src.height;
-    var wDst = dst.width;
-    var hDst = dst.height;
-    var bufSrc = src.data;
-    var bufDst = dst.data;
-
-    var interpolate = function interpolate(k, kMin, vMin, kMax, vMax) {
+  bilinearInterpolation(src, dst) {
+    const wSrc = src.width;
+    const hSrc = src.height;
+    const wDst = dst.width;
+    const hDst = dst.height;
+    const bufSrc = src.data;
+    const bufDst = dst.data;
+    const interpolate = function (k, kMin, vMin, kMax, vMax) {
       // special case - k is integer
@@ -61,11 +58,10 @@ if (kMin === kMax) {
       }
-
       return Math.round((k - kMin) * vMax + (kMax - k) * vMin);
     };
+    const assign = function (pos, offset, x, xMin, xMax, y, yMin, yMax) {
+      let posMin = (yMin * wSrc + xMin) * 4 + offset;
+      let posMax = (yMin * wSrc + xMax) * 4 + offset;
+      const vMin = interpolate(x, xMin, bufSrc[posMin], xMax, bufSrc[posMax]);
 
-    var assign = function assign(pos, offset, x, xMin, xMax, y, yMin, yMax) {
-      var posMin = (yMin * wSrc + xMin) * 4 + offset;
-      var posMax = (yMin * wSrc + xMax) * 4 + offset;
-      var vMin = interpolate(x, xMin, bufSrc[posMin], xMax, bufSrc[posMax]); // special case, y is integer
-
+      // special case, y is integer
       if (yMax === yMin) {
@@ -76,17 +72,16 @@ bufDst[pos + offset] = vMin;
         posMax = (yMax * wSrc + xMax) * 4 + offset;
-        var vMax = interpolate(x, xMin, bufSrc[posMin], xMax, bufSrc[posMax]);
+        const vMax = interpolate(x, xMin, bufSrc[posMin], xMax, bufSrc[posMax]);
         bufDst[pos + offset] = interpolate(y, yMin, vMin, yMax, vMax);
       }
     };
-
-    for (var i = 0; i < hDst; i++) {
-      for (var j = 0; j < wDst; j++) {
-        var posDst = (i * wDst + j) * 4; // x & y in src coordinates
-
-        var x = j * wSrc / wDst;
-        var xMin = Math.floor(x);
-        var xMax = Math.min(Math.ceil(x), wSrc - 1);
-        var y = i * hSrc / hDst;
-        var yMin = Math.floor(y);
-        var yMax = Math.min(Math.ceil(y), hSrc - 1);
+    for (let i = 0; i < hDst; i++) {
+      for (let j = 0; j < wDst; j++) {
+        const posDst = (i * wDst + j) * 4;
+        // x & y in src coordinates
+        const x = j * wSrc / wDst;
+        const xMin = Math.floor(x);
+        const xMax = Math.min(Math.ceil(x), wSrc - 1);
+        const y = i * hSrc / hDst;
+        const yMin = Math.floor(y);
+        const yMax = Math.min(Math.ceil(y), hSrc - 1);
         assign(posDst, 0, x, xMin, xMax, y, yMin, yMax);
@@ -99,22 +94,24 @@ assign(posDst, 1, x, xMin, xMax, y, yMin, yMax);
   },
-  _interpolate2D: function _interpolate2D(src, dst, options, interpolate) {
-    var bufSrc = src.data;
-    var bufDst = dst.data;
-    var wSrc = src.width;
-    var hSrc = src.height;
-    var wDst = dst.width;
-    var hDst = dst.height; // when dst smaller than src/2, interpolate first to a multiple between 0.5 and 1.0 src, then sum squares
+  _interpolate2D(src, dst, options, interpolate) {
+    const bufSrc = src.data;
+    const bufDst = dst.data;
+    const wSrc = src.width;
+    const hSrc = src.height;
+    const wDst = dst.width;
+    const hDst = dst.height;
 
-    var wM = Math.max(1, Math.floor(wSrc / wDst));
-    var wDst2 = wDst * wM;
-    var hM = Math.max(1, Math.floor(hSrc / hDst));
-    var hDst2 = hDst * hM; // ===========================================================
+    // when dst smaller than src/2, interpolate first to a multiple between 0.5 and 1.0 src, then sum squares
+    const wM = Math.max(1, Math.floor(wSrc / wDst));
+    const wDst2 = wDst * wM;
+    const hM = Math.max(1, Math.floor(hSrc / hDst));
+    const hDst2 = hDst * hM;
+
+    // ===========================================================
     // Pass 1 - interpolate rows
     // buf1 has width of dst2 and height of src
+    const buf1 = Buffer.alloc(wDst2 * hSrc * 4);
+    for (let i = 0; i < hSrc; i++) {
+      for (let j = 0; j < wDst2; j++) {
+        // i in src coords, j in dst coords
 
-    var buf1 = Buffer.alloc(wDst2 * hSrc * 4);
-
-    for (var i = 0; i < hSrc; i++) {
-      for (var j = 0; j < wDst2; j++) {
-        // i in src coords, j in dst coords
         // calculate x in src coords
@@ -124,28 +121,27 @@ // this interpolation requires 4 sample points and the two inner ones must be real
         // therefore (wSrc-1)/wDst2
-        var x = j * (wSrc - 1) / wDst2;
-        var xPos = Math.floor(x);
-        var t = x - xPos;
-        var srcPos = (i * wSrc + xPos) * 4;
-        var buf1Pos = (i * wDst2 + j) * 4;
-
-        for (var k = 0; k < 4; k++) {
-          var kPos = srcPos + k;
-          var x0 = xPos > 0 ? bufSrc[kPos - 4] : 2 * bufSrc[kPos] - bufSrc[kPos + 4];
-          var x1 = bufSrc[kPos];
-          var x2 = bufSrc[kPos + 4];
-          var x3 = xPos < wSrc - 2 ? bufSrc[kPos + 8] : 2 * bufSrc[kPos + 4] - bufSrc[kPos];
+        const x = j * (wSrc - 1) / wDst2;
+        const xPos = Math.floor(x);
+        const t = x - xPos;
+        const srcPos = (i * wSrc + xPos) * 4;
+        const buf1Pos = (i * wDst2 + j) * 4;
+        for (let k = 0; k < 4; k++) {
+          const kPos = srcPos + k;
+          const x0 = xPos > 0 ? bufSrc[kPos - 4] : 2 * bufSrc[kPos] - bufSrc[kPos + 4];
+          const x1 = bufSrc[kPos];
+          const x2 = bufSrc[kPos + 4];
+          const x3 = xPos < wSrc - 2 ? bufSrc[kPos + 8] : 2 * bufSrc[kPos + 4] - bufSrc[kPos];
           buf1[buf1Pos + k] = interpolate(x0, x1, x2, x3, t);
         }
       }
-    } // this._writeFile(wDst2, hSrc, buf1, "out/buf1.jpg");
+    }
+    // this._writeFile(wDst2, hSrc, buf1, "out/buf1.jpg");
+
     // ===========================================================
     // Pass 2 - interpolate columns
     // buf2 has width and height of dst2
+    const buf2 = Buffer.alloc(wDst2 * hDst2 * 4);
+    for (let i = 0; i < hDst2; i++) {
+      for (let j = 0; j < wDst2; j++) {
+        // i&j in dst2 coords
 
-
-    var buf2 = Buffer.alloc(wDst2 * hDst2 * 4);
-
-    for (var _i = 0; _i < hDst2; _i++) {
-      for (var _j = 0; _j < wDst2; _j++) {
-        // i&j in dst2 coords
         // calculate y in buf1 coords
@@ -155,47 +151,37 @@ // this interpolation requires 4 sample points and the two inner ones must be real
         // therefore (hSrc-1)/hDst2
-        var y = _i * (hSrc - 1) / hDst2;
-        var yPos = Math.floor(y);
-
-        var _t = y - yPos;
-
-        var _buf1Pos = (yPos * wDst2 + _j) * 4;
-
-        var buf2Pos = (_i * wDst2 + _j) * 4;
-
-        for (var _k = 0; _k < 4; _k++) {
-          var _kPos = _buf1Pos + _k;
-
-          var y0 = yPos > 0 ? buf1[_kPos - wDst2 * 4] : 2 * buf1[_kPos] - buf1[_kPos + wDst2 * 4];
-          var y1 = buf1[_kPos];
-          var y2 = buf1[_kPos + wDst2 * 4];
-          var y3 = yPos < hSrc - 2 ? buf1[_kPos + wDst2 * 8] : 2 * buf1[_kPos + wDst2 * 4] - buf1[_kPos];
-          buf2[buf2Pos + _k] = interpolate(y0, y1, y2, y3, _t);
+        const y = i * (hSrc - 1) / hDst2;
+        const yPos = Math.floor(y);
+        const t = y - yPos;
+        const buf1Pos = (yPos * wDst2 + j) * 4;
+        const buf2Pos = (i * wDst2 + j) * 4;
+        for (let k = 0; k < 4; k++) {
+          const kPos = buf1Pos + k;
+          const y0 = yPos > 0 ? buf1[kPos - wDst2 * 4] : 2 * buf1[kPos] - buf1[kPos + wDst2 * 4];
+          const y1 = buf1[kPos];
+          const y2 = buf1[kPos + wDst2 * 4];
+          const y3 = yPos < hSrc - 2 ? buf1[kPos + wDst2 * 8] : 2 * buf1[kPos + wDst2 * 4] - buf1[kPos];
+          buf2[buf2Pos + k] = interpolate(y0, y1, y2, y3, t);
         }
       }
-    } // this._writeFile(wDst2, hDst2, buf2, "out/buf2.jpg");
+    }
+    // this._writeFile(wDst2, hDst2, buf2, "out/buf2.jpg");
+
     // ===========================================================
     // Pass 3 - scale to dst
-
-
-    var m = wM * hM;
-
+    const m = wM * hM;
     if (m > 1) {
-      for (var _i2 = 0; _i2 < hDst; _i2++) {
-        for (var _j2 = 0; _j2 < wDst; _j2++) {
+      for (let i = 0; i < hDst; i++) {
+        for (let j = 0; j < wDst; j++) {
           // i&j in dst bounded coords
-          var r = 0;
-          var g = 0;
-          var b = 0;
-          var a = 0;
-          var realColors = 0;
-
-          for (var _y = 0; _y < hM; _y++) {
-            var _yPos = _i2 * hM + _y;
-
-            for (var _x = 0; _x < wM; _x++) {
-              var _xPos = _j2 * wM + _x;
-
-              var xyPos = (_yPos * wDst2 + _xPos) * 4;
-              var pixelAlpha = buf2[xyPos + 3];
-
+          let r = 0;
+          let g = 0;
+          let b = 0;
+          let a = 0;
+          let realColors = 0;
+          for (let y = 0; y < hM; y++) {
+            const yPos = i * hM + y;
+            for (let x = 0; x < wM; x++) {
+              const xPos = j * wM + x;
+              const xyPos = (yPos * wDst2 + xPos) * 4;
+              const pixelAlpha = buf2[xyPos + 3];
               if (pixelAlpha) {
@@ -207,8 +193,6 @@ r += buf2[xyPos];
               }
-
               a += pixelAlpha;
             }
           }
-
-          var pos = (_i2 * wDst + _j2) * 4;
+          const pos = (i * wDst + j) * 4;
           bufDst[pos] = realColors ? Math.round(r / realColors) : 0;
@@ -225,25 +209,23 @@ bufDst[pos + 1] = realColors ? Math.round(g / realColors) : 0;
   },
-  bicubicInterpolation: function bicubicInterpolation(src, dst, options) {
-    var interpolateCubic = function interpolateCubic(x0, x1, x2, x3, t) {
-      var a0 = x3 - x2 - x0 + x1;
-      var a1 = x0 - x1 - a0;
-      var a2 = x2 - x0;
-      var a3 = x1;
+  bicubicInterpolation(src, dst, options) {
+    const interpolateCubic = function (x0, x1, x2, x3, t) {
+      const a0 = x3 - x2 - x0 + x1;
+      const a1 = x0 - x1 - a0;
+      const a2 = x2 - x0;
+      const a3 = x1;
       return Math.max(0, Math.min(255, a0 * (t * t * t) + a1 * (t * t) + a2 * t + a3));
     };
-
     return this._interpolate2D(src, dst, options, interpolateCubic);
   },
-  hermiteInterpolation: function hermiteInterpolation(src, dst, options) {
-    var interpolateHermite = function interpolateHermite(x0, x1, x2, x3, t) {
-      var c0 = x1;
-      var c1 = 0.5 * (x2 - x0);
-      var c2 = x0 - 2.5 * x1 + 2 * x2 - 0.5 * x3;
-      var c3 = 0.5 * (x3 - x0) + 1.5 * (x1 - x2);
+  hermiteInterpolation(src, dst, options) {
+    const interpolateHermite = function (x0, x1, x2, x3, t) {
+      const c0 = x1;
+      const c1 = 0.5 * (x2 - x0);
+      const c2 = x0 - 2.5 * x1 + 2 * x2 - 0.5 * x3;
+      const c3 = 0.5 * (x3 - x0) + 1.5 * (x1 - x2);
       return Math.max(0, Math.min(255, Math.round(((c3 * t + c2) * t + c1) * t + c0)));
     };
-
     return this._interpolate2D(src, dst, options, interpolateHermite);
   },
-  bezierInterpolation: function bezierInterpolation(src, dst, options) {
+  bezierInterpolation(src, dst, options) {
     // between 2 points y(n), y(n+1), use next points out, y(n-1), y(n+2)
@@ -260,14 +242,13 @@ // to predict control points (a & b) to be placed at n+0.5
     // but can go with y(-1) = y(0) and y(w) = y(w-1)
-    var interpolateBezier = function interpolateBezier(x0, x1, x2, x3, t) {
+    const interpolateBezier = function (x0, x1, x2, x3, t) {
       // x1, x2 are the knots, use x0 and x3 to calculate control points
-      var cp1 = x1 + (x2 - x0) / 4;
-      var cp2 = x2 - (x3 - x1) / 4;
-      var nt = 1 - t;
-      var c0 = x1 * nt * nt * nt;
-      var c1 = 3 * cp1 * nt * nt * t;
-      var c2 = 3 * cp2 * nt * t * t;
-      var c3 = x2 * t * t * t;
+      const cp1 = x1 + (x2 - x0) / 4;
+      const cp2 = x2 - (x3 - x1) / 4;
+      const nt = 1 - t;
+      const c0 = x1 * nt * nt * nt;
+      const c1 = 3 * cp1 * nt * nt * t;
+      const c2 = 3 * cp2 * nt * t * t;
+      const c3 = x2 * t * t * t;
       return Math.max(0, Math.min(255, Math.round(c0 + c1 + c2 + c3)));
     };
-
     return this._interpolate2D(src, dst, options, interpolateBezier);
@@ -274,0 +255,0 @@ }

package.json

 {
   "name": "@jimp/plugin-resize",
-  "version": "0.20.2",
+  "version": "0.21.0--canary.1149.3239903.0",
   "description": "Resize an image.",
@@ -24,4 +24,3 @@ "main": "dist/index.js",
   "dependencies": {
-    "@babel/runtime": "^7.7.2",
-    "@jimp/utils": "^0.20.2"
+    "@jimp/utils": "0.21.0--canary.1149.3239903.0"
   },
@@ -32,4 +31,4 @@ "peerDependencies": {
   "devDependencies": {
-    "@jimp/custom": "^0.20.2",
-    "@jimp/test-utils": "^0.20.2"
+    "@jimp/custom": "0.21.0--canary.1149.3239903.0",
+    "@jimp/test-utils": "0.21.0--canary.1149.3239903.0"
   },
@@ -39,3 +38,3 @@ "publishConfig": {
   },
-  "gitHead": "cebbdb72f889102a8e3c42b25ad3243b16e3a485"
+  "gitHead": "323990352ce279d67297aed097b37bd8ec66ef51"
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Dependency count

2

decreased by-33.33%

Lines of code

2440

increased by0.87%

Worsened metrics

Total package byte prevSize

224295

decreased by-0.76%

Dependency changes

• + Added@jimp/utils@0.21.0--canary.1149.3239903.0(transitive)

• - Removed@babel/runtime@^7.7.2

• - Removed@babel/runtime@7.26.0(transitive)

• - Removed@jimp/utils@0.20.2(transitive)

• - Removedregenerator-runtime@0.14.1(transitive)

• Updated@jimp/utils@0.21.0--canary.1149.3239903.0