cyberchef 10.22.1 → 10.23.0

package/src/core/operations/AddTextToImage.mjs

@@ -9,13 +9,19 @@ 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,
+    measureText,
+    measureTextHeight,
+    loadFont,
+} from "jimp";
 
 /**
  * Add Text To Image operation
  */
 class AddTextToImage extends Operation {
-
     /**
      * AddTextToImage constructor
      */
@@ -24,7 +30,8 @@ class AddTextToImage extends Operation {
 
         this.name = "Add Text To Image";
         this.module = "Image";
-        this.description = "Adds text onto an image.<br><br>Text can be horizontally or vertically aligned, or the position can be manually specified.<br>Variants of the Roboto font face are available in any size or colour.";
+        this.description =
+            "Adds text onto an image.<br><br>Text can be horizontally or vertically aligned, or the position can be manually specified.<br>Variants of the Roboto font face are available in any size or colour.";
         this.infoURL = "";
         this.inputType = "ArrayBuffer";
         this.outputType = "ArrayBuffer";
@@ -33,72 +40,67 @@ class AddTextToImage extends Operation {
             {
                 name: "Text",
                 type: "string",
-                value: ""
+                value: "",
             },
             {
                 name: "Horizontal align",
                 type: "option",
-                value: ["None", "Left", "Center", "Right"]
+                value: ["None", "Left", "Center", "Right"],
             },
             {
                 name: "Vertical align",
                 type: "option",
-                value: ["None", "Top", "Middle", "Bottom"]
+                value: ["None", "Top", "Middle", "Bottom"],
             },
             {
                 name: "X position",
                 type: "number",
-                value: 0
+                value: 0,
             },
             {
                 name: "Y position",
                 type: "number",
-                value: 0
+                value: 0,
             },
             {
                 name: "Size",
                 type: "number",
                 value: 32,
-                min: 8
+                min: 8,
             },
             {
                 name: "Font face",
                 type: "option",
-                value: [
-                    "Roboto",
-                    "Roboto Black",
-                    "Roboto Mono",
-                    "Roboto Slab"
-                ]
+                value: ["Roboto", "Roboto Black", "Roboto Mono", "Roboto Slab"],
             },
             {
                 name: "Red",
                 type: "number",
                 value: 255,
                 min: 0,
-                max: 255
+                max: 255,
             },
             {
                 name: "Green",
                 type: "number",
                 value: 255,
                 min: 0,
-                max: 255
+                max: 255,
             },
             {
                 name: "Blue",
                 type: "number",
                 value: 255,
                 min: 0,
-                max: 255
+                max: 255,
             },
             {
                 name: "Alpha",
                 type: "number",
                 value: 255,
                 min: 0,
-                max: 255
-            }
+                max: 255,
+            },
         ];
     }
 
@@ -131,41 +133,60 @@ class AddTextToImage extends Operation {
         } catch (err) {
             throw new OperationError(`Error loading image. (${err})`);
         }
-        try {
-            if (isWorkerEnvironment())
-                self.sendStatusMessage("Adding text to image...");
 
-            const fontsMap = {};
+        if (isWorkerEnvironment())
+            self.sendStatusMessage("Adding text to image...");
+
+        const fontsMap = {};
+        try {
             const fonts = [
-                import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/Roboto72White.fnt"),
-                import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoBlack72White.fnt"),
-                import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoMono72White.fnt"),
-                import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoSlab72White.fnt")
+                import(
+                    /* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/Roboto72White.fnt"
+                ),
+                import(
+                    /* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoBlack72White.fnt"
+                ),
+                import(
+                    /* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoMono72White.fnt"
+                ),
+                import(
+                    /* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoSlab72White.fnt"
+                ),
             ];
 
-            await Promise.all(fonts)
-                .then(fonts => {
-                    fontsMap.Roboto = fonts[0];
-                    fontsMap["Roboto Black"] = fonts[1];
-                    fontsMap["Roboto Mono"] = fonts[2];
-                    fontsMap["Roboto Slab"] = fonts[3];
-                });
-
-
+            await Promise.all(fonts).then((fonts) => {
+                fontsMap.Roboto = fonts[0];
+                fontsMap["Roboto Black"] = fonts[1];
+                fontsMap["Roboto Mono"] = fonts[2];
+                fontsMap["Roboto Slab"] = fonts[3];
+            });
             // Make Webpack load the png font images
             await Promise.all([
-                import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/Roboto72White.png"),
-                import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoSlab72White.png"),
-                import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoMono72White.png"),
-                import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoBlack72White.png")
+                import(
+                    /* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/Roboto72White.png"
+                ),
+                import(
+                    /* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoSlab72White.png"
+                ),
+                import(
+                    /* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoMono72White.png"
+                ),
+                import(
+                    /* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoBlack72White.png"
+                ),
             ]);
+        } catch (err) {
+            throw new OperationError(`Error preparing fonts. (${err})`);
+        }
 
+        let jimpFont;
+        try {
             const font = fontsMap[fontFace];
 
             // LoadFont needs an absolute url, so append the font name to self.docURL
-            const jimpFont = await Jimp.loadFont(self.docURL + "/" + font.default);
+            jimpFont = await loadFont(self.docURL + "/" + font.default);
 
-            jimpFont.pages.forEach(function(page) {
+            jimpFont.pages.forEach(function (page) {
                 if (page.bitmap) {
                     // Adjust the RGB values of the image pages to change the font colour.
                     const pageWidth = page.bitmap.width;
@@ -175,32 +196,56 @@ class AddTextToImage extends Operation {
                             const idx = (iy * pageWidth + ix) << 2;
 
                             const newRed = page.bitmap.data[idx] - (255 - red);
-                            const newGreen = page.bitmap.data[idx + 1] - (255 - green);
-                            const newBlue = page.bitmap.data[idx + 2] - (255 - blue);
-                            const newAlpha = page.bitmap.data[idx + 3] - (255 - alpha);
+                            const newGreen =
+                                page.bitmap.data[idx + 1] - (255 - green);
+                            const newBlue =
+                                page.bitmap.data[idx + 2] - (255 - blue);
+                            const newAlpha =
+                                page.bitmap.data[idx + 3] - (255 - alpha);
 
                             // Make sure the bitmap values don't go below 0 as that makes jimp very unhappy
-                            page.bitmap.data[idx] = (newRed > 0) ? newRed : 0;
-                            page.bitmap.data[idx + 1] = (newGreen > 0) ? newGreen : 0;
-                            page.bitmap.data[idx + 2] = (newBlue > 0) ? newBlue : 0;
-                            page.bitmap.data[idx + 3] = (newAlpha > 0) ? newAlpha : 0;
+                            page.bitmap.data[idx] = newRed > 0 ? newRed : 0;
+                            page.bitmap.data[idx + 1] =
+                                newGreen > 0 ? newGreen : 0;
+                            page.bitmap.data[idx + 2] =
+                                newBlue > 0 ? newBlue : 0;
+                            page.bitmap.data[idx + 3] =
+                                newAlpha > 0 ? newAlpha : 0;
                         }
                     }
                 }
             });
+        } catch (err) {
+            throw new OperationError(`Error loading font. (${err})`);
+        }
 
+        try {
             // Create a temporary image to hold the rendered text
-            const textImage = new Jimp(Jimp.measureText(jimpFont, text), Jimp.measureTextHeight(jimpFont, text));
-            textImage.print(jimpFont, 0, 0, text);
+            const textImage = new Jimp({
+                width: measureText(jimpFont, text),
+                height: measureTextHeight(jimpFont, text),
+            });
+            textImage.print({
+                font: jimpFont,
+                x: 0,
+                y: 0,
+                text,
+            });
 
             // Scale the rendered text image to the correct size
             const scaleFactor = size / 72;
             if (size !== 1) {
                 // Use bicubic for decreasing size
                 if (size > 1) {
-                    textImage.scale(scaleFactor, Jimp.RESIZE_BICUBIC);
+                    textImage.scale({
+                        f: scaleFactor,
+                        mode: ResizeStrategy.BICUBIC,
+                    });
                 } else {
-                    textImage.scale(scaleFactor, Jimp.RESIZE_BILINEAR);
+                    textImage.scale({
+                        f: scaleFactor,
+                        mode: ResizeStrategy.BILINEAR,
+                    });
                 }
             }
 
@@ -210,10 +255,10 @@ class AddTextToImage extends Operation {
                     xPos = 0;
                     break;
                 case "Center":
-                    xPos = (image.getWidth() / 2) - (textImage.getWidth() / 2);
+                    xPos = image.width / 2 - textImage.width / 2;
                     break;
                 case "Right":
-                    xPos = image.getWidth() - textImage.getWidth();
+                    xPos = image.width - textImage.width;
                     break;
             }
 
@@ -222,25 +267,33 @@ class AddTextToImage extends Operation {
                     yPos = 0;
                     break;
                 case "Middle":
-                    yPos = (image.getHeight() / 2) - (textImage.getHeight() / 2);
+                    yPos = image.height / 2 - textImage.height / 2;
                     break;
                 case "Bottom":
-                    yPos = image.getHeight() - textImage.getHeight();
+                    yPos = image.height - textImage.height;
                     break;
             }
 
             // Blit the rendered text image onto the original source image
-            image.blit(textImage, xPos, yPos);
+            image.blit({
+                src: textImage,
+                x: xPos,
+                y: yPos,
+            });
+        } catch (err) {
+            throw new OperationError(`Error adding text to image. (${err})`);
+        }
 
+        try {
             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) {
-            throw new OperationError(`Error adding text to image. (${err})`);
+            throw new OperationError(`Error exporting image. (${err})`);
         }
     }
 
@@ -261,7 +314,6 @@ class AddTextToImage extends Operation {
 
         return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
     }
-
 }
 
 export default AddTextToImage;

package/src/core/operations/BlurImage.mjs

@@ -9,14 +9,12 @@ import OperationError from "../errors/OperationError.mjs";
 import { isWorkerEnvironment } from "../Utils.mjs";
 import { isImage } from "../lib/FileType.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
-import { gaussianBlur } from "../lib/ImageManipulation.mjs";
-import Jimp from "jimp/es/index.js";
+import { Jimp, JimpMime } from "jimp";
 
 /**
  * Blur Image operation
  */
 class BlurImage extends Operation {
-
     /**
      * BlurImage constructor
      */
@@ -25,7 +23,8 @@ class BlurImage extends Operation {
 
         this.name = "Blur Image";
         this.module = "Image";
-        this.description = "Applies a blur effect to the image.<br><br>Gaussian blur is much slower than fast blur, but produces better results.";
+        this.description =
+            "Applies a blur effect to the image.<br><br>Gaussian blur is much slower than fast blur, but produces better results.";
         this.infoURL = "https://wikipedia.org/wiki/Gaussian_blur";
         this.inputType = "ArrayBuffer";
         this.outputType = "ArrayBuffer";
@@ -35,13 +34,13 @@ class BlurImage extends Operation {
                 name: "Amount",
                 type: "number",
                 value: 5,
-                min: 1
+                min: 1,
             },
             {
                 name: "Type",
                 type: "option",
-                value: ["Fast", "Gaussian"]
-            }
+                value: ["Fast", "Gaussian"],
+            },
         ];
     }
 
@@ -73,15 +72,15 @@ class BlurImage extends Operation {
                 case "Gaussian":
                     if (isWorkerEnvironment())
                         self.sendStatusMessage("Gaussian blurring image...");
-                    image = gaussianBlur(image, blurAmount);
+                    image.gaussian(blurAmount);
                     break;
             }
 
             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) {
@@ -106,7 +105,6 @@ class BlurImage extends Operation {
 
         return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
     }
-
 }
 
 export default BlurImage;

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;