cyberchef 10.22.1 → 10.24.0

package/src/core/operations/ContainImage.mjs

@@ -9,13 +9,18 @@ import OperationError from "../errors/OperationError.mjs";
 import { isImage } from "../lib/FileType.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
 import { isWorkerEnvironment } from "../Utils.mjs";
-import Jimp from "jimp/es/index.js";
+import {
+    Jimp,
+    JimpMime,
+    ResizeStrategy,
+    HorizontalAlign,
+    VerticalAlign,
+} from "jimp";
 
 /**
  * Contain Image operation
  */
 class ContainImage extends Operation {
-
     /**
      * ContainImage constructor
      */
@@ -24,7 +29,8 @@ class ContainImage extends Operation {
 
         this.name = "Contain Image";
         this.module = "Image";
-        this.description = "Scales an image to the specified width and height, maintaining the aspect ratio. The image may be letterboxed.";
+        this.description =
+            "Scales an image to the specified width and height, maintaining the aspect ratio. The image may be letterboxed.";
         this.infoURL = "";
         this.inputType = "ArrayBuffer";
         this.outputType = "ArrayBuffer";
@@ -34,33 +40,25 @@ class ContainImage extends Operation {
                 name: "Width",
                 type: "number",
                 value: 100,
-                min: 1
+                min: 1,
             },
             {
                 name: "Height",
                 type: "number",
                 value: 100,
-                min: 1
+                min: 1,
             },
             {
                 name: "Horizontal align",
                 type: "option",
-                value: [
-                    "Left",
-                    "Center",
-                    "Right"
-                ],
-                defaultIndex: 1
+                value: ["Left", "Center", "Right"],
+                defaultIndex: 1,
             },
             {
                 name: "Vertical align",
                 type: "option",
-                value: [
-                    "Top",
-                    "Middle",
-                    "Bottom"
-                ],
-                defaultIndex: 1
+                value: ["Top", "Middle", "Bottom"],
+                defaultIndex: 1,
             },
             {
                 name: "Resizing algorithm",
@@ -70,15 +68,15 @@ class ContainImage extends Operation {
                     "Bilinear",
                     "Bicubic",
                     "Hermite",
-                    "Bezier"
+                    "Bezier",
                 ],
-                defaultIndex: 1
+                defaultIndex: 1,
             },
             {
                 name: "Opaque background",
                 type: "boolean",
-                value: true
-            }
+                value: true,
+            },
         ];
     }
 
@@ -91,20 +89,20 @@ class ContainImage extends Operation {
         const [width, height, hAlign, vAlign, alg, opaqueBg] = args;
 
         const resizeMap = {
-            "Nearest Neighbour": Jimp.RESIZE_NEAREST_NEIGHBOR,
-            "Bilinear": Jimp.RESIZE_BILINEAR,
-            "Bicubic": Jimp.RESIZE_BICUBIC,
-            "Hermite": Jimp.RESIZE_HERMITE,
-            "Bezier": Jimp.RESIZE_BEZIER
+            "Nearest Neighbour": ResizeStrategy.NEAREST_NEIGHBOR,
+            Bilinear: ResizeStrategy.BILINEAR,
+            Bicubic: ResizeStrategy.BICUBIC,
+            Hermite: ResizeStrategy.HERMITE,
+            Bezier: ResizeStrategy.BEZIER,
         };
 
         const alignMap = {
-            "Left": Jimp.HORIZONTAL_ALIGN_LEFT,
-            "Center": Jimp.HORIZONTAL_ALIGN_CENTER,
-            "Right": Jimp.HORIZONTAL_ALIGN_RIGHT,
-            "Top": Jimp.VERTICAL_ALIGN_TOP,
-            "Middle": Jimp.VERTICAL_ALIGN_MIDDLE,
-            "Bottom": Jimp.VERTICAL_ALIGN_BOTTOM
+            Left: HorizontalAlign.LEFT,
+            Center: HorizontalAlign.CENTER,
+            Right: HorizontalAlign.RIGHT,
+            Top: VerticalAlign.TOP,
+            Middle: VerticalAlign.MIDDLE,
+            Bottom: VerticalAlign.BOTTOM,
         };
 
         if (!isImage(input)) {
@@ -117,22 +115,35 @@ class ContainImage extends Operation {
         } catch (err) {
             throw new OperationError(`Error loading image. (${err})`);
         }
+        const originalMime = image.mime;
         try {
             if (isWorkerEnvironment())
                 self.sendStatusMessage("Containing image...");
-            image.contain(width, height, alignMap[hAlign] | alignMap[vAlign], resizeMap[alg]);
+            image.contain({
+                w: width,
+                h: height,
+                align: alignMap[hAlign] | alignMap[vAlign],
+                mode: resizeMap[alg],
+            });
 
             if (opaqueBg) {
-                const newImage = await Jimp.read(width, height, 0x000000FF);
-                newImage.blit(image, 0, 0);
-                image = newImage;
+                const newImage = new Jimp({
+                    width,
+                    height,
+                    color: 0x000000ff,
+                });
+                image = newImage.blit({
+                    src: image,
+                    x: 0,
+                    y: 0,
+                });
             }
 
             let imageBuffer;
-            if (image.getMIME() === "image/gif") {
-                imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG);
+            if (originalMime === "image/gif") {
+                imageBuffer = await image.getBuffer(JimpMime.png);
             } else {
-                imageBuffer = await image.getBufferAsync(Jimp.AUTO);
+                imageBuffer = await image.getBuffer(originalMime);
             }
             return imageBuffer.buffer;
         } catch (err) {
@@ -156,7 +167,6 @@ class ContainImage extends Operation {
 
         return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
     }
-
 }
 
 export default ContainImage;

package/src/core/operations/ConvertImageFormat.mjs

@@ -8,13 +8,12 @@ import Operation from "../Operation.mjs";
 import OperationError from "../errors/OperationError.mjs";
 import { isImage } from "../lib/FileType.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
-import Jimp from "jimp/es/index.js";
+import { Jimp, JimpMime, PNGFilterType } from "jimp";
 
 /**
  * Convert Image Format operation
  */
 class ConvertImageFormat extends Operation {
-
     /**
      * ConvertImageFormat constructor
      */
@@ -23,7 +22,8 @@ class ConvertImageFormat extends Operation {
 
         this.name = "Convert Image Format";
         this.module = "Image";
-        this.description = "Converts an image between different formats. Supported formats:<br><ul><li>Joint Photographic Experts Group (JPEG)</li><li>Portable Network Graphics (PNG)</li><li>Bitmap (BMP)</li><li>Tagged Image File Format (TIFF)</li></ul><br>Note: GIF files are supported for input, but cannot be outputted.";
+        this.description =
+            "Converts an image between different formats. Supported formats:<br><ul><li>Joint Photographic Experts Group (JPEG)</li><li>Portable Network Graphics (PNG)</li><li>Bitmap (BMP)</li><li>Tagged Image File Format (TIFF)</li></ul><br>Note: GIF files are supported for input, but cannot be outputted.";
         this.infoURL = "https://wikipedia.org/wiki/Image_file_formats";
         this.inputType = "ArrayBuffer";
         this.outputType = "ArrayBuffer";
@@ -32,39 +32,27 @@ class ConvertImageFormat extends Operation {
             {
                 name: "Output Format",
                 type: "option",
-                value: [
-                    "JPEG",
-                    "PNG",
-                    "BMP",
-                    "TIFF"
-                ]
+                value: ["JPEG", "PNG", "BMP", "TIFF"],
             },
             {
                 name: "JPEG Quality",
                 type: "number",
                 value: 80,
                 min: 1,
-                max: 100
+                max: 100,
             },
             {
                 name: "PNG Filter Type",
                 type: "option",
-                value: [
-                    "Auto",
-                    "None",
-                    "Sub",
-                    "Up",
-                    "Average",
-                    "Paeth"
-                ]
+                value: ["Auto", "None", "Sub", "Up", "Average", "Paeth"],
             },
             {
                 name: "PNG Deflate Level",
                 type: "number",
                 value: 9,
                 min: 0,
-                max: 9
-            }
+                max: 9,
+            },
         ];
     }
 
@@ -76,19 +64,19 @@ class ConvertImageFormat extends Operation {
     async run(input, args) {
         const [format, jpegQuality, pngFilterType, pngDeflateLevel] = args;
         const formatMap = {
-            "JPEG": Jimp.MIME_JPEG,
-            "PNG": Jimp.MIME_PNG,
-            "BMP": Jimp.MIME_BMP,
-            "TIFF": Jimp.MIME_TIFF
+            JPEG: JimpMime.jpeg,
+            PNG: JimpMime.png,
+            BMP: JimpMime.bmp,
+            TIFF: JimpMime.tiff,
         };
 
         const pngFilterMap = {
-            "Auto": Jimp.PNG_FILTER_AUTO,
-            "None": Jimp.PNG_FILTER_NONE,
-            "Sub": Jimp.PNG_FILTER_SUB,
-            "Up": Jimp.PNG_FILTER_UP,
-            "Average": Jimp.PNG_FILTER_AVERAGE,
-            "Paeth": Jimp.PNG_FILTER_PATH
+            Auto: PNGFilterType.AUTO,
+            None: PNGFilterType.NONE,
+            Sub: PNGFilterType.SUB,
+            Up: PNGFilterType.UP,
+            Average: PNGFilterType.AVERAGE,
+            Paeth: PNGFilterType.PATH,
         };
 
         const mime = formatMap[format];
@@ -103,18 +91,25 @@ class ConvertImageFormat extends Operation {
             throw new OperationError(`Error opening image file. (${err})`);
         }
         try {
-            switch (format) {
-                case "JPEG":
-                    image.quality(jpegQuality);
+            let buffer;
+            switch (mime) {
+                case JimpMime.jpeg:
+                    buffer = await image.getBuffer(mime, {
+                        quality: jpegQuality,
+                    });
                     break;
-                case "PNG":
-                    image.filterType(pngFilterMap[pngFilterType]);
-                    image.deflateLevel(pngDeflateLevel);
+                case JimpMime.png:
+                    buffer = await image.getBuffer(mime, {
+                        filterType: pngFilterMap[pngFilterType],
+                        deflateLevel: pngDeflateLevel,
+                    });
+                    break;
+                default:
+                    buffer = await image.getBuffer(mime);
                     break;
             }
 
-            const imageBuffer = await image.getBufferAsync(mime);
-            return imageBuffer.buffer;
+            return buffer.buffer;
         } catch (err) {
             throw new OperationError(`Error converting image format. (${err})`);
         }
@@ -137,7 +132,6 @@ class ConvertImageFormat extends Operation {
 
         return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
     }
-
 }
 
 export default ConvertImageFormat;

package/src/core/operations/CoverImage.mjs

@@ -9,13 +9,18 @@ import OperationError from "../errors/OperationError.mjs";
 import { isImage } from "../lib/FileType.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
 import { isWorkerEnvironment } from "../Utils.mjs";
-import jimp from "jimp/es/index.js";
+import {
+    Jimp,
+    JimpMime,
+    ResizeStrategy,
+    HorizontalAlign,
+    VerticalAlign,
+} from "jimp";
 
 /**
  * Cover Image operation
  */
 class CoverImage extends Operation {
-
     /**
      * CoverImage constructor
      */
@@ -24,7 +29,8 @@ class CoverImage extends Operation {
 
         this.name = "Cover Image";
         this.module = "Image";
-        this.description = "Scales the image to the given width and height, keeping the aspect ratio. The image may be clipped.";
+        this.description =
+            "Scales the image to the given width and height, keeping the aspect ratio. The image may be clipped.";
         this.infoURL = "";
         this.inputType = "ArrayBuffer";
         this.outputType = "ArrayBuffer";
@@ -34,33 +40,25 @@ class CoverImage extends Operation {
                 name: "Width",
                 type: "number",
                 value: 100,
-                min: 1
+                min: 1,
             },
             {
                 name: "Height",
                 type: "number",
                 value: 100,
-                min: 1
+                min: 1,
             },
             {
                 name: "Horizontal align",
                 type: "option",
-                value: [
-                    "Left",
-                    "Center",
-                    "Right"
-                ],
-                defaultIndex: 1
+                value: ["Left", "Center", "Right"],
+                defaultIndex: 1,
             },
             {
                 name: "Vertical align",
                 type: "option",
-                value: [
-                    "Top",
-                    "Middle",
-                    "Bottom"
-                ],
-                defaultIndex: 1
+                value: ["Top", "Middle", "Bottom"],
+                defaultIndex: 1,
             },
             {
                 name: "Resizing algorithm",
@@ -70,10 +68,10 @@ class CoverImage extends Operation {
                     "Bilinear",
                     "Bicubic",
                     "Hermite",
-                    "Bezier"
+                    "Bezier",
                 ],
-                defaultIndex: 1
-            }
+                defaultIndex: 1,
+            },
         ];
     }
 
@@ -86,20 +84,20 @@ class CoverImage extends Operation {
         const [width, height, hAlign, vAlign, alg] = args;
 
         const resizeMap = {
-            "Nearest Neighbour": jimp.RESIZE_NEAREST_NEIGHBOR,
-            "Bilinear": jimp.RESIZE_BILINEAR,
-            "Bicubic": jimp.RESIZE_BICUBIC,
-            "Hermite": jimp.RESIZE_HERMITE,
-            "Bezier": jimp.RESIZE_BEZIER
+            "Nearest Neighbour": ResizeStrategy.NEAREST_NEIGHBOR,
+            Bilinear: ResizeStrategy.BILINEAR,
+            Bicubic: ResizeStrategy.BICUBIC,
+            Hermite: ResizeStrategy.HERMITE,
+            Bezier: ResizeStrategy.BEZIER,
         };
 
         const alignMap = {
-            "Left": jimp.HORIZONTAL_ALIGN_LEFT,
-            "Center": jimp.HORIZONTAL_ALIGN_CENTER,
-            "Right": jimp.HORIZONTAL_ALIGN_RIGHT,
-            "Top": jimp.VERTICAL_ALIGN_TOP,
-            "Middle": jimp.VERTICAL_ALIGN_MIDDLE,
-            "Bottom": jimp.VERTICAL_ALIGN_BOTTOM
+            Left: HorizontalAlign.LEFT,
+            Center: HorizontalAlign.CENTER,
+            Right: HorizontalAlign.RIGHT,
+            Top: VerticalAlign.TOP,
+            Middle: VerticalAlign.MIDDLE,
+            Bottom: VerticalAlign.BOTTOM,
         };
 
         if (!isImage(input)) {
@@ -108,19 +106,24 @@ class CoverImage extends Operation {
 
         let image;
         try {
-            image = await jimp.read(input);
+            image = await Jimp.read(input);
         } catch (err) {
             throw new OperationError(`Error loading image. (${err})`);
         }
         try {
             if (isWorkerEnvironment())
                 self.sendStatusMessage("Covering image...");
-            image.cover(width, height, alignMap[hAlign] | alignMap[vAlign], resizeMap[alg]);
+            image.cover({
+                w: width,
+                h: height,
+                align: alignMap[hAlign] | alignMap[vAlign],
+                mode: resizeMap[alg],
+            });
             let imageBuffer;
-            if (image.getMIME() === "image/gif") {
-                imageBuffer = await image.getBufferAsync(jimp.MIME_PNG);
+            if (image.mime === "image/gif") {
+                imageBuffer = await image.getBuffer(JimpMime.png);
             } else {
-                imageBuffer = await image.getBufferAsync(jimp.AUTO);
+                imageBuffer = await image.getBuffer(image.mime);
             }
             return imageBuffer.buffer;
         } catch (err) {
@@ -144,7 +147,6 @@ class CoverImage extends Operation {
 
         return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
     }
-
 }
 
 export default CoverImage;

package/src/core/operations/CropImage.mjs

@@ -9,13 +9,12 @@ import OperationError from "../errors/OperationError.mjs";
 import { isImage } from "../lib/FileType.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
 import { isWorkerEnvironment } from "../Utils.mjs";
-import Jimp from "jimp/es/index.js";
+import { Jimp, JimpMime } from "jimp";
 
 /**
  * Crop Image operation
  */
 class CropImage extends Operation {
-
     /**
      * CropImage constructor
      */
@@ -24,7 +23,8 @@ class CropImage extends Operation {
 
         this.name = "Crop Image";
         this.module = "Image";
-        this.description = "Crops an image to the specified region, or automatically crops edges.<br><br><b><u>Autocrop</u></b><br>Automatically crops same-colour borders from the image.<br><br><u>Autocrop tolerance</u><br>A percentage value for the tolerance of colour difference between pixels.<br><br><u>Only autocrop frames</u><br>Only crop real frames (all sides must have the same border)<br><br><u>Symmetric autocrop</u><br>Force autocrop to be symmetric (top/bottom and left/right are cropped by the same amount)<br><br><u>Autocrop keep border</u><br>The number of pixels of border to leave around the image.";
+        this.description =
+            "Crops an image to the specified region, or automatically crops edges.<br><br><b><u>Autocrop</u></b><br>Automatically crops same-colour borders from the image.<br><br><u>Autocrop tolerance</u><br>A percentage value for the tolerance of colour difference between pixels.<br><br><u>Only autocrop frames</u><br>Only crop real frames (all sides must have the same border)<br><br><u>Symmetric autocrop</u><br>Force autocrop to be symmetric (top/bottom and left/right are cropped by the same amount)<br><br><u>Autocrop keep border</u><br>The number of pixels of border to leave around the image.";
         this.infoURL = "https://wikipedia.org/wiki/Cropping_(image)";
         this.inputType = "ArrayBuffer";
         this.outputType = "ArrayBuffer";
@@ -34,30 +34,30 @@ class CropImage extends Operation {
                 name: "X Position",
                 type: "number",
                 value: 0,
-                min: 0
+                min: 0,
             },
             {
                 name: "Y Position",
                 type: "number",
                 value: 0,
-                min: 0
+                min: 0,
             },
             {
                 name: "Width",
                 type: "number",
                 value: 10,
-                min: 1
+                min: 1,
             },
             {
                 name: "Height",
                 type: "number",
                 value: 10,
-                min: 1
+                min: 1,
             },
             {
                 name: "Autocrop",
                 type: "boolean",
-                value: false
+                value: false,
             },
             {
                 name: "Autocrop tolerance (%)",
@@ -65,24 +65,24 @@ class CropImage extends Operation {
                 value: 0.02,
                 min: 0,
                 max: 100,
-                step: 0.01
+                step: 0.01,
             },
             {
                 name: "Only autocrop frames",
                 type: "boolean",
-                value: true
+                value: true,
             },
             {
                 name: "Symmetric autocrop",
                 type: "boolean",
-                value: false
+                value: false,
             },
             {
                 name: "Autocrop keep border (px)",
                 type: "number",
                 value: 0,
-                min: 0
-            }
+                min: 0,
+            },
         ];
     }
 
@@ -92,7 +92,17 @@ class CropImage extends Operation {
      * @returns {byteArray}
      */
     async run(input, args) {
-        const [xPos, yPos, width, height, autocrop, autoTolerance, autoFrames, autoSymmetric, autoBorder] = args;
+        const [
+            xPos,
+            yPos,
+            width,
+            height,
+            autocrop,
+            autoTolerance,
+            autoFrames,
+            autoSymmetric,
+            autoBorder,
+        ] = args;
         if (!isImage(input)) {
             throw new OperationError("Invalid file type.");
         }
@@ -108,20 +118,25 @@ class CropImage extends Operation {
                 self.sendStatusMessage("Cropping image...");
             if (autocrop) {
                 image.autocrop({
-                    tolerance: (autoTolerance / 100),
+                    tolerance: autoTolerance / 100,
                     cropOnlyFrames: autoFrames,
                     cropSymmetric: autoSymmetric,
-                    leaveBorder: autoBorder
+                    leaveBorder: autoBorder,
                 });
             } else {
-                image.crop(xPos, yPos, width, height);
+                image.crop({
+                    x: xPos,
+                    y: yPos,
+                    w: width,
+                    h: height,
+                });
             }
 
             let imageBuffer;
-            if (image.getMIME() === "image/gif") {
-                imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG);
+            if (image.mime === "image/gif") {
+                imageBuffer = await image.getBuffer(JimpMime.png);
             } else {
-                imageBuffer = await image.getBufferAsync(Jimp.AUTO);
+                imageBuffer = await image.getBuffer(image.mime);
             }
             return imageBuffer.buffer;
         } catch (err) {
@@ -145,7 +160,6 @@ class CropImage extends Operation {
 
         return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
     }
-
 }
 
 export default CropImage;