Converted the core to ES modules

src/core/Chef.mjs

@@ -0,0 +1,172 @@
+/**
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2016
+ * @license Apache-2.0
+ */
+
+import Dish from "./Dish";
+import Recipe from "./Recipe";
+import log from "loglevel";
+
+/**
+ * The main controller for CyberChef.
+ */
+class Chef {
+
+    /**
+     * Chef constructor
+     */
+    constructor() {
+        this.dish = new Dish();
+    }
+
+
+    /**
+     * Runs the recipe over the input.
+     *
+     * @param {string|ArrayBuffer} input - The input data as a string or ArrayBuffer
+     * @param {Object[]} recipeConfig - The recipe configuration object
+     * @param {Object} options - The options object storing various user choices
+     * @param {boolean} options.attempHighlight - Whether or not to attempt highlighting
+     * @param {number} progress - The position in the recipe to start from
+     * @param {number} [step] - Whether to only execute one operation in the recipe
+     *
+     * @returns {Object} response
+     * @returns {string} response.result - The output of the recipe
+     * @returns {string} response.type - The data type of the result
+     * @returns {number} response.progress - The position that we have got to in the recipe
+     * @returns {number} response.duration - The number of ms it took to execute the recipe
+     * @returns {number} response.error - The error object thrown by a failed operation (false if no error)
+    */
+    async bake(input, recipeConfig, options, progress, step) {
+        log.debug("Chef baking");
+        const startTime = new Date().getTime(),
+            recipe      = new Recipe(recipeConfig),
+            containsFc  = recipe.containsFlowControl(),
+            notUTF8     = options && options.hasOwnProperty("treatAsUtf8") && !options.treatAsUtf8;
+        let error = false;
+
+        if (containsFc && ENVIRONMENT_IS_WORKER()) self.setOption("attemptHighlight", false);
+
+        // Clean up progress
+        if (progress >= recipeConfig.length) {
+            progress = 0;
+        }
+
+        if (step) {
+            // Unset breakpoint on this step
+            recipe.setBreakpoint(progress, false);
+            // Set breakpoint on next step
+            recipe.setBreakpoint(progress + 1, true);
+        }
+
+        // If stepping with flow control, we have to start from the beginning
+        // but still want to skip all previous breakpoints
+        if (progress > 0 && containsFc) {
+            recipe.removeBreaksUpTo(progress);
+            progress = 0;
+        }
+
+        // If starting from scratch, load data
+        if (progress === 0) {
+            const type = input instanceof ArrayBuffer ? Dish.ARRAY_BUFFER : Dish.STRING;
+            this.dish.set(input, type);
+        }
+
+        try {
+            progress = await recipe.execute(this.dish, progress);
+        } catch (err) {
+            log.error(err);
+            error = {
+                displayStr: err.displayStr,
+            };
+            progress = err.progress;
+        }
+
+        // Depending on the size of the output, we may send it back as a string or an ArrayBuffer.
+        // This can prevent unnecessary casting as an ArrayBuffer can be easily downloaded as a file.
+        // The threshold is specified in KiB.
+        const threshold = (options.ioDisplayThreshold || 1024) * 1024;
+        const returnType = this.dish.size > threshold ? Dish.ARRAY_BUFFER : Dish.STRING;
+
+        return {
+            result: this.dish.type === Dish.HTML ?
+                this.dish.get(Dish.HTML, notUTF8) :
+                this.dish.get(returnType, notUTF8),
+            type: Dish.enumLookup(this.dish.type),
+            progress: progress,
+            duration: new Date().getTime() - startTime,
+            error: error
+        };
+    }
+
+
+    /**
+     * When a browser tab is unfocused and the browser has to run lots of dynamic content in other tabs,
+     * it swaps out the memory for that tab. If the CyberChef tab has been unfocused for more than a
+     * minute, we run a silent bake which will force the browser to load and cache all the relevant
+     * JavaScript code needed to do a real bake.
+     *
+     * This will stop baking taking a long time when the CyberChef browser tab has been unfocused for a
+     * long time and the browser has swapped out all its memory.
+     *
+     * The output will not be modified (hence "silent" bake).
+     *
+     * This will only actually execute the recipe if auto-bake is enabled, otherwise it will just load
+     * the recipe, ingredients and dish.
+     *
+     * @param {Object[]} recipeConfig - The recipe configuration object
+     * @returns {number} The time it took to run the silent bake in milliseconds.
+    */
+    silentBake(recipeConfig) {
+        log.debug("Running silent bake");
+
+        let startTime = new Date().getTime(),
+            recipe    = new Recipe(recipeConfig),
+            dish      = new Dish("", Dish.STRING);
+
+        try {
+            recipe.execute(dish);
+        } catch (err) {
+            // Suppress all errors
+        }
+        return new Date().getTime() - startTime;
+    }
+
+
+    /**
+     * Calculates highlight offsets if possible.
+     *
+     * @param {Object[]} recipeConfig
+     * @param {string} direction
+     * @param {Object} pos - The position object for the highlight.
+     * @param {number} pos.start - The start offset.
+     * @param {number} pos.end - The end offset.
+     * @returns {Object}
+     */
+    calculateHighlights(recipeConfig, direction, pos) {
+        const recipe = new Recipe(recipeConfig);
+        const highlights = recipe.generateHighlightList();
+
+        if (!highlights) return false;
+
+        for (let i = 0; i < highlights.length; i++) {
+            // Remove multiple highlights before processing again
+            pos = [pos[0]];
+
+            const func = direction === "forward" ? highlights[i].f : highlights[i].b;
+
+            if (typeof func == "function") {
+                pos = func(pos, highlights[i].args);
+            }
+        }
+
+        return {
+            pos: pos,
+            direction: direction
+        };
+    }
+
+}
+
+export default Chef;