cyberchef 10.22.0 → 10.23.0

package/src/core/operations/RandomizeColourPalette.mjs

@@ -10,13 +10,12 @@ import Utils from "../Utils.mjs";
 import { isImage } from "../lib/FileType.mjs";
 import { runHash } from "../lib/Hash.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
-import Jimp from "jimp/es/index.js";
+import { Jimp } from "jimp";
 
 /**
  * Randomize Colour Palette operation
  */
 class RandomizeColourPalette extends Operation {
-
     /**
      * RandomizeColourPalette constructor
      */
@@ -25,7 +24,8 @@ class RandomizeColourPalette extends Operation {
 
         this.name = "Randomize Colour Palette";
         this.module = "Image";
-        this.description = "Randomizes each colour in an image's colour palette. This can often reveal text or symbols that were previously a very similar colour to their surroundings, a technique sometimes used in Steganography.";
+        this.description =
+            "Randomizes each colour in an image's colour palette. This can often reveal text or symbols that were previously a very similar colour to their surroundings, a technique sometimes used in Steganography.";
         this.infoURL = "https://wikipedia.org/wiki/Indexed_color";
         this.inputType = "ArrayBuffer";
         this.outputType = "ArrayBuffer";
@@ -34,8 +34,8 @@ class RandomizeColourPalette extends Operation {
             {
                 name: "Seed",
                 type: "string",
-                value: ""
-            }
+                value: "",
+            },
         ];
     }
 
@@ -45,23 +45,24 @@ class RandomizeColourPalette extends Operation {
      * @returns {ArrayBuffer}
      */
     async run(input, args) {
-        if (!isImage(input)) throw new OperationError("Please enter a valid image file.");
+        if (!isImage(input))
+            throw new OperationError("Please enter a valid image file.");
 
-        const seed = args[0] || (Math.random().toString().substr(2)),
+        const seed = args[0] || Math.random().toString().substr(2),
             parsedImage = await Jimp.read(input),
             width = parsedImage.bitmap.width,
             height = parsedImage.bitmap.height;
 
         let rgbString, rgbHash, rgbHex;
 
-        parsedImage.scan(0, 0, width, height, function(x, y, idx) {
-            rgbString = this.bitmap.data.slice(idx, idx+3).join(".");
+        parsedImage.scan(0, 0, width, height, function (x, y, idx) {
+            rgbString = this.bitmap.data.slice(idx, idx + 3).join(".");
             rgbHash = runHash("md5", Utils.strToArrayBuffer(seed + rgbString));
             rgbHex = rgbHash.substr(0, 6) + "ff";
             parsedImage.setPixelColor(parseInt(rgbHex, 16), x, y);
         });
 
-        const imageBuffer = await parsedImage.getBufferAsync(Jimp.AUTO);
+        const imageBuffer = await parsedImage.getBuffer(parsedImage.mime);
 
         return new Uint8Array(imageBuffer).buffer;
     }
@@ -77,7 +78,6 @@ class RandomizeColourPalette extends Operation {
 
         return `<img src="data:${type};base64,${toBase64(data)}">`;
     }
-
 }
 
 export default RandomizeColourPalette;

package/src/core/operations/ResizeImage.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, ResizeStrategy } from "jimp";
 
 /**
  * Resize Image operation
  */
 class ResizeImage extends Operation {
-
     /**
      * ResizeImage constructor
      */
@@ -24,7 +23,8 @@ class ResizeImage extends Operation {
 
         this.name = "Resize Image";
         this.module = "Image";
-        this.description = "Resizes an image to the specified width and height values.";
+        this.description =
+            "Resizes an image to the specified width and height values.";
         this.infoURL = "https://wikipedia.org/wiki/Image_scaling";
         this.inputType = "ArrayBuffer";
         this.outputType = "ArrayBuffer";
@@ -34,23 +34,23 @@ class ResizeImage extends Operation {
                 name: "Width",
                 type: "number",
                 value: 100,
-                min: 1
+                min: 1,
             },
             {
                 name: "Height",
                 type: "number",
                 value: 100,
-                min: 1
+                min: 1,
             },
             {
                 name: "Unit type",
                 type: "option",
-                value: ["Pixels", "Percent"]
+                value: ["Pixels", "Percent"],
             },
             {
                 name: "Maintain aspect ratio",
                 type: "boolean",
-                value: false
+                value: false,
             },
             {
                 name: "Resizing algorithm",
@@ -60,10 +60,10 @@ class ResizeImage extends Operation {
                     "Bilinear",
                     "Bicubic",
                     "Hermite",
-                    "Bezier"
+                    "Bezier",
                 ],
-                defaultIndex: 1
-            }
+                defaultIndex: 1,
+            },
         ];
     }
 
@@ -80,11 +80,11 @@ class ResizeImage extends Operation {
             resizeAlg = args[4];
 
         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,
         };
 
         if (!isImage(input)) {
@@ -99,23 +99,31 @@ class ResizeImage extends Operation {
         }
         try {
             if (unit === "Percent") {
-                width = image.getWidth() * (width / 100);
-                height = image.getHeight() * (height / 100);
+                width = image.width * (width / 100);
+                height = image.height * (height / 100);
             }
 
             if (isWorkerEnvironment())
                 self.sendStatusMessage("Resizing image...");
             if (aspect) {
-                image.scaleToFit(width, height, resizeMap[resizeAlg]);
+                image.scaleToFit({
+                    w: width,
+                    h: height,
+                    mode: resizeMap[resizeAlg],
+                });
             } else {
-                image.resize(width, height, resizeMap[resizeAlg]);
+                image.resize({
+                    w: width,
+                    h: height,
+                    mode: resizeMap[resizeAlg],
+                });
             }
 
             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) {
@@ -139,7 +147,6 @@ class ResizeImage extends Operation {
 
         return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
     }
-
 }
 
 export default ResizeImage;

package/src/core/operations/RotateImage.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";
 
 /**
  * Rotate Image operation
  */
 class RotateImage extends Operation {
-
     /**
      * RotateImage constructor
      */
@@ -24,7 +23,8 @@ class RotateImage extends Operation {
 
         this.name = "Rotate Image";
         this.module = "Image";
-        this.description = "Rotates an image by the specified number of degrees.";
+        this.description =
+            "Rotates an image by the specified number of degrees.";
         this.infoURL = "";
         this.inputType = "ArrayBuffer";
         this.outputType = "ArrayBuffer";
@@ -33,8 +33,8 @@ class RotateImage extends Operation {
             {
                 name: "Rotation amount (degrees)",
                 type: "number",
-                value: 90
-            }
+                value: 90,
+            },
         ];
     }
 
@@ -62,10 +62,10 @@ class RotateImage extends Operation {
             image.rotate(degrees);
 
             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) {
@@ -89,7 +89,6 @@ class RotateImage extends Operation {
 
         return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
     }
-
 }
 
 export default RotateImage;

package/src/core/operations/SQLBeautify.mjs

@@ -3,8 +3,7 @@
  * @copyright Crown Copyright 2016
  * @license Apache-2.0
  */
-
-import vkbeautify from "vkbeautify";
+import { format } from "sql-formatter";
 import Operation from "../Operation.mjs";
 
 /**
@@ -39,7 +38,26 @@ class SQLBeautify extends Operation {
      */
     run(input, args) {
         const indentStr = args[0];
-        return vkbeautify.sql(input, indentStr);
+        // Extract and replace bind variables like :Bind1 with __BIND_0__
+        const bindRegex = /:\w+/g;
+        const bindMap = {};
+        let bindCounter=0;
+        const placeholderInput = input.replace(bindRegex, (match) => {
+            const placeholder = `__BIND_${bindCounter++}__`;
+            bindMap[placeholder] = match;
+            return placeholder;
+        });
+        // Format the SQL with chosen options
+        let formatted= format(placeholderInput, {
+            language: "mysql", // Use MySQL as the default dialect for better compatibility with real-world SQL
+            useTabs: indentStr==="\t", // true if tab, false if spaces
+            tabWidth: indentStr.length || 4,     // fallback if empty
+            indentStyle: "standard"              // fine for most SQL
+        });
+        // Replace placeholders back with original bind variables
+        formatted = formatted.replace(/__BIND_\d+__/g, match => bindMap[match] || match);
+
+        return formatted;
     }
 
 }

package/src/core/operations/SharpenImage.mjs

@@ -8,15 +8,13 @@ import Operation from "../Operation.mjs";
 import OperationError from "../errors/OperationError.mjs";
 import { isImage } from "../lib/FileType.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
-import { gaussianBlur } from "../lib/ImageManipulation.mjs";
 import { isWorkerEnvironment } from "../Utils.mjs";
-import Jimp from "jimp/es/index.js";
+import { Jimp, JimpMime } from "jimp";
 
 /**
  * Sharpen Image operation
  */
 class SharpenImage extends Operation {
-
     /**
      * SharpenImage constructor
      */
@@ -35,22 +33,22 @@ class SharpenImage extends Operation {
                 name: "Radius",
                 type: "number",
                 value: 2,
-                min: 1
+                min: 1,
             },
             {
                 name: "Amount",
                 type: "number",
                 value: 1,
                 min: 0,
-                step: 0.1
+                step: 0.1,
             },
             {
                 name: "Threshold",
                 type: "number",
                 value: 10,
                 min: 0,
-                max: 100
-            }
+                max: 100,
+            },
         ];
     }
 
@@ -79,67 +77,102 @@ class SharpenImage extends Operation {
             const blurMask = image.clone();
 
             if (isWorkerEnvironment())
-                self.sendStatusMessage("Sharpening image... (Blurring cloned image)");
-            const blurImage = gaussianBlur(image.clone(), radius);
-
+                self.sendStatusMessage(
+                    "Sharpening image... (Blurring cloned image)",
+                );
+            const blurImage = image.clone().gaussian(radius);
 
             if (isWorkerEnvironment())
-                self.sendStatusMessage("Sharpening image... (Creating unsharp mask)");
-            blurMask.scan(0, 0, blurMask.bitmap.width, blurMask.bitmap.height, function(x, y, idx) {
-                const blurRed = blurImage.bitmap.data[idx];
-                const blurGreen = blurImage.bitmap.data[idx + 1];
-                const blurBlue = blurImage.bitmap.data[idx + 2];
-
-                const normalRed = this.bitmap.data[idx];
-                const normalGreen = this.bitmap.data[idx + 1];
-                const normalBlue = this.bitmap.data[idx + 2];
-
-                // Subtract blurred pixel value from normal image
-                this.bitmap.data[idx] = (normalRed > blurRed) ? normalRed - blurRed : 0;
-                this.bitmap.data[idx + 1] = (normalGreen > blurGreen) ? normalGreen - blurGreen : 0;
-                this.bitmap.data[idx + 2] = (normalBlue > blurBlue) ? normalBlue - blurBlue : 0;
-            });
+                self.sendStatusMessage(
+                    "Sharpening image... (Creating unsharp mask)",
+                );
+            blurMask.scan(
+                0,
+                0,
+                blurMask.bitmap.width,
+                blurMask.bitmap.height,
+                function (x, y, idx) {
+                    const blurRed = blurImage.bitmap.data[idx];
+                    const blurGreen = blurImage.bitmap.data[idx + 1];
+                    const blurBlue = blurImage.bitmap.data[idx + 2];
+
+                    const normalRed = this.bitmap.data[idx];
+                    const normalGreen = this.bitmap.data[idx + 1];
+                    const normalBlue = this.bitmap.data[idx + 2];
+
+                    // Subtract blurred pixel value from normal image
+                    this.bitmap.data[idx] =
+                        normalRed > blurRed ? normalRed - blurRed : 0;
+                    this.bitmap.data[idx + 1] =
+                        normalGreen > blurGreen ? normalGreen - blurGreen : 0;
+                    this.bitmap.data[idx + 2] =
+                        normalBlue > blurBlue ? normalBlue - blurBlue : 0;
+                },
+            );
 
             if (isWorkerEnvironment())
-                self.sendStatusMessage("Sharpening image... (Merging with unsharp mask)");
-            image.scan(0, 0, image.bitmap.width, image.bitmap.height, function(x, y, idx) {
-                let maskRed = blurMask.bitmap.data[idx];
-                let maskGreen = blurMask.bitmap.data[idx + 1];
-                let maskBlue = blurMask.bitmap.data[idx + 2];
-
-                const normalRed = this.bitmap.data[idx];
-                const normalGreen = this.bitmap.data[idx + 1];
-                const normalBlue = this.bitmap.data[idx + 2];
-
-                // Calculate luminance
-                const maskLuminance = (0.2126 * maskRed + 0.7152 * maskGreen + 0.0722 * maskBlue);
-                const normalLuminance = (0.2126 * normalRed + 0.7152 * normalGreen + 0.0722 * normalBlue);
-
-                let luminanceDiff;
-                if (maskLuminance > normalLuminance) {
-                    luminanceDiff = maskLuminance - normalLuminance;
-                } else {
-                    luminanceDiff = normalLuminance - maskLuminance;
-                }
-
-                // Scale mask colours by amount
-                maskRed = maskRed * amount;
-                maskGreen = maskGreen * amount;
-                maskBlue = maskBlue * amount;
-
-                // Only change pixel value if the difference is higher than threshold
-                if ((luminanceDiff / 255) * 100 >= threshold) {
-                    this.bitmap.data[idx] = (normalRed + maskRed) <= 255 ? normalRed + maskRed : 255;
-                    this.bitmap.data[idx + 1] = (normalGreen + maskGreen) <= 255 ? normalGreen + maskGreen : 255;
-                    this.bitmap.data[idx + 2] = (normalBlue + maskBlue) <= 255 ? normalBlue + maskBlue : 255;
-                }
-            });
+                self.sendStatusMessage(
+                    "Sharpening image... (Merging with unsharp mask)",
+                );
+            image.scan(
+                0,
+                0,
+                image.bitmap.width,
+                image.bitmap.height,
+                function (x, y, idx) {
+                    let maskRed = blurMask.bitmap.data[idx];
+                    let maskGreen = blurMask.bitmap.data[idx + 1];
+                    let maskBlue = blurMask.bitmap.data[idx + 2];
+
+                    const normalRed = this.bitmap.data[idx];
+                    const normalGreen = this.bitmap.data[idx + 1];
+                    const normalBlue = this.bitmap.data[idx + 2];
+
+                    // Calculate luminance
+                    const maskLuminance =
+                        0.2126 * maskRed +
+                        0.7152 * maskGreen +
+                        0.0722 * maskBlue;
+                    const normalLuminance =
+                        0.2126 * normalRed +
+                        0.7152 * normalGreen +
+                        0.0722 * normalBlue;
+
+                    let luminanceDiff;
+                    if (maskLuminance > normalLuminance) {
+                        luminanceDiff = maskLuminance - normalLuminance;
+                    } else {
+                        luminanceDiff = normalLuminance - maskLuminance;
+                    }
+
+                    // Scale mask colours by amount
+                    maskRed = maskRed * amount;
+                    maskGreen = maskGreen * amount;
+                    maskBlue = maskBlue * amount;
+
+                    // Only change pixel value if the difference is higher than threshold
+                    if ((luminanceDiff / 255) * 100 >= threshold) {
+                        this.bitmap.data[idx] =
+                            normalRed + maskRed <= 255 ?
+                                normalRed + maskRed :
+                                255;
+                        this.bitmap.data[idx + 1] =
+                            normalGreen + maskGreen <= 255 ?
+                                normalGreen + maskGreen :
+                                255;
+                        this.bitmap.data[idx + 2] =
+                            normalBlue + maskBlue <= 255 ?
+                                normalBlue + maskBlue :
+                                255;
+                    }
+                },
+            );
 
             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) {
@@ -163,7 +196,6 @@ class SharpenImage extends Operation {
 
         return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
     }
-
 }
 
 export default SharpenImage;

package/src/core/operations/SplitColourChannels.mjs

@@ -7,14 +7,13 @@
 import Operation from "../Operation.mjs";
 import OperationError from "../errors/OperationError.mjs";
 import Utils from "../Utils.mjs";
-import {isImage} from "../lib/FileType.mjs";
-import Jimp from "jimp/es/index.js";
+import { isImage } from "../lib/FileType.mjs";
+import { Jimp, JimpMime } from "jimp";
 
 /**
  * Split Colour Channels operation
  */
 class SplitColourChannels extends Operation {
-
     /**
      * SplitColourChannels constructor
      */
@@ -23,7 +22,8 @@ class SplitColourChannels extends Operation {
 
         this.name = "Split Colour Channels";
         this.module = "Image";
-        this.description = "Splits the given image into its red, green and blue colour channels.";
+        this.description =
+            "Splits the given image into its red, green and blue colour channels.";
         this.infoURL = "https://wikipedia.org/wiki/Channel_(digital_image)";
         this.inputType = "ArrayBuffer";
         this.outputType = "List<File>";
@@ -48,26 +48,44 @@ class SplitColourChannels extends Operation {
                 const split = parsedImage
                     .clone()
                     .color([
-                        {apply: "blue", params: [-255]},
-                        {apply: "green", params: [-255]}
+                        { apply: "blue", params: [-255] },
+                        { apply: "green", params: [-255] },
                     ])
-                    .getBufferAsync(Jimp.MIME_PNG);
-                resolve(new File([new Uint8Array((await split).values())], "red.png", {type: "image/png"}));
+                    .getBuffer(JimpMime.png);
+                resolve(
+                    new File(
+                        [new Uint8Array((await split).values())],
+                        "red.png",
+                        { type: "image/png" },
+                    ),
+                );
             } catch (err) {
-                reject(new OperationError(`Could not split red channel: ${err}`));
+                reject(
+                    new OperationError(`Could not split red channel: ${err}`),
+                );
             }
         });
 
         const green = new Promise(async (resolve, reject) => {
             try {
-                const split = parsedImage.clone()
+                const split = parsedImage
+                    .clone()
                     .color([
-                        {apply: "red", params: [-255]},
-                        {apply: "blue", params: [-255]},
-                    ]).getBufferAsync(Jimp.MIME_PNG);
-                resolve(new File([new Uint8Array((await split).values())], "green.png", {type: "image/png"}));
+                        { apply: "red", params: [-255] },
+                        { apply: "blue", params: [-255] },
+                    ])
+                    .getBuffer(JimpMime.png);
+                resolve(
+                    new File(
+                        [new Uint8Array((await split).values())],
+                        "green.png",
+                        { type: "image/png" },
+                    ),
+                );
             } catch (err) {
-                reject(new OperationError(`Could not split green channel: ${err}`));
+                reject(
+                    new OperationError(`Could not split green channel: ${err}`),
+                );
             }
         });
 
@@ -75,12 +93,21 @@ class SplitColourChannels extends Operation {
             try {
                 const split = parsedImage
                     .color([
-                        {apply: "red", params: [-255]},
-                        {apply: "green", params: [-255]},
-                    ]).getBufferAsync(Jimp.MIME_PNG);
-                resolve(new File([new Uint8Array((await split).values())], "blue.png", {type: "image/png"}));
+                        { apply: "red", params: [-255] },
+                        { apply: "green", params: [-255] },
+                    ])
+                    .getBuffer(JimpMime.png);
+                resolve(
+                    new File(
+                        [new Uint8Array((await split).values())],
+                        "blue.png",
+                        { type: "image/png" },
+                    ),
+                );
             } catch (err) {
-                reject(new OperationError(`Could not split blue channel: ${err}`));
+                reject(
+                    new OperationError(`Could not split blue channel: ${err}`),
+                );
             }
         });
 
@@ -96,7 +123,6 @@ class SplitColourChannels extends Operation {
     async present(files) {
         return await Utils.displayFilesAsHTML(files);
     }
-
 }
 
 export default SplitColourChannels;