9.22.1

Bumps [jquery](https://github.com/jquery/jquery) from 3.4.1 to 3.5.0.
- [Release notes](https://github.com/jquery/jquery/releases)
- [Commits](https://github.com/jquery/jquery/compare/3.4.1...3.5.0)

Signed-off-by: dependabot[bot] <support@github.com>

.github/workflows/master.yml

@@ -0,0 +1,54 @@
+name: Master
+
+on:
+  push:
+    branches:
+    - master
+
+jobs:
+  main:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Set node version
+      uses: actions/setup-node@v1
+      with:
+        node-version: '10.x'
+
+    - name: Install
+      run: |
+        npm install
+        export NODE_OPTIONS=--max_old_space_size=2048
+
+    - name: Lint
+      run: npx grunt lint
+
+    - name: Unit Tests
+      run: |
+        npm test
+        npx grunt testnodeconsumer
+
+    - name: Production Build
+      if: success()
+      run: npx grunt prod
+
+    - name: Generate sitemap
+      run: npx grunt exec:sitemap
+
+    - name: UI Tests
+      if: success()
+      run: xvfb-run --server-args="-screen 0 1200x800x24" npx grunt testui
+
+    - name: Prepare for GitHub Pages
+      if: success()
+      run: npx grunt copy:ghPages
+
+    - name: Deploy to GitHub Pages
+      if: success() && github.ref == 'refs/heads/master'
+      uses: crazy-max/ghaction-github-pages@v2
+      with:
+        target_branch: gh-pages
+        build_dir: ./build/prod
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/releases.yml

@@ -0,0 +1,55 @@
+name: Release
+
+on:
+  push:
+    tags:
+    - 'v*'
+
+jobs:
+  main:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Set node version
+      uses: actions/setup-node@v1
+      with:
+        node-version: '10.x'
+
+    - name: Install
+      run: |
+        npm install
+        export NODE_OPTIONS=--max_old_space_size=2048
+
+    - name: Lint
+      run: npx grunt lint
+
+    - name: Unit Tests
+      run: |
+        npm test
+        npx grunt testnodeconsumer
+
+    - name: Production Build
+      if: success()
+      run: npx grunt prod
+
+    - name: UI Tests
+      if: success()
+      run: xvfb-run --server-args="-screen 0 1200x800x24" npx grunt testui
+
+    - name: Upload Release Assets
+      if: success()
+      id: upload-release-assets
+      uses: svenstaro/upload-release-action@v2
+      with:
+        repo_token: ${{ secrets.GITHUB_TOKEN }}
+        file: build/prod/*.zip
+        tag: ${{ github.ref }}
+        overwrite: true
+        file_glob: true
+
+    - name: Publish to NPM
+      if: success()
+      uses: JS-DevTools/npm-publish@v1
+      with:
+        token: ${{ secrets.NPM_TOKEN }}

.travis.yml

@@ -1,54 +0,0 @@
-language: node_js
-node_js:
-  - lts/dubnium
-cache: npm
-addons:
-  chrome: stable
-install: npm install
-before_script:
-  - npm install -g grunt
-  - export NODE_OPTIONS=--max_old_space_size=2048
-script:
-  - grunt lint
-  - grunt test
-  - grunt testnodeconsumer
-  - grunt prod --msg="$COMPILE_MSG"
-  - xvfb-run --server-args="-screen 0 1200x800x24" grunt testui
-before_deploy:
-  - grunt exec:sitemap
-  - grunt copy:ghPages
-deploy:
-  - provider: pages
-    skip_cleanup: true
-    github_token: $GITHUB_TOKEN
-    local_dir: build/prod/
-    target_branch: gh-pages
-    on:
-      repo: gchq/CyberChef
-      branch: master
-  - provider: releases
-    skip_cleanup: true
-    api_key:
-      secure: "HV1WSKv4l/0Y2bKKs1iBJocBcmLj08PCRUeEM/jTwA4jqJ8EiLHWiXtER/D5sEg2iibRVKd2OQjfrmS6bo4AiwdeVgAKmv0FtS2Jw+391N8Nd5AkEANHa5Om/IpHLTL2YRAjpJTsDpY72bMUTJIwjQA3TFJkgrpOw6KYfohOcgbxLpZ4XuNJRU3VL4Hsxdv5V9aOVmfFOmMOVPQlakXy7NgtW5POp1f2WJwgcZxylkR1CjwaqMyXmSoVl46pyH3tr5+dptsQoKSGdi6sIHGA60oDotFPcm+0ifa47wZw+vapuuDi4tdNxhrHGaDMG8xiE0WFDHwQUDlk2/+W7j9SEX0H3Em7us371JXRp56EDwEcDa34VpVkC6i8HGcHK55hnxVbMZXGf3qhOFD8wY7qMbjMRvIpucrMHBi86OfkDfv0vDj2LyvIl5APj/AX50BrE0tfH1MZbH26Jkx4NdlkcxQ14GumarmUqfmVvbX/fsoA6oUuAAE9ZgRRi3KHO4wci6KUcRfdm+XOeUkaBFsL86G3EEYIvrtBTuaypdz+Cx7nd1iPZyWMx5Y1gXnVzha4nBdV4+7l9JIsFggD8QVpw2uHXQiS1KXFjOeqA3DBD8tjMB7q26Fl2fD3jkOo4BTbQ2NrRIZUu/iL+fOmMPsyMt2qulB0yaSBCfkbEq8xrUA="
-    file_glob: true
-    file:
-      - build/prod/*.zip
-      - src/node/cjs.js
-    on:
-      repo: gchq/CyberChef
-      tags: true
-  - provider: npm
-    skip_cleanup: true
-    email: "n1474335@gmail.com"
-    api_key:
-      secure: "UnDQL3Kh+GK2toL0TK3FObO0ujVssU3Eg4BBuYdjwLB81GhiGE5/DTh7THdZPOpbLo6wQeOwfZDuMeKC1OU+0Uf4NsdYFu1aq6xMO20qBQ4qUfgsyiK4Qgywj9gk0p1+OFZdGAZ/j1CNRAaF71XQIY6iV84c+SO4WoizXYrNT0Jh4sr2DA4/97G2xmJtPi0qOzYrJ09R56ZUozmqeik5G0pMRIuJRbpjS/7bZXV+N7WV0ombZc9RkUaetbabEVOLQ+Xx5YAIVq+VuEeMe9VBSnxY/FfCLmy1wJsjGzpLCyBI9nbrG4nw8Wgc2m8NfK9rcpIvBTGner9r2j60NVDkZ8kLZPrqXhq6AZMwa+oz6K5UQCqRo2RRQzSGwXxg67HY5Tcq+oNmjd+DqpPg4LZ3eGlluyP5XfG+hpSr9Ya4d8q8SrUWLxkoLHI6ZKMtoKFbTCSSQPiluW5hsZxjz3yDkkjsJw64M/EM8UyJrgaXqDklQu+7rBGKLfsK6os7RDiqjBWpQ7gwpo8HvY0O8yqEAabPz+QGkanpjcCOZCXFbSkzWxYy37RMAPu88iINVZVlZE4l+WJenCpZY95ueyy0mG9cyMSzVRPyX6A+/n4H6VMFPFjpGDLTD588ACEjY1lmHfS/eXwXJcgqPPD2gW0XdRdUheU/ssqlfCfGWQMTDXs="
-    on:
-      tags: true
-      branch: master
-notifications:
-    webhooks:
-        urls:
-            - https://webhooks.gitter.im/e/83c143a6822e218d5b34
-        on_success: change
-        on_failure: always
-        on_start: never

CHANGELOG.md

@@ -2,6 +2,36 @@
 All major and minor version changes will be documented in this file. Details of patch-level version changes can be found in [commit messages](https://github.com/gchq/CyberChef/commits/master).
 
 
+### [9.21.0] - 2020-06-12
+- Node API now exports `magic` operation [@d98762625] | [#1049]
+
+### [9.20.0] - 2020-03-27
+- 'Parse ObjectID Timestamp' operation added [@dmfj] | [#987]
+
+### [9.19.0] - 2020-03-24
+- Improvements to the 'Magic' operation, allowing it to recognise more data formats and provide more accurate results [@n1073645] [@n1474335] | [#966] [b765534b](https://github.com/gchq/CyberChef/commit/b765534b8b2a0454a5132a0a52d1d8844bcbdaaa)
+
+### [9.18.0] - 2020-03-13
+- 'Convert to NATO alphabet' operation added [@MarvinJWendt] | [#674]
+
+### [9.17.0] - 2020-03-13
+- 'Generate Image' operation added [@pointhi] | [#683]
+
+### [9.16.0] - 2020-03-06
+- 'Colossus' operation added [@VirtualColossus] | [#917]
+
+### [9.15.0] - 2020-03-05
+- 'CipherSaber2 Encrypt' and 'CipherSaber2 Decrypt' operations added [@n1073645] | [#952]
+
+### [9.14.0] - 2020-03-05
+- 'Luhn Checksum' operation added [@n1073645] | [#965]
+
+### [9.13.0] - 2020-02-13
+- 'Rail Fence Cipher Encode' and 'Rail Fence Cipher Decode' operations added [@Flavsditz] | [#948]
+
+### [9.12.0] - 2019-12-20
+- 'Normalise Unicode' operation added [@matthieuxyz] | [#912]
+
 ### [9.11.0] - 2019-11-06
 - Implemented CFB, OFB, and CTR modes for Blowfish operations [@cbeuw] | [#653]
 
@@ -197,6 +227,15 @@ All major and minor version changes will be documented in this file. Details of
 
 
 
+[9.20.0]: https://github.com/gchq/CyberChef/releases/tag/v9.20.0
+[9.19.0]: https://github.com/gchq/CyberChef/releases/tag/v9.19.0
+[9.18.0]: https://github.com/gchq/CyberChef/releases/tag/v9.18.0
+[9.17.0]: https://github.com/gchq/CyberChef/releases/tag/v9.17.0
+[9.16.0]: https://github.com/gchq/CyberChef/releases/tag/v9.16.0
+[9.15.0]: https://github.com/gchq/CyberChef/releases/tag/v9.15.0
+[9.14.0]: https://github.com/gchq/CyberChef/releases/tag/v9.14.0
+[9.13.0]: https://github.com/gchq/CyberChef/releases/tag/v9.13.0
+[9.12.0]: https://github.com/gchq/CyberChef/releases/tag/v9.12.0
 [9.11.0]: https://github.com/gchq/CyberChef/releases/tag/v9.11.0
 [9.10.0]: https://github.com/gchq/CyberChef/releases/tag/v9.10.0
 [9.9.0]: https://github.com/gchq/CyberChef/releases/tag/v9.9.0
@@ -257,6 +296,7 @@ All major and minor version changes will be documented in this file. Details of
 [@n1474335]: https://github.com/n1474335
 [@d98762625]: https://github.com/d98762625
 [@j433866]: https://github.com/j433866
+[@n1073645]: https://github.com/n1073645
 [@GCHQ77703]: https://github.com/GCHQ77703
 [@h345983745]: https://github.com/h345983745
 [@s2224834]: https://github.com/s2224834
@@ -281,6 +321,11 @@ All major and minor version changes will be documented in this file. Details of
 [@jarrodconnolly]: https://github.com/jarrodconnolly
 [@VirtualColossus]: https://github.com/VirtualColossus
 [@cbeuw]: https://github.com/cbeuw
+[@matthieuxyz]: https://github.com/matthieuxyz
+[@Flavsditz]: https://github.com/Flavsditz
+[@pointhi]: https://github.com/pointhi
+[@MarvinJWendt]: https://github.com/MarvinJWendt
+[@dmfj]: https://github.com/dmfj
 
 [#95]: https://github.com/gchq/CyberChef/pull/299
 [#173]: https://github.com/gchq/CyberChef/pull/173
@@ -343,4 +388,13 @@ All major and minor version changes will be documented in this file. Details of
 [#627]: https://github.com/gchq/CyberChef/pull/627
 [#632]: https://github.com/gchq/CyberChef/pull/632
 [#653]: https://github.com/gchq/CyberChef/pull/653
+[#674]: https://github.com/gchq/CyberChef/pull/674
+[#683]: https://github.com/gchq/CyberChef/pull/683
 [#865]: https://github.com/gchq/CyberChef/pull/865
+[#912]: https://github.com/gchq/CyberChef/pull/912
+[#917]: https://github.com/gchq/CyberChef/pull/917
+[#948]: https://github.com/gchq/CyberChef/pull/948
+[#952]: https://github.com/gchq/CyberChef/pull/952
+[#965]: https://github.com/gchq/CyberChef/pull/965
+[#966]: https://github.com/gchq/CyberChef/pull/966
+[#987]: https://github.com/gchq/CyberChef/pull/987

Gruntfile.js

@@ -36,11 +36,10 @@ module.exports = function (grunt) {
             "clean:node", "clean:config", "clean:nodeConfig", "exec:generateConfig", "exec:generateNodeIndex"
         ]);
 
-    grunt.registerTask("test",
-        "A task which runs all the operation tests in the tests directory.",
+    grunt.registerTask("configTests",
+        "A task which configures config files in preparation for tests to be run. Use `npm test` to run tests.",
         [
-            "clean:config", "clean:nodeConfig", "exec:generateConfig", "exec:generateNodeIndex",
-            "exec:nodeTests", "exec:opTests"
+            "clean:config", "clean:nodeConfig", "exec:generateConfig", "exec:generateNodeIndex"
         ]);
 
     grunt.registerTask("testui",
@@ -55,7 +54,6 @@ module.exports = function (grunt) {
         "Lints the code base",
         ["eslint", "exec:repoSize"]);
 
-    grunt.registerTask("tests", "test");
     grunt.registerTask("lint", "eslint");
 
     grunt.registerTask("findModules",
@@ -219,6 +217,7 @@ module.exports = function (grunt) {
             options: {
                 webpack: webpackConfig,
                 host: "0.0.0.0",
+                port: grunt.option("port") || 8080,
                 disableHostCheck: true,
                 overlay: true,
                 inline: false,
@@ -275,7 +274,7 @@ module.exports = function (grunt) {
         connect: {
             prod: {
                 options: {
-                    port: 8000,
+                    port: grunt.option("port") || 8000,
                     base: "build/prod/"
                 }
             }
@@ -303,7 +302,7 @@ module.exports = function (grunt) {
                 },
                 files: [
                     {
-                        src: "build/prod/index.html",
+                        src: ["build/prod/index.html"],
                         dest: "build/prod/index.html"
                     }
                 ]
@@ -325,7 +324,7 @@ module.exports = function (grunt) {
                 },
                 files: [
                     {
-                        src: "build/prod/index.html",
+                        src: ["build/prod/index.html"],
                         dest: `build/prod/CyberChef_v${pkg.version}.html`
                     }
                 ]
@@ -384,15 +383,9 @@ module.exports = function (grunt) {
                 ]),
                 sync: true
             },
-            opTests: {
-                command: "node --experimental-modules --no-warnings --no-deprecation tests/operations/index.mjs"
-            },
             browserTests: {
                 command: "./node_modules/.bin/nightwatch --env prod"
             },
-            nodeTests: {
-                command: "node --experimental-modules --no-warnings --no-deprecation tests/node/index.mjs"
-            },
             setupNodeConsumers: {
                 command: chainCommands([
                     "echo '\n--- Testing node consumers ---'",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "cyberchef",
-  "version": "9.11.13",
+  "version": "9.22.1",
   "description": "The Cyber Swiss Army Knife for encryption, encoding, compression and data analysis.",
   "author": "n1474335 <n1474335@gmail.com>",
   "homepage": "https://gchq.github.io/CyberChef",
@@ -36,133 +36,143 @@
     "node >= 10"
   ],
   "devDependencies": {
-    "@babel/core": "^7.7.5",
-    "@babel/plugin-transform-runtime": "^7.7.6",
-    "@babel/preset-env": "^7.7.6",
-    "autoprefixer": "^9.7.3",
-    "babel-eslint": "^10.0.3",
-    "babel-loader": "^8.0.6",
-    "babel-plugin-dynamic-import-node": "^2.3.0",
-    "chromedriver": "^78.0.1",
+    "@babel/core": "^7.12.10",
+    "@babel/plugin-transform-runtime": "^7.12.10",
+    "@babel/preset-env": "^7.12.10",
+    "autoprefixer": "^10.1.0",
+    "babel-eslint": "^10.1.0",
+    "babel-loader": "^8.2.2",
+    "babel-plugin-dynamic-import-node": "^2.3.3",
+    "chromedriver": "^87.0.4",
+    "cli-progress": "^3.8.2",
     "colors": "^1.4.0",
-    "copy-webpack-plugin": "^5.0.5",
-    "css-loader": "^3.2.1",
-    "eslint": "^6.7.2",
-    "exports-loader": "^0.7.0",
-    "file-loader": "^5.0.2",
-    "grunt": "^1.0.4",
+    "copy-webpack-plugin": "^7.0.0",
+    "css-loader": "^5.0.1",
+    "eslint": "^7.15.0",
+    "exports-loader": "^1.1.1",
+    "file-loader": "^6.2.0",
+    "grunt": "^1.3.0",
     "grunt-accessibility": "~6.0.0",
     "grunt-chmod": "~1.1.1",
     "grunt-concurrent": "^3.0.0",
     "grunt-contrib-clean": "~2.0.0",
-    "grunt-contrib-connect": "^2.1.0",
+    "grunt-contrib-connect": "^3.0.0",
     "grunt-contrib-copy": "~1.0.0",
     "grunt-contrib-watch": "^1.1.0",
-    "grunt-eslint": "^22.0.0",
+    "grunt-eslint": "^23.0.0",
     "grunt-exec": "~3.0.0",
-    "grunt-webpack": "^3.1.3",
+    "grunt-webpack": "^4.0.2",
     "grunt-zip": "^0.18.2",
-    "html-webpack-plugin": "^3.2.0",
-    "imports-loader": "^0.8.0",
-    "mini-css-extract-plugin": "^0.8.0",
-    "nightwatch": "^1.3.2",
-    "node-sass": "^4.13.0",
-    "postcss-css-variables": "^0.14.0",
-    "postcss-import": "^12.0.1",
-    "postcss-loader": "^3.0.0",
+    "html-webpack-plugin": "^4.5.0",
+    "imports-loader": "^1.2.0",
+    "mini-css-extract-plugin": "^1.3.3",
+    "nightwatch": "^1.5.1",
+    "node-sass": "^5.0.0",
+    "postcss": "^8.2.1",
+    "postcss-css-variables": "^0.17.0",
+    "postcss-import": "^13.0.0",
+    "postcss-loader": "^4.1.0",
     "prompt": "^1.0.0",
-    "sass-loader": "^8.0.0",
-    "sitemap": "^5.1.0",
-    "style-loader": "^1.0.1",
-    "svg-url-loader": "^3.0.3",
-    "url-loader": "^3.0.0",
-    "webpack": "^4.41.2",
-    "webpack-bundle-analyzer": "^3.6.0",
-    "webpack-dev-server": "^3.9.0",
-    "webpack-node-externals": "^1.7.2",
-    "worker-loader": "^2.0.0"
+    "sass-loader": "^10.1.0",
+    "sitemap": "^6.3.3",
+    "style-loader": "^2.0.0",
+    "svg-url-loader": "^7.1.1",
+    "url-loader": "^4.1.1",
+    "webpack": "^5.10.1",
+    "webpack-bundle-analyzer": "^4.2.0",
+    "webpack-dev-server": "^3.11.0",
+    "webpack-node-externals": "^2.5.2",
+    "worker-loader": "^3.0.6"
   },
   "dependencies": {
-    "@babel/polyfill": "^7.7.0",
-    "@babel/runtime": "^7.7.6",
+    "@babel/polyfill": "^7.12.1",
+    "@babel/runtime": "^7.12.5",
     "arrive": "^2.4.1",
-    "avsc": "^5.4.16",
+    "avsc": "^5.5.3",
     "babel-plugin-transform-builtin-extend": "1.1.2",
     "bcryptjs": "^2.4.3",
-    "bignumber.js": "^9.0.0",
+    "bignumber.js": "^9.0.1",
     "blakejs": "^1.1.0",
-    "bootstrap": "4.4.1",
+    "bootstrap": "4.5.3",
     "bootstrap-colorpicker": "^3.2.0",
-    "bootstrap-material-design": "^4.1.2",
-    "bson": "^4.0.2",
+    "bootstrap-material-design": "^4.1.3",
+    "browserify-zlib": "^0.2.0",
+    "bson": "^4.2.2",
+    "buffer": "^6.0.3",
     "chi-squared": "^1.1.0",
     "codepage": "^1.14.0",
-    "core-js": "^3.4.8",
+    "core-js": "^3.8.1",
     "crypto-api": "^0.8.5",
-    "crypto-js": "^3.1.9-1",
+    "crypto-browserify": "^3.12.0",
+    "crypto-js": "^4.0.0",
     "ctph.js": "0.0.5",
-    "d3": "^5.14.2",
+    "d3": "^6.3.1",
     "d3-hexbin": "^0.2.2",
-    "diff": "^4.0.1",
-    "es6-promisify": "^6.0.2",
-    "escodegen": "^1.12.0",
+    "diff": "^5.0.0",
+    "es6-promisify": "^6.1.1",
+    "escodegen": "^2.0.0",
     "esm": "^3.2.25",
-    "esmangle": "^1.0.1",
     "esprima": "^4.0.1",
     "exif-parser": "^0.1.12",
-    "file-saver": "^2.0.2",
+    "file-saver": "^2.0.5",
     "geodesy": "^1.1.3",
-    "highlight.js": "^9.16.2",
-    "jimp": "^0.9.3",
-    "jquery": "3.4.1",
+    "highlight.js": "^10.4.1",
+    "jimp": "^0.16.1",
+    "jquery": "3.5.1",
     "js-crc": "^0.2.0",
     "js-sha3": "^0.8.0",
-    "jsesc": "^2.5.2",
+    "jsesc": "^3.0.2",
     "jsonpath": "^1.0.2",
     "jsonwebtoken": "^8.5.1",
-    "jsqr": "^1.2.0",
-    "jsrsasign": "8.0.12",
-    "kbpgp": "2.1.6",
+    "jsqr": "^1.3.1",
+    "jsrsasign": "10.1.4",
+    "kbpgp": "2.1.15",
     "libbzip2-wasm": "0.0.4",
-    "libyara-wasm": "^1.0.1",
-    "lodash": "^4.17.15",
-    "loglevel": "^1.6.6",
+    "libyara-wasm": "^1.1.0",
+    "lodash": "^4.17.20",
+    "loglevel": "^1.7.1",
     "loglevel-message-prefix": "^3.0.0",
-    "markdown-it": "^10.0.0",
-    "moment": "^2.24.0",
-    "moment-timezone": "^0.5.27",
+    "markdown-it": "^12.0.3",
+    "moment": "^2.29.1",
+    "moment-timezone": "^0.5.32",
     "ngeohash": "^0.6.3",
-    "node-forge": "^0.9.1",
+    "node-forge": "^0.10.0",
     "node-md6": "^0.1.0",
     "nodom": "^2.4.0",
-    "notepack.io": "^2.2.0",
+    "notepack.io": "^2.3.0",
     "nwmatcher": "^1.4.4",
     "otp": "^0.1.3",
-    "popper.js": "^1.16.0",
+    "path": "^0.12.7",
+    "popper.js": "^1.16.1",
+    "process": "^0.11.10",
     "qr-image": "^3.2.0",
     "scryptsy": "^2.1.0",
     "snackbarjs": "^1.1.0",
-    "sortablejs": "^1.10.1",
-    "split.js": "^1.5.11",
+    "sortablejs": "^1.12.0",
+    "split.js": "^1.6.2",
     "ssdeep.js": "0.0.2",
-    "tesseract.js": "^2.0.0-alpha.15",
-    "ua-parser-js": "^0.7.20",
+    "stream-browserify": "^3.0.0",
+    "terser": "^5.5.1",
+    "tesseract.js": "^2.1.1",
+    "ua-parser-js": "^0.7.23",
+    "unorm": "^1.6.0",
     "utf8": "^3.0.0",
     "vkbeautify": "^0.99.3",
-    "xmldom": "^0.1.27",
-    "xpath": "0.0.27",
-    "xregexp": "^4.2.4",
+    "xmldom": "^0.4.0",
+    "xpath": "0.0.32",
+    "xregexp": "^4.4.1",
     "zlibjs": "^0.3.1"
   },
   "scripts": {
     "start": "grunt dev",
     "build": "grunt prod",
     "repl": "node src/node/repl.js",
-    "test": "grunt test",
+    "test": "grunt configTests && node --experimental-modules --no-warnings --no-deprecation tests/node/index.mjs && node --experimental-modules --no-warnings --no-deprecation tests/operations/index.mjs",
     "test-node-consumer": "grunt testnodeconsumer",
     "testui": "grunt testui",
     "testuidev": "npx nightwatch --env=dev",
     "lint": "grunt lint",
+    "postinstall": "bash postinstall.sh",
     "newop": "node --experimental-modules src/core/config/scripts/newOperation.mjs"
   }
 }

postinstall.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+# Add file extensions to Crypto-Api imports
+if [[ "$OSTYPE" == "darwin"* ]]; then
+  find ./node_modules/crypto-api/src/ \( -type d -name .git -prune \) -o -type f -print0 | xargs -0 sed -i '' -e '/\.mjs/!s/\(from "\.[^"]*\)";/\1.mjs";/g'
+else
+  find ./node_modules/crypto-api/src/ \( -type d -name .git -prune \) -o -type f -print0 | xargs -0 sed -i -e '/\.mjs/!s/\(from "\.[^"]*\)";/\1.mjs";/g'
+fi

src/core/Chef.mjs

@@ -39,7 +39,7 @@ class Chef {
     */
     async bake(input, recipeConfig, options) {
         log.debug("Chef baking");
-        const startTime = new Date().getTime(),
+        const startTime = Date.now(),
             recipe      = new Recipe(recipeConfig),
             containsFc  = recipe.containsFlowControl(),
             notUTF8     = options && "treatAsUtf8" in options && !options.treatAsUtf8;
@@ -73,10 +73,10 @@ class Chef {
         // The threshold is specified in KiB.
         const threshold = (options.ioDisplayThreshold || 1024) * 1024;
         const returnType =
-            this.dish.size > threshold ?
-                Dish.ARRAY_BUFFER :
-                this.dish.type === Dish.HTML ?
-                    Dish.HTML :
+            this.dish.type === Dish.HTML ?
+                Dish.HTML :
+                this.dish.size > threshold ?
+                    Dish.ARRAY_BUFFER :
                     Dish.STRING;
 
         return {
@@ -84,7 +84,7 @@ class Chef {
             result: await this.dish.get(returnType, notUTF8),
             type: Dish.enumLookup(this.dish.type),
             progress: progress,
-            duration: new Date().getTime() - startTime,
+            duration: Date.now() - startTime,
             error: error
         };
     }
@@ -110,7 +110,7 @@ class Chef {
     silentBake(recipeConfig) {
         log.debug("Running silent bake");
 
-        const startTime = new Date().getTime(),
+        const startTime = Date.now(),
             recipe = new Recipe(recipeConfig),
             dish = new Dish();
 
@@ -119,7 +119,7 @@ class Chef {
         } catch (err) {
             // Suppress all errors
         }
-        return new Date().getTime() - startTime;
+        return Date.now() - startTime;
     }
 
 
@@ -146,7 +146,12 @@ class Chef {
             const func = direction === "forward" ? highlights[i].f : highlights[i].b;
 
             if (typeof func == "function") {
-                pos = func(pos, highlights[i].args);
+                try {
+                    pos = func(pos, highlights[i].args);
+                } catch (err) {
+                    // Throw away highlighting errors
+                    pos = [];
+                }
             }
         }
 

src/core/Ingredient.mjs

@@ -113,6 +113,7 @@ class Ingredient {
                     return data;
                 }
             case "number":
+                if (data === null) return data;
                 number = parseFloat(data);
                 if (isNaN(number)) {
                     const sample = Utils.truncate(data.toString(), 10);

src/core/Utils.mjs

@@ -591,6 +591,44 @@ class Utils {
         return utf8 ? Utils.byteArrayToUtf8(arr) : Utils.byteArrayToChars(arr);
     }
 
+    /**
+     * Calculates the Shannon entropy for a given set of data.
+     *
+     * @param {Uint8Array|ArrayBuffer} input
+     * @returns {number}
+     */
+    static calculateShannonEntropy(data) {
+        if (data instanceof ArrayBuffer) {
+            data = new Uint8Array(data);
+        }
+        const prob = [],
+            occurrences = new Array(256).fill(0);
+
+        // Count occurrences of each byte in the input
+        let i;
+        for (i = 0; i < data.length; i++) {
+            occurrences[data[i]]++;
+        }
+
+        // Store probability list
+        for (i = 0; i < occurrences.length; i++) {
+            if (occurrences[i] > 0) {
+                prob.push(occurrences[i] / data.length);
+            }
+        }
+
+        // Calculate Shannon entropy
+        let entropy = 0,
+            p;
+
+        for (i = 0; i < prob.length; i++) {
+            p = prob[i];
+            entropy += p * Math.log(p) / Math.log(2);
+        }
+
+        return -entropy;
+    }
+
 
     /**
      * Parses CSV data and returns it as a two dimensional array or strings.
@@ -1144,6 +1182,7 @@ class Utils {
             "CRLF":          /\r\n/g,
             "Forward slash": /\//g,
             "Backslash":     /\\/g,
+            "0x with comma": /,?0x/g,
             "0x":            /0x/g,
             "\\x":           /\\x/g,
             "None":          /\s+/g // Included here to remove whitespace when there shouldn't be any
@@ -1297,7 +1336,7 @@ export function sendStatusMessage(msg) {
         self.sendStatusMessage(msg);
     else if (isWebEnvironment())
         app.alert(msg, 10000);
-    else if (isNodeEnvironment())
+    else if (isNodeEnvironment() && !global.TESTING)
         // eslint-disable-next-line no-console
         console.debug(msg);
 }

src/core/config/Categories.json

@@ -39,6 +39,7 @@
             "URL Decode",
             "Escape Unicode Characters",
             "Unescape Unicode Characters",
+            "Normalise Unicode",
             "To Quoted Printable",
             "From Quoted Printable",
             "To Punycode",
@@ -94,7 +95,11 @@
             "Affine Cipher Decode",
             "A1Z26 Cipher Encode",
             "A1Z26 Cipher Decode",
+            "Rail Fence Cipher Encode",
+            "Rail Fence Cipher Decode",
             "Atbash Cipher",
+            "CipherSaber2 Encrypt",
+            "CipherSaber2 Decrypt",
             "Substitute",
             "Derive PBKDF2 key",
             "Derive EVP key",
@@ -110,7 +115,8 @@
             "Bombe",
             "Multiple Bombe",
             "Typex",
-            "Lorenz"
+            "Lorenz",
+            "Colossus"
         ]
     },
     {
@@ -194,8 +200,10 @@
         "ops": [
             "Encode text",
             "Decode text",
+            "Unicode Text Format",
             "Remove Diacritics",
-            "Unescape Unicode Characters"
+            "Unescape Unicode Characters",
+            "Convert to NATO alphabet"
         ]
     },
     {
@@ -235,6 +243,7 @@
             "Convert co-ordinate format",
             "Show on map",
             "Parse UNIX file permissions",
+            "Parse ObjectID timestamp",
             "Swap endianness",
             "Parse colour code",
             "Escape string",
@@ -329,6 +338,7 @@
             "Fletcher-32 Checksum",
             "Fletcher-64 Checksum",
             "Adler-32 Checksum",
+            "Luhn Checksum",
             "CRC-8 Checksum",
             "CRC-16 Checksum",
             "CRC-32 Checksum",
@@ -388,6 +398,7 @@
         "ops": [
             "Render Image",
             "Play Media",
+            "Generate Image",
             "Optical Character Recognition",
             "Remove EXIF",
             "Extract EXIF",

src/core/config/scripts/generateConfig.mjs

@@ -42,13 +42,10 @@ for (const opObj in Ops) {
         outputType:  op.presentType,
         flowControl: op.flowControl,
         manualBake:  op.manualBake,
-        args:        op.args
+        args:        op.args,
+        checks:      op.checks
     };
 
-    if ("patterns" in op) {
-        operationConfig[op.name].patterns = op.patterns;
-    }
-
     if (!(op.module in modules))
         modules[op.module] = {};
     modules[op.module][op.name] = opObj;

src/core/dishTypes/DishJSON.mjs

@@ -17,7 +17,7 @@ class DishJSON extends DishType {
      */
     static toArrayBuffer() {
         DishJSON.checkForValue(this.value);
-        this.value = this.value ? Utils.strToArrayBuffer(JSON.stringify(this.value, null, 4)) : new ArrayBuffer;
+        this.value = this.value !== undefined ? Utils.strToArrayBuffer(JSON.stringify(this.value, null, 4)) : new ArrayBuffer;
     }
 
     /**

src/core/dishTypes/DishListFile.mjs

@@ -5,7 +5,7 @@
  */
 
 import DishType from "./DishType.mjs";
-import { isNodeEnvironment } from "../Utils.mjs";
+import Utils, { isNodeEnvironment } from "../Utils.mjs";
 
 
 /**
@@ -16,13 +16,14 @@ class DishListFile extends DishType {
     /**
      * convert the given value to a ArrayBuffer
      */
-    static toArrayBuffer() {
+    static async toArrayBuffer() {
         DishListFile.checkForValue(this.value);
 
         if (isNodeEnvironment()) {
             this.value = this.value.map(file => Uint8Array.from(file.data));
+        } else {
+            this.value = await DishListFile.concatenateTypedArraysWithTypedElements(...this.value);
         }
-        this.value = DishListFile.concatenateTypedArrays(...this.value).buffer;
     }
 
     /**
@@ -33,6 +34,27 @@ class DishListFile extends DishType {
         this.value = [new File(this.value, "unknown")];
     }
 
+    /**
+     * Concatenates a list of typed elements together.
+     *
+     * @param {Uint8Array[]} arrays
+     * @returns {Uint8Array}
+     */
+    static async concatenateTypedArraysWithTypedElements(...arrays) {
+        let totalLength = 0;
+        for (const arr of arrays) {
+            totalLength += arr.size;
+        }
+        const myArray = new Uint8Array(totalLength);
+
+        let offset = 0;
+        for (const arr of arrays) {
+            const data = await Utils.readFile(arr);
+            myArray.set(data, offset);
+            offset += data.length;
+        }
+        return myArray;
+    }
 
     /**
      * Concatenates a list of Uint8Arrays together

src/core/lib/Blowfish.mjs

@@ -38,7 +38,7 @@
 
 const crypto = {};
 
-import forge from "node-forge/dist/forge.min.js";
+import forge from "node-forge";
 
 
 /* dojo-release-1.8.1/dojo/_base/lang.js.uncompressed.js */

src/core/lib/ChrEnc.mjs

@@ -164,3 +164,15 @@ export const IO_FORMAT = {
     "Simplified Chinese GB18030 (54936)": 54936,
 };
 
+/**
+ * Unicode Normalisation Forms
+ *
+ * @author Matthieu [m@tthieu.xyz]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+/**
+ * Character encoding format mappings.
+ */
+export const UNICODE_NORMALISATION_FORMS = ["NFD", "NFC", "NFKD", "NFKC"];

src/core/lib/CipherSaber2.mjs

@@ -0,0 +1,34 @@
+/**
+ * @author n1073645 [n1073645@gmail.com]
+ * @copyright Crown Copyright 2020
+ * @license Apache-2.0
+ */
+export function encode(tempIVP, key, rounds, input) {
+    const ivp = new Uint8Array(key.concat(tempIVP));
+    const state = new Array(256).fill(0);
+    let j = 0, i = 0;
+    const result = [];
+
+    // Mixing states based off of IV.
+    for (let i = 0; i < 256; i++)
+        state[i] = i;
+    const ivpLength = ivp.length;
+    for (let r = 0; r < rounds; r ++) {
+        for (let k = 0; k < 256; k++) {
+            j = (j + state[k] + ivp[k % ivpLength]) % 256;
+            [state[k], state[j]] = [state[j], state[k]];
+        }
+    }
+    j = 0;
+    i = 0;
+
+    // XOR cipher with key.
+    for (let x = 0; x < input.length; x++) {
+        i = (++i) % 256;
+        j = (j + state[i]) % 256;
+        [state[i], state[j]] = [state[j], state[i]];
+        const n = (state[i] + state[j]) % 256;
+        result.push(state[n] ^ input[x]);
+    }
+    return result;
+}

src/core/lib/Colossus.mjs

@@ -0,0 +1,417 @@
+/**
+ * Colossus - an emulation of the world's first electronic computer
+ *
+ * @author VirtualColossus [martin@virtualcolossus.co.uk]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+import {INIT_PATTERNS, ITA2_TABLE, ROTOR_SIZES} from "../lib/Lorenz.mjs";
+
+/**
+ * Colossus simulator class.
+ */
+export class ColossusComputer {
+    /**
+     * Construct a Colossus.
+     *
+     * @param {string} ciphertext
+     * @param {string} pattern - named pattern of Chi, Mu and Psi wheels
+     * @param {Object} qbusin - which data inputs are being sent to q bus - each can be null, plain or delta
+     * @param {Object[]} qbusswitches - Q bus calculation switches, multiple rows
+     * @param {Object} control - control switches which specify stepping modes
+     * @param {Object} starts - rotor start positions
+     */
+    constructor(ciphertext, pattern, qbusin, qbusswitches, control, starts, settotal, limit) {
+        this.ITAlookup = ITA2_TABLE;
+        this.ReverseITAlookup = {};
+        for (const letter in this.ITAlookup) {
+            const code = this.ITAlookup[letter];
+            this.ReverseITAlookup[code] = letter;
+        }
+
+        this.initThyratrons(pattern);
+
+        this.ciphertext = ciphertext;
+        this.qbusin = qbusin;
+        this.qbusswitches = qbusswitches;
+        this.control = control;
+        this.starts = starts;
+        this.settotal = settotal;
+        this.limitations = limit;
+
+
+        this.allCounters = [0, 0, 0, 0, 0];
+
+        this.Zbits = [0, 0, 0, 0, 0]; // Z input is the cipher tape
+        this.ZbitsOneBack = [0, 0, 0, 0, 0]; // for delta
+        this.Qbits = [0, 0, 0, 0, 0]; // input generated for placing onto the Q-bus (the logic processor)
+
+        this.Xbits = [0, 0, 0, 0, 0]; // X is the Chi wheel bits
+        this.Xptr = [0, 0, 0, 0, 0]; // pointers to the current X bits (Chi wheels)
+        this.XbitsOneBack = [0, 0, 0, 0, 0]; // the X bits one back (for delta)
+
+        this.Sbits = [0, 0, 0, 0, 0]; // S is the Psi wheel bits
+        this.Sptr = [0, 0, 0, 0, 0]; // pointers to the current S bits (Psi wheels)
+        this.SbitsOneBack = [0, 0, 0, 0, 0]; // the S bits one back (for delta)
+
+        this.Mptr = [0, 0];
+
+        this.rotorPtrs = {};
+
+        this.totalmotor = 0;
+        this.P5Zbit = [0, 0];
+    }
+
+    /**
+     * Begin a run
+     *
+     * @returns {object}
+     */
+    run() {
+        const result = {
+            printout: ""
+        };
+
+        // loop until our start positions are back to the beginning
+        this.rotorPtrs = {X1: this.starts.X1, X2: this.starts.X2, X3: this.starts.X3, X4: this.starts.X4, X5: this.starts.X5, M61: this.starts.M61, M37: this.starts.M37, S1: this.starts.S1, S2: this.starts.S2, S3: this.starts.S3, S4: this.starts.S4, S5: this.starts.S5};
+        // this.rotorPtrs = this.starts;
+        let runcount = 1;
+
+        const fast = this.control.fast;
+        const slow = this.control.slow;
+
+        // Print Headers
+        result.printout += fast + " " + slow + "\n";
+
+        do {
+            this.allCounters = [0, 0, 0, 0, 0];
+            this.ZbitsOneBack = [0, 0, 0, 0, 0];
+            this.XbitsOneBack = [0, 0, 0, 0, 0];
+
+            // Run full tape loop and process counters
+            this.runTape();
+
+            // Only print result if larger than set total
+            let fastRef = "00";
+            let slowRef = "00";
+            if (fast !== "") fastRef = this.rotorPtrs[fast].toString().padStart(2, "0");
+            if (slow !== "") slowRef = this.rotorPtrs[slow].toString().padStart(2, "0");
+            let printline = "";
+            for (let c=0;c<5;c++) {
+                if (this.allCounters[c] > this.settotal) {
+                    printline += String.fromCharCode(c+97) + this.allCounters[c]+" ";
+                }
+            }
+            if (printline !== "") {
+                result.printout += fastRef + " " + slowRef + " : ";
+                result.printout += printline;
+                result.printout += "\n";
+            }
+
+            // Step fast rotor if required
+            if (fast !== "") {
+                this.rotorPtrs[fast]++;
+                if (this.rotorPtrs[fast] > ROTOR_SIZES[fast]) this.rotorPtrs[fast] = 1;
+            }
+
+            // Step slow rotor if fast rotor has returned to initial start position
+            if (slow !== "" && this.rotorPtrs[fast] === this.starts[fast]) {
+                this.rotorPtrs[slow]++;
+                if (this.rotorPtrs[slow] > ROTOR_SIZES[slow]) this.rotorPtrs[slow] = 1;
+            }
+
+            runcount++;
+        } while (JSON.stringify(this.rotorPtrs) !== JSON.stringify(this.starts));
+
+        result.counters = this.allCounters;
+        result.runcount = runcount;
+
+        return result;
+    }
+
+    /**
+     * Run tape loop
+     */
+    runTape() {
+        let charZin = "";
+
+        this.Xptr = [this.rotorPtrs.X1, this.rotorPtrs.X2, this.rotorPtrs.X3, this.rotorPtrs.X4, this.rotorPtrs.X5];
+        this.Mptr = [this.rotorPtrs.M37, this.rotorPtrs.M61];
+        this.Sptr = [this.rotorPtrs.S1, this.rotorPtrs.S2, this.rotorPtrs.S3, this.rotorPtrs.S4, this.rotorPtrs.S5];
+
+        // Run full loop of all character on the input tape (Z)
+        for (let i=0; i<this.ciphertext.length; i++) {
+            charZin = this.ciphertext.charAt(i);
+
+            // Firstly, we check what inputs are specified on the Q-bus input switches
+            this.getQbusInputs(charZin);
+
+            /*
+             * Pattern conditions on individual impulses. Matching patterns of bits on the Q bus.
+             * This is the top section on Colussus K rack - the Q bus programming switches
+             */
+            const tmpcnt = this.runQbusProcessingConditional();
+
+            /*
+             * Addition of impulses.
+             * This is the bottom section of Colossus K rack.
+             */
+            this.runQbusProcessingAddition(tmpcnt);
+
+            // Store Z bit impulse 5 two back required for P5 limitation
+            this.P5Zbit[1] = this.P5Zbit[0];
+            this.P5Zbit[0] = this.ITAlookup[charZin].split("")[4];
+
+            // Step rotors
+            this.stepThyratrons();
+
+        }
+    }
+
+    /**
+     * Step thyratron rings to simulate movement of Lorenz rotors
+     * Chi rotors all step one per character
+     * Motor M61 rotor steps one per character, M37 steps dependant on M61 setting
+     * Psi rotors only step dependant on M37 setting + limitation
+     */
+    stepThyratrons() {
+        let X2bPtr = this.Xptr[1]-1;
+        if (X2bPtr===0) X2bPtr = ROTOR_SIZES.X2;
+        let S1bPtr = this.Sptr[0]-1;
+        if (S1bPtr===0) S1bPtr = ROTOR_SIZES.S1;
+
+        // Get Chi rotor 5 two back to calculate plaintext (Z+Chi+Psi=Plain)
+        let X5bPtr=this.Xptr[4]-1;
+        if (X5bPtr===0) X5bPtr=ROTOR_SIZES.X5;
+        X5bPtr=X5bPtr-1;
+        if (X5bPtr===0) X5bPtr=ROTOR_SIZES.X5;
+        // Get Psi rotor 5 two back to calculate plaintext (Z+Chi+Psi=Plain)
+        let S5bPtr=this.Sptr[4]-1;
+        if (S5bPtr===0) S5bPtr=ROTOR_SIZES.S5;
+        S5bPtr=S5bPtr-1;
+        if (S5bPtr===0) S5bPtr=ROTOR_SIZES.S5;
+
+        const x2sw = this.limitations.X2;
+        const s1sw = this.limitations.S1;
+        const p5sw = this.limitations.P5;
+
+        // Limitation calculations
+        let lim=1;
+        if (x2sw) lim = this.rings.X[2][X2bPtr-1];
+        if (s1sw) lim = lim ^ this.rings.S[1][S1bPtr-1];
+
+        // P5
+        if (p5sw) {
+            let p5lim = this.P5Zbit[1];
+            p5lim = p5lim ^ this.rings.X[5][X5bPtr-1];
+            p5lim = p5lim ^ this.rings.S[5][S5bPtr-1];
+            lim = lim ^ p5lim;
+        }
+
+        const basicmotor = this.rings.M[2][this.Mptr[0]-1];
+        this.totalmotor = basicmotor;
+
+        if (x2sw || s1sw) {
+            if (basicmotor===0 && lim===1) {
+                this.totalmotor = 0;
+            } else {
+                this.totalmotor = 1;
+            }
+        }
+
+        // Step Chi rotors
+        for (let r=0; r<5; r++) {
+            this.Xptr[r]++;
+            if (this.Xptr[r] > ROTOR_SIZES["X"+(r+1)]) this.Xptr[r] = 1;
+        }
+
+        if (this.totalmotor) {
+            // Step Psi rotors
+            for (let r=0; r<5; r++) {
+                this.Sptr[r]++;
+                if (this.Sptr[r] > ROTOR_SIZES["S"+(r+1)]) this.Sptr[r] = 1;
+            }
+        }
+
+        // Move M37 rotor if M61 set
+        if (this.rings.M[1][this.Mptr[1]-1]===1) this.Mptr[0]++;
+        if (this.Mptr[0] > ROTOR_SIZES.M37) this.Mptr[0]=1;
+
+        // Always move M61 rotor
+        this.Mptr[1]++;
+        if (this.Mptr[1] > ROTOR_SIZES.M61) this.Mptr[1]=1;
+    }
+
+    /**
+     * Get Q bus inputs
+     */
+    getQbusInputs(charZin) {
+        // Zbits - the bits from the current character from the cipher tape.
+        this.Zbits = this.ITAlookup[charZin].split("");
+        if (this.qbusin.Z === "Z") {
+            // direct Z
+            this.Qbits = this.Zbits;
+        } else if (this.qbusin.Z === "ΔZ") {
+            // delta Z, the Bitwise XOR of this character Zbits + last character Zbits
+            for (let b=0;b<5;b++) {
+                this.Qbits[b] = this.Zbits[b] ^ this.ZbitsOneBack[b];
+            }
+        }
+        this.ZbitsOneBack = this.Zbits.slice(); // copy value of object, not reference
+
+        // Xbits - the current Chi wheel bits
+        for (let b=0;b<5;b++) {
+            this.Xbits[b] = this.rings.X[b+1][this.Xptr[b]-1];
+        }
+        if (this.qbusin.Chi !== "") {
+            if (this.qbusin.Chi === "Χ") {
+                // direct X added to Qbits
+                for (let b=0;b<5;b++) {
+                    this.Qbits[b] = this.Qbits[b] ^ this.Xbits[b];
+                }
+            } else if (this.qbusin.Chi === "ΔΧ") {
+                // delta X
+                for (let b=0;b<5;b++) {
+                    this.Qbits[b] = this.Qbits[b] ^ this.Xbits[b];
+                    this.Qbits[b] = this.Qbits[b] ^ this.XbitsOneBack[b];
+                }
+            }
+        }
+        this.XbitsOneBack = this.Xbits.slice();
+
+        // Sbits - the current Psi wheel bits
+        for (let b=0;b<5;b++) {
+            this.Sbits[b] = this.rings.S[b+1][this.Sptr[b]-1];
+        }
+        if (this.qbusin.Psi !== "") {
+            if (this.qbusin.Psi === "Ψ") {
+                // direct S added to Qbits
+                for (let b=0;b<5;b++) {
+                    this.Qbits[b] = this.Qbits[b] ^ this.Sbits[b];
+                }
+            } else if (this.qbusin.Psi === "ΔΨ") {
+                // delta S
+                for (let b=0;b<5;b++) {
+                    this.Qbits[b] = this.Qbits[b] ^ this.Sbits[b];
+                    this.Qbits[b] = this.Qbits[b] ^ this.SbitsOneBack[b];
+                }
+            }
+        }
+        this.SbitsOneBack = this.Sbits.slice();
+    }
+
+    /**
+     * Conditional impulse Q bus section
+     */
+    runQbusProcessingConditional() {
+        const cnt = [-1, -1, -1, -1, -1];
+        const numrows = this.qbusswitches.condition.length;
+
+        for (let r=0;r<numrows;r++) {
+            const row = this.qbusswitches.condition[r];
+            if (row.Counter !== "") {
+                let result = true;
+                const cPnt = row.Counter-1;
+                const Qswitch = this.readBusSwitches(row.Qswitches);
+                // Match switches to bit pattern
+                for (let s=0;s<5;s++) {
+                    if (Qswitch[s] >= 0 && Qswitch[s] !== parseInt(this.Qbits[s], 10)) result = false;
+                }
+                // Check for NOT switch
+                if (row.Negate) result = !result;
+
+                // AND each row to get final result
+                if (cnt[cPnt] === -1) {
+                    cnt[cPnt] = result;
+                } else if (!result) {
+                    cnt[cPnt] = false;
+                }
+            }
+        }
+
+        // Negate the whole column, this allows A OR B by doing NOT(NOT A AND NOT B)
+        for (let c=0;c<5;c++) {
+            if (this.qbusswitches.condNegateAll && cnt[c] !== -1) cnt[c] = !cnt[c];
+        }
+
+        return cnt;
+    }
+
+    /**
+     * Addition of impulses Q bus section
+     */
+    runQbusProcessingAddition(cnt) {
+        const row = this.qbusswitches.addition[0];
+        const Qswitch = row.Qswitches.slice();
+
+        // To save making the arguments of this operation any larger, limiting addition counter to first one only
+        // Colossus could actually add into any of the five counters.
+        if (row.C1) {
+            let addition = 0;
+            for (let s=0;s<5;s++) {
+                // XOR addition
+                if (Qswitch[s]) {
+                    addition = addition ^ this.Qbits[s];
+                }
+            }
+            const equals = (row.Equals===""?-1:(row.Equals==="."?0:1));
+            if (addition === equals) {
+                // AND with conditional rows to get final result
+                if (cnt[0] === -1) cnt[0] = true;
+            } else {
+                cnt[0] = false;
+            }
+        }
+
+        // Final check, check for addition section negate
+        // then, if any column set, from top to bottom of rack, add to counter.
+        for (let c=0;c<5;c++) {
+            if (this.qbusswitches.addNegateAll && cnt[c] !== -1) cnt[c] = !cnt[c];
+
+            if (this.qbusswitches.totalMotor === "" || (this.qbusswitches.totalMotor === "x" && this.totalmotor === 0) || (this.qbusswitches.totalMotor === "." && this.totalmotor === 1)) {
+                if (cnt[c] === true) this.allCounters[c]++;
+            }
+
+        }
+    }
+
+    /**
+     * Initialise thyratron rings
+     * These hold the pattern of 1s & 0s for each rotor on banks of thyraton GT1C valves which act as a one-bit store.
+     */
+    initThyratrons(pattern) {
+        this.rings = {
+            X: {
+                1: INIT_PATTERNS[pattern].X[1].slice().reverse(),
+                2: INIT_PATTERNS[pattern].X[2].slice().reverse(),
+                3: INIT_PATTERNS[pattern].X[3].slice().reverse(),
+                4: INIT_PATTERNS[pattern].X[4].slice().reverse(),
+                5: INIT_PATTERNS[pattern].X[5].slice().reverse()
+            },
+            M: {
+                1: INIT_PATTERNS[pattern].M[1].slice().reverse(),
+                2: INIT_PATTERNS[pattern].M[2].slice().reverse(),
+            },
+            S: {
+                1: INIT_PATTERNS[pattern].S[1].slice().reverse(),
+                2: INIT_PATTERNS[pattern].S[2].slice().reverse(),
+                3: INIT_PATTERNS[pattern].S[3].slice().reverse(),
+                4: INIT_PATTERNS[pattern].S[4].slice().reverse(),
+                5: INIT_PATTERNS[pattern].S[5].slice().reverse()
+            }
+        };
+    }
+
+    /**
+     * Read argument bus switches X & . and convert to 1 & 0
+     */
+    readBusSwitches(row) {
+        const output = [-1, -1, -1, -1, -1];
+        for (let c=0;c<5;c++) {
+            if (row[c]===".") output[c] = 0;
+            if (row[c]==="x") output[c] = 1;
+        }
+        return output;
+    }
+
+}

src/core/lib/FileSignatures.mjs

@@ -280,7 +280,7 @@ export const FILE_SIGNATURES = {
                 9: 0x0,
                 10: [0x0, 0x1]
             },
-            extractor: null
+            extractor: extractICO
         },
         {
             name: "Radiance High Dynamic Range image",
@@ -468,6 +468,34 @@ export const FILE_SIGNATURES = {
             ],
             extractor: null
         },
+        {
+            name: "Targa Image",
+            extension: "tga",
+            mime: "image/x-targa",
+            description: "",
+            signature: [
+                { // This signature is not at the beginning of the file. The extractor works backwards.
+                    0: 0x54,
+                    1: 0x52,
+                    2: 0x55,
+                    3: 0x45,
+                    4: 0x56,
+                    5: 0x49,
+                    6: 0x53,
+                    7: 0x49,
+                    8: 0x4f,
+                    9: 0x4e,
+                    10: 0x2d,
+                    11: 0x58,
+                    12: 0x46,
+                    13: 0x49,
+                    14: 0x4c,
+                    15: 0x45,
+                    16: 0x2e
+                }
+            ],
+            extractor: extractTARGA
+        }
     ],
     "Video": [
         { // Place before webm
@@ -780,7 +808,7 @@ export const FILE_SIGNATURES = {
                     1: 0xfb
                 }
             ],
-            extractor: null
+            extractor: extractMP3
         },
         {
             name: "MPEG-4 Part 14 audio",
@@ -1008,8 +1036,7 @@ export const FILE_SIGNATURES = {
                 0: 0x7b,
                 1: 0x5c,
                 2: 0x72,
-                3: 0x74,
-                4: 0x66
+                3: 0x74
             },
             extractor: extractRTF
         },
@@ -1725,6 +1752,25 @@ export const FILE_SIGNATURES = {
             },
             extractor: null
         },
+        {
+            name: "Jar Archive",
+            extension: "jar",
+            mime: "application/java-archive",
+            description: "",
+            signature: {
+                0: 0x50,
+                1: 0x4B,
+                2: 0x03,
+                3: 0x04,
+                4: 0x14,
+                5: 0x00,
+                6: 0x08,
+                7: 0x00,
+                8: 0x08,
+                9: 0x00
+            },
+            extractor: extractZIP
+        },
         {
             name: "lzop compressed",
             extension: "lzop,lzo",
@@ -1740,8 +1786,40 @@ export const FILE_SIGNATURES = {
                 6: 0x0a,
                 7: 0x1a
             },
-            extractor: null
+            extractor: extractLZOP
         },
+        {
+            name: "Linux deb package",
+            extension: "deb",
+            mime: "application/vnd.debian.binary-package",
+            description: "",
+            signature: {
+                0: 0x21,
+                1: 0x3C,
+                2: 0x61,
+                3: 0x72,
+                4: 0x63,
+                5: 0x68,
+                6: 0x3e
+            },
+            extractor: extractDEB
+        },
+        {
+            name: "Apple Disk Image",
+            extension: "dmg",
+            mime: "application/x-apple-diskimage",
+            description: "",
+            signature: {
+                0: 0x78,
+                1: 0x01,
+                2: 0x73,
+                3: 0x0d,
+                4: 0x62,
+                5: 0x62,
+                6: 0x60
+            },
+            extractor: null
+        }
     ],
     "Miscellaneous": [
         {
@@ -2039,7 +2117,7 @@ export const FILE_SIGNATURES = {
                 6: [0x4d, 0x36],
                 7: [0x50, 0x34]
             },
-            extractor: null
+            extractor: extractDMP
         },
         {
             name: "Windows Prefetch",
@@ -2056,7 +2134,7 @@ export const FILE_SIGNATURES = {
                 6: 0x43,
                 7: 0x41
             },
-            extractor: null
+            extractor: extractPF
         },
         {
             name: "Windows Prefetch (Win 10)",
@@ -2070,7 +2148,7 @@ export const FILE_SIGNATURES = {
                 3: 0x04,
                 7: 0x0
             },
-            extractor: null
+            extractor: extractPFWin10
         },
         {
             name: "PList (XML)",
@@ -2343,7 +2421,7 @@ export const FILE_SIGNATURES = {
                 18: 0x00,
                 19: 0x46
             },
-            extractor: null
+            extractor: extractLNK
         },
         {
             name: "Bash",
@@ -2471,6 +2549,44 @@ export const FILE_SIGNATURES = {
                 4: 0x70,
             },
             extractor: null
+        },
+        {
+            name: "Smile",
+            extension: "sml",
+            mime: "	application/x-jackson-smile",
+            description: "",
+            signature: {
+                0: 0x3a,
+                1: 0x29,
+                2: 0xa
+            },
+            extractor: null
+        },
+        {
+            name: "Lua Bytecode",
+            extension: "luac",
+            mime: "application/x-lua",
+            description: "",
+            signature: {
+                0: 0x1b,
+                1: 0x4c,
+                2: 0x75,
+                3: 0x61
+            },
+            extractor: null
+        },
+        {
+            name: "WebAssembly binary",
+            extension: "wasm",
+            mime: "application/octet-stream",
+            description: "",
+            signature: {
+                0: 0x00,
+                1: 0x61,
+                2: 0x73,
+                3: 0x6d
+            },
+            extractor: null
         }
     ]
 };
@@ -2933,6 +3049,116 @@ export function extractBMP(bytes, offset) {
 }
 
 
+/**
+ * ICO extractor.
+ *
+ * @param {Uint8Array} bytes
+ * @param {number} offset
+ */
+export function extractICO(bytes, offset) {
+    const stream = new Stream(bytes.slice(offset));
+
+    // Move to number of files there are.
+    stream.moveTo(4);
+
+    // Read the number of files stored in the ICO
+    const numberFiles = stream.readInt(2, "le");
+
+    // Move forward to the last file header.
+    stream.moveForwardsBy(8 + ((numberFiles-1) * 16));
+    const fileSize = stream.readInt(4, "le");
+    const fileOffset = stream.readInt(4, "le");
+
+    // Move to the end of the last file.
+    stream.moveTo(fileOffset + fileSize);
+    return stream.carve();
+}
+
+
+/**
+ * TARGA extractor.
+ *
+ * @param {Uint8Array} bytes
+ * @param {number} offset
+ */
+export function extractTARGA(bytes, offset) {
+    // Need all the bytes since we do not know how far up the image goes.
+    const stream = new Stream(bytes);
+    stream.moveTo(offset - 8);
+
+    // Read in the offsets of the possible areas.
+    const extensionOffset = stream.readInt(4, "le");
+    const developerOffset = stream.readInt(4, "le");
+
+    stream.moveBackwardsBy(8);
+
+    /**
+     * Moves backwards in the stream until it meet bytes that are the same as the amount of bytes moved.
+     *
+     * @param {number} sizeOfSize
+     * @param {number} maxSize
+     */
+    function moveBackwardsUntilSize(maxSize, sizeOfSize) {
+        for (let i = 0; i < maxSize; i++) {
+            stream.moveBackwardsBy(1);
+
+            // Read in sizeOfSize amount of bytes in.
+            const size = stream.readInt(sizeOfSize, "le") - 1;
+            stream.moveBackwardsBy(sizeOfSize);
+
+            // If the size matches.
+            if (size === i)
+                break;
+        }
+    }
+
+    /**
+     * Moves backwards in the stream until we meet bytes(when calculated) that are the same as the amount of bytes moved.
+     */
+    function moveBackwardsUntilImageSize() {
+        stream.moveBackwardsBy(5);
+
+        // The documentation said that 0x100000 was the largest the file could be.
+        for (let i = 0; i < 0x100000; i++) {
+
+            // (Height * Width * pixel depth in bits)/8
+            const total = (stream.readInt(2, "le") * stream.readInt(2, "le") * stream.readInt(1))/8;
+            if (total === i-1)
+                break;
+
+            stream.moveBackwardsBy(6);
+        }
+    }
+
+    if (extensionOffset || developerOffset) {
+        if (extensionOffset) {
+            // Size is stored in two bytes hence the maximum is 0xffff.
+            moveBackwardsUntilSize(0xffff, 2);
+
+            // Move to where we think the start of the file is.
+            stream.moveBackwardsBy(extensionOffset);
+        } else if (developerOffset) {
+            // Size is stored in 4 bytes hence the maxiumum is 0xffffffff.
+            moveBackwardsUntilSize(0xffffffff, 4);
+
+            // Size is stored in byte position 6 so have to move back.
+            stream.moveBackwardsBy(6);
+
+            // Move to where we think the start of the file is.
+            stream.moveBackwardsBy(developerOffset);
+        }
+    } else {
+        // Move backwards until size === number of bytes passed.
+        moveBackwardsUntilImageSize();
+
+        // Move backwards over the reaminder of the header + the 5 we borrowed in moveBackwardsUntilImageSize().
+        stream.moveBackwardsBy(0xc+5);
+    }
+
+    return stream.carve(stream.position, offset+0x12);
+}
+
+
 /**
  * WAV extractor.
  *
@@ -2947,12 +3173,85 @@ export function extractWAV(bytes, offset) {
     stream.moveTo(4);
 
     // Move to file size.
-    stream.moveTo(stream.readInt(4, "le") - 4);
+    stream.moveTo(stream.readInt(4, "le") + 8);
 
     return stream.carve();
 }
 
 
+/**
+ * MP3 extractor.
+ *
+ * @param {Uint8Array} bytes
+ * @param {Number} offset
+ * @returns {Uint8Array}
+ */
+export function extractMP3(bytes, offset) {
+    const stream = new Stream(bytes.slice(offset));
+
+    // Constants for flag byte.
+    const bitRateIndexes = ["free", 32000, 40000, 48000, 56000, 64000, 80000, 96000, 112000, 128000, 160000, 192000, 224000, 256000, 320000, "bad"];
+
+    const samplingRateFrequencyIndex = [44100, 48000, 32000, "reserved"];
+
+    // ID3 tag, move over it.
+    if ((stream.getBytes(3).toString() === [0x49, 0x44, 0x33].toString())) {
+        stream.moveTo(6);
+        const tagSize = (stream.readInt(1) << 21) | (stream.readInt(1) << 14) | (stream.readInt(1) << 7) | stream.readInt(1);
+        stream.moveForwardsBy(tagSize);
+    } else {
+        stream.moveTo(0);
+    }
+
+    // Loop over all the frame headers in the file.
+    while (stream.hasMore()) {
+
+        // If it has an old TAG frame at the end of it, fixed size, 128 bytes.
+        if (stream.getBytes(3) === [0x54, 0x41, 0x47].toString()) {
+            stream.moveForwardsBy(125);
+            break;
+        }
+
+        // If not start of frame.
+        if (stream.getBytes(2).toString() !== [0xff, 0xfb].toString()) {
+            stream.moveBackwardsBy(2);
+            break;
+        }
+
+        // Read flag byte.
+        const flags = stream.readInt(1);
+
+        // Extract frame bit rate from flag byte.
+        const bitRate = bitRateIndexes[flags >> 4];
+
+        // Extract frame sample rate from flag byte.
+        const sampleRate = samplingRateFrequencyIndex[(flags & 0x0f) >> 2];
+
+        // Padding if the frame size is not a multiple of the bitrate.
+        const padding = (flags & 0x02) >> 1;
+
+        // Things that are either not standard or undocumented.
+        if (bitRate === "free" || bitRate === "bad" || sampleRate === "reserved") {
+            stream.moveBackwardsBy(1);
+            break;
+        }
+
+        // Formula: FrameLength = (144 * BitRate / SampleRate ) + Padding
+        const frameSize = Math.floor(((144 * bitRate) / sampleRate) + padding);
+
+        // If the next move goes past the end of the bytestream then extract the entire bytestream.
+        // We assume complete frames in the above formula because there is no field that suggests otherwise.
+        if ((stream.position + frameSize) > stream.length) {
+            stream.moveTo(stream.length);
+            break;
+        } else {
+            stream.moveForwardsBy(frameSize - 3);
+        }
+    }
+    return stream.carve();
+}
+
+
 /**
  * FLV extractor.
  *
@@ -3075,15 +3374,127 @@ export function extractSQLITE(bytes, offset) {
 export function extractPListXML(bytes, offset) {
     const stream = new Stream(bytes.slice(offset));
 
-    // Find closing tag (</plist>)
-    stream.continueUntil([0x3c, 0x2f, 0x70, 0x6c, 0x69, 0x73, 0x74, 0x3e]);
-    stream.moveForwardsBy(8);
+    let braceCount = 0;
+
+    // Continue to the first (<plist).
+    stream.continueUntil([0x3c, 0x70, 0x6c, 0x69, 0x73, 0x74]);
+    stream.moveForwardsBy(6);
+    braceCount++;
+
+    // While we have an unequal amount of braces.
+    while (braceCount > 0 && stream.hasMore()) {
+        if (stream.readInt(1) === 0x3c) {
+
+            // If we hit an <plist.
+            if (stream.getBytes(5).join("") === [0x70, 0x6c, 0x69, 0x73, 0x74].join("")) {
+                braceCount++;
+            } else {
+                stream.moveBackwardsBy(5);
+            }
+
+            // If we hit an </plist>.
+            if (stream.getBytes(7).join("") === [0x2f, 0x70, 0x6c, 0x69, 0x73, 0x74, 0x3e].join("")) {
+                braceCount--;
+            } else {
+                stream.moveBackwardsBy(7);
+            }
+        }
+    }
     stream.consumeIf(0x0a);
 
     return stream.carve();
 }
 
 
+/**
+ * OLE2 extractor.
+ *
+ * @param {Uint8Array} bytes
+ * @param {number} offset
+ * @returns {Uint8Array}
+ */
+export function extractOLE2(bytes, offset) {
+    const stream = new Stream(bytes.slice(offset));
+    const entries = [
+        [[0x52, 0x00, 0x6f, 0x00, 0x6f, 0x00, 0x74, 0x00, 0x20, 0x00, 0x45, 0x00, 0x6e, 0x00, 0x74, 0x00, 0x72, 0x00, 0x79], 19, "Root Entry"],
+        [[0x57, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x6b, 0x00, 0x62, 0x00, 0x6f, 0x00, 0x6f, 0x00, 0x6b], 15, "Workbook"],
+        [[0x43, 0x00, 0x75, 0x00, 0x72, 0x00, 0x72, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x74, 0x00, 0x20, 0x00, 0x55, 0x00, 0x73, 0x00, 0x65, 0x00, 0x72],  23,  "Current User"],
+        [[0x50, 0x00, 0x6f, 0x00, 0x77, 0x00, 0x65, 0x00, 0x72, 0x00, 0x50, 0x00, 0x6f, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x74, 0x00, 0x20, 0x00, 0x44, 0x00, 0x6f, 0x00, 0x63, 0x00, 0x75, 0x00, 0x6d, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x74], 37, "PowerPoint Document"],
+        [[0x57, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x64, 0x00, 0x44, 0x00, 0x6f, 0x00, 0x63, 0x00, 0x75, 0x00, 0x6d, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x74], 23, "WordDocument"],
+        [[0x44, 0x00, 0x61, 0x00, 0x74, 0x00, 0x61], 7, "Data"],
+        [[0x50, 0x00, 0x69, 0x00, 0x63, 0x00, 0x74, 0x00, 0x75, 0x00, 0x72, 0x00, 0x65, 0x00, 0x73], 15, "Pictures"],
+        [[0x31, 0x00, 0x54, 0x00, 0x61, 0x00, 0x62, 0x00, 0x6c, 0x00, 0x65], 11, "1Table"],
+        [[0x05, 0x00, 0x53, 0x00, 0x75, 0x00, 0x6d, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x72, 0x00, 0x79, 0x00, 0x49, 0x00, 0x6e, 0x00, 0x66, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e], 37, "SummaryInformation"],
+        [[0x05, 0x00, 0x44, 0x00, 0x6f, 0x00, 0x63, 0x00, 0x75, 0x00, 0x6d, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x74, 0x00, 0x53, 0x00, 0x75, 0x00, 0x6d, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x72, 0x00, 0x79, 0x00, 0x49, 0x00, 0x6e, 0x00, 0x66, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e], 53, "DocumentSummaryInformation"],
+        [[0x43, 0x00, 0x6f, 0x00, 0x6d, 0x00, 0x70, 0x00, 0x4f, 0x00, 0x62, 0x00, 0x6a], 13, "Comp Obj"],
+        [[0x01, 0x00], 2, "Entry"]
+    ];
+    let endianness = "le";
+
+    // Move to endianess field.
+    stream.moveForwardsBy(28);
+    if (stream.readInt(2, endianness) === 0xfffe)
+        endianness = "be";
+
+    // Calculate the size of the normal sectors.
+    const sizeOfSector = 2 ** stream.readInt(2, endianness);
+
+    // Move to root directory offset field.
+    stream.moveTo(48);
+
+    // Read root directory offset.
+    const rootStuff  = stream.readInt(4, endianness);
+
+    // Calculate root directory offset.
+    let total = 512 + (rootStuff * sizeOfSector);
+    stream.moveTo(total);
+
+    // While valid directory entries.
+    let found = true;
+    while (found) {
+        found = false;
+
+        // Attempt to determine what directory entry it is.
+        for (const element of entries) {
+
+            // If the byte pattern matches.
+            if (stream.getBytes(element[1]).join("") === element[0].join("")) {
+                stream.moveBackwardsBy(element[1]);
+                found = true;
+
+                // Move forwards by the size of the comp obj.
+                if (element[2] === "Comp Obj") {
+
+                    // The size of the Comp Obj entry - 128. Since we add 128 later.
+                    total += 128 * 6;
+                    stream.moveTo(total);
+                } else if (element[2] === "Entry") {
+
+                    // If there is an entry move backwards by 126 to then move forwards by 128. Hence a total displacement of 2.
+                    stream.moveBackwardsBy(126);
+                }
+                break;
+            }
+            stream.moveBackwardsBy(element[1]);
+        }
+
+        // If we have found a valid entry, move forwards by 128.
+        if (found) {
+
+            // Every entry is at least 128 in size, some are bigger which is dealt with by the above if statement.
+            total += 128;
+            stream.moveForwardsBy(128);
+        }
+    }
+
+    // Round up to a multiple of 512.
+    total = Math.ceil(total / 512) * 512;
+
+    stream.moveTo(total);
+    return stream.carve();
+}
+
+
 /**
  * GZIP extractor.
  *
@@ -3241,6 +3652,37 @@ export function extractXZ(bytes, offset) {
 }
 
 
+/**
+ * DEB extractor.
+ *
+ * @param {Uint8Array} bytes
+ * @param {Number} offset
+ */
+export function extractDEB(bytes, offset) {
+    const stream = new Stream(bytes.slice(offset));
+
+    // Move past !<arch>
+    stream.moveForwardsBy(8);
+    while (stream.hasMore()) {
+
+        // Move to size field.
+        stream.moveForwardsBy(48);
+        let fsize= "";
+
+        // Convert size to a usable number.
+        for (const elem of stream.getBytes(10)) {
+            fsize += String.fromCharCode(elem);
+        }
+        fsize = parseInt(fsize.trim(), 10);
+
+        // Move past `\n
+        stream.moveForwardsBy(2);
+        stream.moveForwardsBy(fsize);
+    }
+    return stream.carve();
+}
+
+
 /**
  * ELF extractor.
  *
@@ -3542,3 +3984,158 @@ export function extractEVT(bytes, offset) {
     stream.moveForwardsBy(eofSize-4);
     return stream.carve();
 }
+
+
+/**
+ * DMP extractor.
+ *
+ * @param {Uint8Array} bytes
+ * @param {Number} offset
+ * @returns {Uint8Array}
+ */
+export function extractDMP(bytes, offset) {
+    const stream = new Stream(bytes.slice(offset));
+
+    // Move to fileSize field.
+    stream.moveTo(0x70);
+
+    // Multiply number of pages by page size. Plus 1 since the header is a page.
+    stream.moveTo((stream.readInt(4, "le") + 1) * 0x1000);
+
+    return stream.carve();
+}
+
+
+/**
+ * PF extractor.
+ *
+ * @param {Uint8Array} bytes
+ * @param {Number} offset
+ * @returns {Uint8Array}
+ */
+export function extractPF(bytes, offset) {
+    const stream = new Stream(bytes.slice(offset));
+
+    // Move to file size.
+    stream.moveTo(12);
+    stream.moveTo(stream.readInt(4, "be"));
+
+    return stream.carve();
+}
+
+
+/**
+ * PF (Win 10) extractor.
+ *
+ * @param {Uint8Array} bytes
+ * @param {Number} offset
+ * @returns {Uint8Array}
+ */
+export function extractPFWin10(bytes, offset) {
+    const stream = new Stream(bytes.slice(offset));
+
+    // Read in file size.
+    stream.moveTo(stream.readInt(4, "be"));
+
+    return stream.carve();
+}
+
+
+/**
+ * LNK extractor.
+ *
+ * @param {Uint8Array} bytes
+ * @param {Number} offset
+ * @returns {Uint8Array}
+ */
+export function extractLNK(bytes, offset) {
+    const stream = new Stream(bytes.slice(offset));
+
+    // Move to file size field.
+    stream.moveTo(0x34);
+    stream.moveTo(stream.readInt(4, "le"));
+
+    return stream.carve();
+}
+
+
+/**
+ * LZOP extractor.
+ *
+ * @param {Uint8Array} bytes
+ * @param {Number} offset
+ * @returns {Uint8Array}
+ */
+export function extractLZOP(bytes, offset) {
+    const stream = new Stream(bytes.slice(offset));
+
+    // Flag bits.
+    const F_ADLER32_D = 0x00000001;
+    const F_ADLER32_C = 0x00000002;
+    const F_CRC32_D = 0x00000100;
+    const F_CRC32_C = 0x00000200;
+    const F_H_FILTER = 0x00000800;
+    const F_H_EXTRA_FIELD = 0x00000040;
+
+    let numCheckSumC = 0, numCheckSumD = 0;
+
+    // Move over magic bytes.
+    stream.moveForwardsBy(9);
+
+    const version = stream.readInt(2, "be");
+
+    // Move to flag register offset.
+    stream.moveForwardsBy(6);
+    const flags = stream.readInt(4, "be");
+
+    if (version & F_H_FILTER)
+        stream.moveForwardsBy(4);
+
+    if (flags & F_ADLER32_C)
+        numCheckSumC++;
+
+    if (flags & F_CRC32_C)
+        numCheckSumC++;
+
+    if (flags & F_ADLER32_D)
+        numCheckSumD++;
+
+    if (flags & F_CRC32_D)
+        numCheckSumD++;
+
+    // Move over the mode, mtime_low
+    stream.moveForwardsBy(8);
+
+    if (version >= 0x0940)
+        stream.moveForwardsBy(4);
+
+    const fnameSize = stream.readInt(1, "be");
+
+    // Move forwards by size of file name and the following 4 byte checksum.
+    stream.moveForwardsBy(fnameSize);
+
+    if (flags & F_H_EXTRA_FIELD) {
+        const extraSize = stream.readInt(4, "be");
+        stream.moveForwardsBy(extraSize);
+    }
+
+    // Move past checksum.
+    stream.moveForwardsBy(4);
+
+    while (stream.hasMore()) {
+        const uncompSize = stream.readInt(4, "be");
+
+        // If data has no length, break.
+        if (uncompSize === 0)
+            break;
+
+        const compSize = stream.readInt(4, "be");
+
+        const numCheckSumSkip = (uncompSize === compSize) ? numCheckSumD : numCheckSumD + numCheckSumC;
+
+        // skip forwards by compressed data size and the size of the checksum(s).
+        stream.moveForwardsBy(compSize + (numCheckSumSkip * 4));
+    }
+    return stream.carve();
+
+}

src/core/lib/Hex.mjs

@@ -23,25 +23,39 @@ import Utils from "../Utils.mjs";
  *
  * // returns "0a:14:1e"
  * toHex([10,20,30], ":");
+ *
+ * // returns "0x0a,0x14,0x1e"
+ * toHex([10,20,30], "0x", 2, ",")
  */
-export function toHex(data, delim=" ", padding=2) {
+export function toHex(data, delim=" ", padding=2, extraDelim="", lineSize=0) {
     if (!data) return "";
     if (data instanceof ArrayBuffer) data = new Uint8Array(data);
 
     let output = "";
+    const prepend = (delim === "0x" || delim === "\\x");
 
     for (let i = 0; i < data.length; i++) {
-        output += data[i].toString(16).padStart(padding, "0") + delim;
+        const hex = data[i].toString(16).padStart(padding, "0");
+        output += prepend ? delim + hex : hex + delim;
+
+        if (extraDelim) {
+            output += extraDelim;
+        }
+        // Add LF after each lineSize amount of bytes but not at the end
+        if ((i !== data.length - 1) && ((i + 1) % lineSize === 0)) {
+            output += "\n";
+        }
     }
 
-    // Add \x or 0x to beginning
-    if (delim === "0x") output = "0x" + output;
-    if (delim === "\\x") output = "\\x" + output;
-
-    if (delim.length)
-        return output.slice(0, -delim.length);
-    else
+    // Remove the extraDelim at the end (if there is one)
+    // and remove the delim at the end, but if it's prepended there's nothing to remove
+    const rTruncLen = extraDelim.length + (prepend ? 0 : delim.length);
+    if (rTruncLen) {
+        // If rTruncLen === 0 then output.slice(0,0) will be returned, which is nothing
+        return output.slice(0, -rTruncLen);
+    } else {
         return output;
+    }
 }
 
 
@@ -87,7 +101,7 @@ export function toHexFast(data) {
  */
 export function fromHex(data, delim="Auto", byteLen=2) {
     if (delim !== "None") {
-        const delimRegex = delim === "Auto" ? /[^a-f\d]/gi : Utils.regexRep(delim);
+        const delimRegex = delim === "Auto" ? /[^a-f\d]|(0x)/gi : Utils.regexRep(delim);
         data = data.replace(delimRegex, "");
     }
 
@@ -102,7 +116,7 @@ export function fromHex(data, delim="Auto", byteLen=2) {
 /**
  * To Hexadecimal delimiters.
  */
-export const TO_HEX_DELIM_OPTIONS = ["Space", "Percent", "Comma", "Semi-colon", "Colon", "Line feed", "CRLF", "0x", "\\x", "None"];
+export const TO_HEX_DELIM_OPTIONS = ["Space", "Percent", "Comma", "Semi-colon", "Colon", "Line feed", "CRLF", "0x", "0x with comma", "\\x", "None"];
 
 
 /**

src/core/lib/IP.mjs

@@ -26,7 +26,7 @@ export function ipv4CidrRange(cidr, includeNetworkInfo, enumerateAddresses, allo
     let output = "";
 
     if (cidrRange < 0 || cidrRange > 31) {
-        return "IPv4 CIDR must be less than 32";
+        throw new OperationError("IPv4 CIDR must be less than 32");
     }
 
     const mask = ~(0xFFFFFFFF >>> cidrRange),
@@ -64,7 +64,7 @@ export function ipv6CidrRange(cidr, includeNetworkInfo) {
         cidrRange = parseInt(cidr[cidr.length-1], 10);
 
     if (cidrRange < 0 || cidrRange > 127) {
-        return "IPv6 CIDR must be less than 128";
+        throw new OperationError("IPv6 CIDR must be less than 128");
     }
 
     const ip1 = new Array(8),
@@ -211,7 +211,7 @@ export function ipv4ListedRange(match, includeNetworkInfo, enumerateAddresses, a
         const network = strToIpv4(ipv4CidrList[i].split("/")[0]);
         const cidrRange = parseInt(ipv4CidrList[i].split("/")[1], 10);
         if (cidrRange < 0 || cidrRange > 31) {
-            return "IPv4 CIDR must be less than 32";
+            throw new OperationError("IPv4 CIDR must be less than 32");
         }
         const mask = ~(0xFFFFFFFF >>> cidrRange),
             cidrIp1 = network & mask,
@@ -254,7 +254,7 @@ export function ipv6ListedRange(match, includeNetworkInfo) {
         const cidrRange = parseInt(ipv6CidrList[i].split("/")[1], 10);
 
         if (cidrRange < 0 || cidrRange > 127) {
-            return "IPv6 CIDR must be less than 128";
+            throw new OperationError("IPv6 CIDR must be less than 128");
         }
 
         const cidrIp1 = new Array(8),

src/core/lib/Lorenz.mjs

@@ -0,0 +1,156 @@
+/**
+ * Resources required by the Lorenz SZ40/42 and Colossus
+ *
+ * @author VirtualColossus [martin@virtualcolossus.co.uk]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+export const SWITCHES = [
+    {name: "Up (.)", value: "."},
+    {name: "Centre", value: ""},
+    {name: "Down (x)", value: "x"}
+];
+
+export const VALID_ITA2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ34589+-./";
+
+export const ITA2_TABLE = {
+    "A": "11000",
+    "B": "10011",
+    "C": "01110",
+    "D": "10010",
+    "E": "10000",
+    "F": "10110",
+    "G": "01011",
+    "H": "00101",
+    "I": "01100",
+    "J": "11010",
+    "K": "11110",
+    "L": "01001",
+    "M": "00111",
+    "N": "00110",
+    "O": "00011",
+    "P": "01101",
+    "Q": "11101",
+    "R": "01010",
+    "S": "10100",
+    "T": "00001",
+    "U": "11100",
+    "V": "01111",
+    "W": "11001",
+    "X": "10111",
+    "Y": "10101",
+    "Z": "10001",
+    "3": "00010",
+    "4": "01000",
+    "9": "00100",
+    "/": "00000",
+    " ": "00100",
+    ".": "00100",
+    "8": "11111",
+    "5": "11011",
+    "-": "11111",
+    "+": "11011"
+};
+
+export const ROTOR_SIZES = {
+    S1: 43,
+    S2: 47,
+    S3: 51,
+    S4: 53,
+    S5: 59,
+    M37: 37,
+    M61: 61,
+    X1: 41,
+    X2: 31,
+    X3: 29,
+    X4: 26,
+    X5: 23
+};
+
+/**
+ * Initial rotor patterns
+ */
+export const INIT_PATTERNS = {
+    "No Pattern": {
+        "X": {
+            1: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            2: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            3: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            4: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            5: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+        },
+        "S": {
+            1: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            2: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            3: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            4: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            5: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+        },
+        "M": {
+            1: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            2: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+        }
+
+    },
+    "KH Pattern": {
+        "X": {
+            1: [0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0],
+            2: [1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0],
+            3: [0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0],
+            4: [1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0],
+            5: [1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0]
+        },
+        "S": {
+            1: [0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1],
+            2: [0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1],
+            3: [0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1],
+            4: [0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0],
+            5: [1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0]
+        },
+        "M":  {
+            1: [0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0],
+            2: [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0]
+        }
+    },
+    "ZMUG Pattern":  {
+        "X": {
+            1: [0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0],
+            2: [1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0],
+            3: [0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0],
+            4: [1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1],
+            5: [0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1]
+        },
+        "S": {
+            1: [1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0],
+            2: [0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1],
+            3: [0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1],
+            4: [0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1],
+            5: [1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0]
+        },
+        "M": {
+            1: [1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1],
+            2: [0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1]
+        }
+    },
+    "BREAM Pattern": {
+        "X": {
+            1: [0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0],
+            2: [0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1],
+            3: [1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0],
+            4: [1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0],
+            5: [0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0]
+        },
+        "S": {
+            1: [0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0],
+            2: [1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0],
+            3: [1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1],
+            4: [0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1],
+            5: [1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]
+        },
+        "M": {
+            1: [1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1],
+            2: [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1]
+        }
+    }
+};

src/core/lib/Magic.mjs

@@ -2,7 +2,7 @@ import OperationConfig from "../config/OperationConfig.json";
 import Utils, { isWorkerEnvironment } from "../Utils.mjs";
 import Recipe from "../Recipe.mjs";
 import Dish from "../Dish.mjs";
-import {detectFileType} from "./FileType.mjs";
+import {detectFileType, isType} from "./FileType.mjs";
 import chiSquared from "chi-squared";
 
 /**
@@ -19,31 +19,38 @@ class Magic {
      * Magic constructor.
      *
      * @param {ArrayBuffer} buf
-     * @param {Object[]} [opPatterns]
+     * @param {Object[]} [opCriteria]
+     * @param {Object} [prevOp]
      */
-    constructor(buf, opPatterns) {
+    constructor(buf, opCriteria=Magic._generateOpCriteria(), prevOp=null) {
         this.inputBuffer = new Uint8Array(buf);
         this.inputStr = Utils.arrayBufferToStr(buf);
-        this.opPatterns = opPatterns || Magic._generateOpPatterns();
+        this.opCriteria = opCriteria;
+        this.prevOp = prevOp;
     }
 
     /**
-     * Finds operations that claim to be able to decode the input based on regular
-     * expression matches.
+     * Finds operations that claim to be able to decode the input based on various criteria.
      *
      * @returns {Object[]}
      */
-    findMatchingOps() {
-        const matches = [];
+    findMatchingInputOps() {
+        const matches = [],
+            inputEntropy = this.calcEntropy();
 
-        for (let i = 0; i < this.opPatterns.length; i++) {
-            const pattern = this.opPatterns[i],
-                regex = new RegExp(pattern.match, pattern.flags);
+        this.opCriteria.forEach(check => {
+            // If the input doesn't lie in the required entropy range, move on
+            if (check.entropyRange &&
+                (inputEntropy < check.entropyRange[0] ||
+                inputEntropy > check.entropyRange[1]))
+                return;
+            // If the input doesn't match the pattern, move on
+            if (check.pattern &&
+                !check.pattern.test(this.inputStr))
+                return;
 
-            if (regex.test(this.inputStr)) {
-                matches.push(pattern);
-            }
-        }
+            matches.push(check);
+        });
 
         return matches;
     }
@@ -185,8 +192,10 @@ class Magic {
      *
      * @returns {number}
      */
-    calcEntropy() {
-        const prob = this._freqDist();
+    calcEntropy(data=this.inputBuffer, standalone=false) {
+        if (!standalone && this.inputEntropy) return this.inputEntropy;
+
+        const prob = this._freqDist(data, standalone);
         let entropy = 0,
             p;
 
@@ -195,6 +204,8 @@ class Magic {
             if (p === 0) continue;
             entropy += p * Math.log(p) / Math.log(2);
         }
+
+        if (!standalone) this.inputEntropy = -entropy;
         return -entropy;
     }
 
@@ -264,25 +275,59 @@ class Magic {
         return results;
     }
 
+    /**
+     * Checks whether the data passes output criteria for an operation check
+     *
+     * @param {ArrayBuffer} data
+     * @param {Object} criteria
+     * @returns {boolean}
+     */
+    outputCheckPasses(data, criteria) {
+        if (criteria.pattern) {
+            const dataStr = Utils.arrayBufferToStr(data),
+                regex = new RegExp(criteria.pattern, criteria.flags);
+            if (!regex.test(dataStr))
+                return false;
+        }
+        if (criteria.entropyRange) {
+            const dataEntropy = this.calcEntropy(data, true);
+            if (dataEntropy < criteria.entropyRange[0] || dataEntropy > criteria.entropyRange[1])
+                return false;
+        }
+        if (criteria.mime &&
+            !isType(criteria.mime, data))
+            return false;
+
+        return true;
+    }
+
     /**
      * Speculatively executes matching operations, recording metadata of each result.
      *
      * @param {number} [depth=0] - How many levels to try to execute
      * @param {boolean} [extLang=false] - Extensive language support (false = only check the most
-     *                                    common Internet languages)
+     *     common Internet languages)
      * @param {boolean} [intensive=false] - Run brute-forcing on each branch (significantly affects
-     *                                      performance)
+     *     performance)
      * @param {Object[]} [recipeConfig=[]] - The recipe configuration up to this point
      * @param {boolean} [useful=false] - Whether the current recipe should be scored highly
-     * @param {string} [crib=null] - The regex crib provided by the user, for filtering the operation output
+     * @param {string} [crib=null] - The regex crib provided by the user, for filtering the operation
+     *     output
      * @returns {Object[]} - A sorted list of the recipes most likely to result in correct decoding
      */
-    async speculativeExecution(depth=0, extLang=false, intensive=false, recipeConfig=[], useful=false, crib=null) {
+    async speculativeExecution(
+        depth=0,
+        extLang=false,
+        intensive=false,
+        recipeConfig=[],
+        useful=false,
+        crib=null) {
+
+        // If we have reached the recursion depth, return
         if (depth < 0) return [];
 
         // Find any operations that can be run on this data
-        const matchingOps = this.findMatchingOps();
-
+        const matchingOps = this.findMatchingInputOps();
         let results = [];
 
         // Record the properties of the current data
@@ -308,17 +353,21 @@ class Magic {
                 },
                 output = await this._runRecipe([opConfig]);
 
-            // If the recipe is repeating and returning the same data, do not continue
-            if (prevOp && op.op === prevOp.op && _buffersEqual(output, this.inputBuffer)) {
-                return;
-            }
-
             // If the recipe returned an empty buffer, do not continue
             if (_buffersEqual(output, new ArrayBuffer())) {
                 return;
             }
 
-            const magic = new Magic(output, this.opPatterns),
+            // If the recipe is repeating and returning the same data, do not continue
+            if (prevOp && op.op === prevOp.op && _buffersEqual(output, this.inputBuffer)) {
+                return;
+            }
+
+            // If the output criteria for this op doesn't match the output, do not continue
+            if (op.output && !this.outputCheckPasses(output, op.output))
+                return;
+
+            const magic = new Magic(output, this.opCriteria, OperationConfig[op.op]),
                 speculativeResults = await magic.speculativeExecution(
                     depth-1, extLang, intensive, [...recipeConfig, opConfig], op.useful, crib);
 
@@ -330,7 +379,7 @@ class Magic {
             const bfEncodings = await this.bruteForce();
 
             await Promise.all(bfEncodings.map(async enc => {
-                const magic = new Magic(enc.data, this.opPatterns),
+                const magic = new Magic(enc.data, this.opCriteria, undefined),
                     bfResults = await magic.speculativeExecution(
                         depth-1, extLang, false, [...recipeConfig, enc.conf], false, crib);
 
@@ -345,7 +394,8 @@ class Magic {
                 r.languageScores[0].probability > 0 ||    // Some kind of language was found
                 r.fileType ||                             // A file was found
                 r.isUTF8 ||                               // UTF-8 was found
-                r.matchingOps.length                      // A matching op was found
+                r.matchingOps.length ||                   // A matching op was found
+                r.matchesCrib                             // The crib matches
             )
         );
 
@@ -376,9 +426,10 @@ class Magic {
             bScore += b.entropy;
 
             // A result with no recipe but matching ops suggests there are better options
-            if ((!a.recipe.length && a.matchingOps.length) &&
-                b.recipe.length)
+            if ((!a.recipe.length && a.matchingOps.length) && b.recipe.length)
                 return 1;
+            if ((!b.recipe.length && b.matchingOps.length) && a.recipe.length)
+                return -1;
 
             return aScore - bScore;
         });
@@ -403,7 +454,7 @@ class Magic {
             await recipe.execute(dish);
             // Return an empty buffer if the recipe did not run to completion
             if (recipe.lastRunOp === recipe.opList[recipe.opList.length - 1]) {
-                return dish.get(Dish.ARRAY_BUFFER);
+                return await dish.get(Dish.ARRAY_BUFFER);
             } else {
                 return new ArrayBuffer();
             }
@@ -417,14 +468,16 @@ class Magic {
      * Calculates the number of times each byte appears in the input as a percentage
      *
      * @private
+     * @param {ArrayBuffer} [data]
+     * @param {boolean} [standalone]
      * @returns {number[]}
      */
-    _freqDist() {
-        if (this.freqDist) return this.freqDist;
+    _freqDist(data=this.inputBuffer, standalone=false) {
+        if (!standalone && this.freqDist) return this.freqDist;
 
-        const len = this.inputBuffer.length;
+        const len = data.length,
+            counts = new Array(256).fill(0);
         let i = len;
-        const counts = new Array(256).fill(0);
 
         if (!len) {
             this.freqDist = counts;
@@ -432,13 +485,15 @@ class Magic {
         }
 
         while (i--) {
-            counts[this.inputBuffer[i]]++;
+            counts[data[i]]++;
         }
 
-        this.freqDist = counts.map(c => {
+        const result = counts.map(c => {
             return c / len * 100;
         });
-        return this.freqDist;
+
+        if (!standalone) this.freqDist = result;
+        return result;
     }
 
     /**
@@ -447,24 +502,29 @@ class Magic {
      * @private
      * @returns {Object[]}
      */
-    static _generateOpPatterns() {
-        const opPatterns = [];
+    static _generateOpCriteria() {
+        const opCriteria = [];
 
         for (const op in OperationConfig) {
-            if (!("patterns" in OperationConfig[op])) continue;
+            if (!("checks" in OperationConfig[op]))
+                continue;
 
-            OperationConfig[op].patterns.forEach(pattern => {
-                opPatterns.push({
+            OperationConfig[op].checks.forEach(check => {
+                // Add to the opCriteria list.
+                // Compile the regex here and cache the compiled version so we
+                // don't have to keep calculating it.
+                opCriteria.push({
                     op: op,
-                    match: pattern.match,
-                    flags: pattern.flags,
-                    args: pattern.args,
-                    useful: pattern.useful || false
+                    pattern: check.pattern ? new RegExp(check.pattern, check.flags) : null,
+                    args: check.args,
+                    useful: check.useful,
+                    entropyRange: check.entropyRange,
+                    output: check.output
                 });
             });
         }
 
-        return opPatterns;
+        return opCriteria;
     }
 
     /**

src/core/lib/QRCode.mjs

@@ -9,8 +9,9 @@
 import OperationError from "../errors/OperationError.mjs";
 import jsQR from "jsqr";
 import qr from "qr-image";
-import jimp from "jimp";
 import Utils from "../Utils.mjs";
+import jimplib from "jimp/es/index.js";
+const jimp = jimplib.default ? jimplib.default : jimplib;
 
 /**
  * Parses a QR code image from an image

src/core/lib/Stream.mjs

@@ -303,11 +303,13 @@ export default class Stream {
     /**
      * Returns a slice of the stream up to the current position.
      *
+     * @param {number} [start=0]
+     * @param {number} [finish=this.position]
      * @returns {Uint8Array}
      */
-    carve() {
-        if (this.bitPos > 0) this.position++;
-        return this.bytes.slice(0, this.position);
+    carve(start=0, finish=this.position) {
+        if (this.bitPos > 0) finish++;
+        return this.bytes.slice(start, finish);
     }
 
 }

src/core/operations/A1Z26CipherDecode.mjs

@@ -33,6 +33,38 @@ class A1Z26CipherDecode extends Operation {
                 value: DELIM_OPTIONS
             }
         ];
+        this.checks = [
+            {
+                pattern:  "^\\s*([12]?[0-9] )+[12]?[0-9]\\s*$",
+                flags:  "",
+                args:   ["Space"]
+            },
+            {
+                pattern:  "^\\s*([12]?[0-9],)+[12]?[0-9]\\s*$",
+                flags:  "",
+                args:   ["Comma"]
+            },
+            {
+                pattern:  "^\\s*([12]?[0-9];)+[12]?[0-9]\\s*$",
+                flags:  "",
+                args:   ["Semi-colon"]
+            },
+            {
+                pattern:  "^\\s*([12]?[0-9]:)+[12]?[0-9]\\s*$",
+                flags:  "",
+                args:   ["Colon"]
+            },
+            {
+                pattern:  "^\\s*([12]?[0-9]\\n)+[12]?[0-9]\\s*$",
+                flags:  "",
+                args:   ["Line feed"]
+            },
+            {
+                pattern:  "^\\s*([12]?[0-9]\\r\\n)+[12]?[0-9]\\s*$",
+                flags:  "",
+                args:   ["CRLF"]
+            }
+        ];
     }
 
     /**

src/core/operations/AESDecrypt.mjs

@@ -6,7 +6,7 @@
 
 import Operation from "../Operation.mjs";
 import Utils from "../Utils.mjs";
-import forge from "node-forge/dist/forge.min.js";
+import forge from "node-forge";
 import OperationError from "../errors/OperationError.mjs";
 
 /**

src/core/operations/AESEncrypt.mjs

@@ -6,7 +6,7 @@
 
 import Operation from "../Operation.mjs";
 import Utils from "../Utils.mjs";
-import forge from "node-forge/dist/forge.min.js";
+import forge from "node-forge";
 import OperationError from "../errors/OperationError.mjs";
 
 /**

src/core/operations/AddTextToImage.mjs

@@ -9,7 +9,8 @@ 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";
+import jimplib from "jimp/es/index.js";
+const jimp = jimplib.default ? jimplib.default : jimplib;
 
 /**
  * Add Text To Image operation

src/core/operations/BaconCipherDecode.mjs

@@ -44,6 +44,48 @@ class BaconCipherDecode extends Operation {
                 "value": false
             }
         ];
+        this.checks = [
+            {
+                pattern:  "^\\s*([01]{5}\\s?)+$",
+                flags:  "",
+                args:   ["Standard (I=J and U=V)", "0/1", false]
+            },
+            {
+                pattern:  "^\\s*([01]{5}\\s?)+$",
+                flags:  "",
+                args:   ["Standard (I=J and U=V)", "0/1", true]
+            },
+            {
+                pattern:  "^\\s*([AB]{5}\\s?)+$",
+                flags:  "",
+                args:   ["Standard (I=J and U=V)", "A/B", false]
+            },
+            {
+                pattern:  "^\\s*([AB]{5}\\s?)+$",
+                flags:  "",
+                args:   ["Standard (I=J and U=V)", "A/B", true]
+            },
+            {
+                pattern:  "^\\s*([01]{5}\\s?)+$",
+                flags:  "",
+                args:   ["Complete", "0/1", false]
+            },
+            {
+                pattern:  "^\\s*([01]{5}\\s?)+$",
+                flags:  "",
+                args:   ["Complete", "0/1", true]
+            },
+            {
+                pattern:  "^\\s*([AB]{5}\\s?)+$",
+                flags:  "",
+                args:   ["Complete", "A/B", false]
+            },
+            {
+                pattern:  "^\\s*([AB]{5}\\s?)+$",
+                flags:  "",
+                args:   ["Complete", "A/B", true]
+            }
+        ];
     }
 
     /**

src/core/operations/BlowfishDecrypt.mjs

@@ -6,7 +6,7 @@
 
 import Operation from "../Operation.mjs";
 import Utils from "../Utils.mjs";
-import forge from "node-forge/dist/forge.min.js";
+import forge from "node-forge";
 import OperationError from "../errors/OperationError.mjs";
 import { Blowfish } from "../lib/Blowfish.mjs";
 

src/core/operations/BlowfishEncrypt.mjs

@@ -6,7 +6,7 @@
 
 import Operation from "../Operation.mjs";
 import Utils from "../Utils.mjs";
-import forge from "node-forge/dist/forge.min.js";
+import forge from "node-forge";
 import OperationError from "../errors/OperationError.mjs";
 import { Blowfish } from "../lib/Blowfish.mjs";
 

src/core/operations/BlurImage.mjs

@@ -9,8 +9,9 @@ import OperationError from "../errors/OperationError.mjs";
 import { isWorkerEnvironment } from "../Utils.mjs";
 import { isImage } from "../lib/FileType.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
-import jimp from "jimp";
 import { gaussianBlur } from "../lib/ImageManipulation.mjs";
+import jimplib from "jimp/es/index.js";
+const jimp = jimplib.default ? jimplib.default : jimplib;
 
 /**
  * Blur Image operation

src/core/operations/Bzip2Decompress.mjs

@@ -33,9 +33,9 @@ class Bzip2Decompress extends Operation {
                 value: false
             }
         ];
-        this.patterns = [
+        this.checks = [
             {
-                "match": "^\\x42\\x5a\\x68",
+                "pattern": "^\\x42\\x5a\\x68",
                 "flags": "",
                 "args": []
             }

src/core/operations/CTPH.mjs

@@ -21,7 +21,7 @@ class CTPH extends Operation {
         this.name = "CTPH";
         this.module = "Crypto";
         this.description = "Context Triggered Piecewise Hashing, also called Fuzzy Hashing, can match inputs that have homologies. Such inputs have sequences of identical bytes in the same order, although bytes in between these sequences may be different in both content and length.<br><br>CTPH was originally based on the work of Dr. Andrew Tridgell and a spam email detector called SpamSum. This method was adapted by Jesse Kornblum and published at the DFRWS conference in 2006 in a paper 'Identifying Almost Identical Files Using Context Triggered Piecewise Hashing'.";
-        this.infoURL = "https://forensicswiki.org/wiki/Context_Triggered_Piecewise_Hashing";
+        this.infoURL = "https://forensicswiki.xyz/wiki/index.php?title=Context_Triggered_Piecewise_Hashing";
         this.inputType = "string";
         this.outputType = "string";
         this.args = [];

src/core/operations/CipherSaber2Decrypt.mjs

@@ -0,0 +1,61 @@
+/**
+ * @author n1073645 [n1073645@gmail.com]
+ * @copyright Crown Copyright 2020
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import { encode } from "../lib/CipherSaber2.mjs";
+import Utils from "../Utils.mjs";
+
+/**
+ * CipherSaber2 Decrypt operation
+ */
+class CipherSaber2Decrypt extends Operation {
+
+    /**
+     * CipherSaber2Decrypt constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "CipherSaber2 Decrypt";
+        this.module = "Crypto";
+        this.description = "CipherSaber is a simple symmetric encryption protocol based on the RC4 stream cipher. It gives reasonably strong protection of message confidentiality, yet it's designed to be simple enough that even novice programmers can memorize the algorithm and implement it from scratch.";
+        this.infoURL = "https://wikipedia.org/wiki/CipherSaber";
+        this.inputType = "ArrayBuffer";
+        this.outputType = "ArrayBuffer";
+        this.args = [
+            {
+                name: "Key",
+                type: "toggleString",
+                value: "",
+                toggleValues: ["Hex", "UTF8", "Latin1", "Base64"]
+            },
+            {
+                name: "Rounds",
+                type: "number",
+                value: 20
+            }
+        ];
+    }
+
+    /**
+     * @param {ArrayBuffer} input
+     * @param {Object[]} args
+     * @returns {ArrayBuffer}
+     */
+    run(input, args) {
+        input = new Uint8Array(input);
+        const result = [],
+            key = Utils.convertToByteArray(args[0].string, args[0].option),
+            rounds = args[1];
+
+        const tempIVP = input.slice(0, 10);
+        input = input.slice(10);
+        return new Uint8Array(result.concat(encode(tempIVP, key, rounds, input))).buffer;
+    }
+
+}
+
+export default CipherSaber2Decrypt;

src/core/operations/CipherSaber2Encrypt.mjs

@@ -0,0 +1,65 @@
+/**
+ * @author n1073645 [n1073645@gmail.com]
+ * @copyright Crown Copyright 2020
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import crypto from "crypto";
+import { encode } from "../lib/CipherSaber2.mjs";
+import Utils from "../Utils.mjs";
+
+/**
+ * CipherSaber2 Encrypt operation
+ */
+class CipherSaber2Encrypt extends Operation {
+
+    /**
+     * CipherSaber2Encrypt constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "CipherSaber2 Encrypt";
+        this.module = "Crypto";
+        this.description = "CipherSaber is a simple symmetric encryption protocol based on the RC4 stream cipher. It gives reasonably strong protection of message confidentiality, yet it's designed to be simple enough that even novice programmers can memorize the algorithm and implement it from scratch.";
+        this.infoURL = "https://wikipedia.org/wiki/CipherSaber";
+        this.inputType = "ArrayBuffer";
+        this.outputType = "ArrayBuffer";
+        this.args = [
+            {
+                name: "Key",
+                type: "toggleString",
+                value: "",
+                toggleValues: ["Hex", "UTF8", "Latin1", "Base64"]
+            },
+            {
+                name: "Rounds",
+                type: "number",
+                value: 20
+            }
+        ];
+    }
+
+    /**
+     * @param {ArrayBuffer} input
+     * @param {Object[]} args
+     * @returns {ArrayBuffer}
+     */
+    run(input, args) {
+        input = new Uint8Array(input);
+        const result = [],
+            key = Utils.convertToByteArray(args[0].string, args[0].option),
+            rounds = args[1];
+
+        // Assign into initialisation vector based on cipher mode.
+        const tempIVP = crypto.randomBytes(10);
+        for (let m = 0; m < 10; m++)
+            result.push(tempIVP[m]);
+
+        return new Uint8Array(result.concat(encode(tempIVP, key, rounds, input))).buffer;
+    }
+
+}
+
+export default CipherSaber2Encrypt;

src/core/operations/Colossus.mjs

@@ -0,0 +1,572 @@
+/**
+ * Emulation of Colossus.
+ *
+ * @author VirtualColossus [martin@virtualcolossus.co.uk]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import { ColossusComputer } from "../lib/Colossus.mjs";
+import { SWITCHES, VALID_ITA2 } from "../lib/Lorenz.mjs";
+
+/**
+ * Colossus operation
+ */
+class Colossus extends Operation {
+
+    /**
+     * Colossus constructor
+     */
+    constructor() {
+        super();
+        this.name = "Colossus";
+        this.module = "Bletchley";
+        this.description = "Colossus is the name of the world's first electronic computer. Ten Colossi were designed by Tommy Flowers and built at the Post Office Research Labs at Dollis Hill in 1943 during World War 2. They assisted with the breaking of the German Lorenz cipher attachment, a machine created to encipher communications between Hitler and his generals on the front lines.<br><br>To learn more, Virtual Colossus, an online, browser based simulation of a Colossus computer is available at <a href='https://virtualcolossus.co.uk' target='_blank'>virtualcolossus.co.uk</a>.<br><br>A more detailed description of this operation can be found <a href='https://github.com/gchq/CyberChef/wiki/Colossus' target='_blank'>here</a>.";
+        this.infoURL = "https://wikipedia.org/wiki/Colossus_computer";
+        this.inputType = "string";
+        this.outputType = "JSON";
+        this.presentType = "html";
+        this.args = [
+            {
+                name: "Input",
+                type: "label"
+            },
+            {
+                name: "Pattern",
+                type: "option",
+                value: ["KH Pattern", "ZMUG Pattern", "BREAM Pattern"]
+            },
+            {
+                name: "QBusZ",
+                type: "option",
+                value: ["", "Z", "ΔZ"]
+            },
+            {
+                name: "QBusΧ",
+                type: "option",
+                value: ["", "Χ", "ΔΧ"]
+            },
+            {
+                name: "QBusΨ",
+                type: "option",
+                value: ["", "Ψ", "ΔΨ"]
+            },
+            {
+                name: "Limitation",
+                type: "option",
+                value: ["None", "Χ2", "Χ2 + P5", "X2 + Ψ1", "X2 + Ψ1 + P5"]
+            },
+            {
+                name: "K Rack Option",
+                type: "argSelector",
+                value: [
+                    {
+                        name: "Select Program",
+                        on: [7],
+                        off: [8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40]
+                    },
+                    {
+                        name: "Top Section - Conditional",
+                        on: [8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30],
+                        off: [7, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40]
+                    },
+                    {
+                        name: "Bottom Section - Addition",
+                        on: [31, 32, 33, 34, 35, 36, 37, 38, 39, 40],
+                        off: [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30]
+                    },
+                    {
+                        name: "Advanced",
+                        on: [8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40],
+                        off: [7]
+                    }
+                ]
+            },
+            {
+                name: "Program to run",
+                type: "option",
+                value: ["", "Letter Count", "1+2=. (1+2 Break In, Find X1,X2)", "4=5=/1=2 (Given X1,X2 find X4,X5)", "/,5,U (Count chars to find X3)"]
+            },
+            {
+                name: "K Rack: Conditional",
+                type: "label"
+            },
+            {
+                name: "R1-Q1",
+                type: "editableOptionShort",
+                value: SWITCHES,
+                defaultIndex: 1
+            },
+            {
+                name: "R1-Q2",
+                type: "editableOptionShort",
+                value: SWITCHES,
+                defaultIndex: 1
+            },
+            {
+                name: "R1-Q3",
+                type: "editableOptionShort",
+                value: SWITCHES,
+                defaultIndex: 1
+            },
+            {
+                name: "R1-Q4",
+                type: "editableOptionShort",
+                value: SWITCHES,
+                defaultIndex: 1
+            },
+            {
+                name: "R1-Q5",
+                type: "editableOptionShort",
+                value: SWITCHES,
+                defaultIndex: 1
+            },
+            {
+                name: "R1-Negate",
+                type: "boolean"
+            },
+            {
+                name: "R1-Counter",
+                type: "option",
+                value: ["", "1", "2", "3", "4", "5"]
+            },
+            {
+                name: "R2-Q1",
+                type: "editableOptionShort",
+                value: SWITCHES,
+                defaultIndex: 1
+            },
+            {
+                name: "R2-Q2",
+                type: "editableOptionShort",
+                value: SWITCHES,
+                defaultIndex: 1
+            },
+            {
+                name: "R2-Q3",
+                type: "editableOptionShort",
+                value: SWITCHES,
+                defaultIndex: 1
+            },
+            {
+                name: "R2-Q4",
+                type: "editableOptionShort",
+                value: SWITCHES,
+                defaultIndex: 1
+            },
+            {
+                name: "R2-Q5",
+                type: "editableOptionShort",
+                value: SWITCHES,
+                defaultIndex: 1
+            },
+            {
+                name: "R2-Negate",
+                type: "boolean"
+            },
+            {
+                name: "R2-Counter",
+                type: "option",
+                value: ["", "1", "2", "3", "4", "5"]
+            },
+            {
+                name: "R3-Q1",
+                type: "editableOptionShort",
+                value: SWITCHES,
+                defaultIndex: 1
+            },
+            {
+                name: "R3-Q2",
+                type: "editableOptionShort",
+                value: SWITCHES,
+                defaultIndex: 1
+            },
+            {
+                name: "R3-Q3",
+                type: "editableOptionShort",
+                value: SWITCHES,
+                defaultIndex: 1
+            },
+            {
+                name: "R3-Q4",
+                type: "editableOptionShort",
+                value: SWITCHES,
+                defaultIndex: 1
+            },
+            {
+                name: "R3-Q5",
+                type: "editableOptionShort",
+                value: SWITCHES,
+                defaultIndex: 1
+            },
+            {
+                name: "R3-Negate",
+                type: "boolean"
+            },
+            {
+                name: "R3-Counter",
+                type: "option",
+                value: ["", "1", "2", "3", "4", "5"]
+            },
+            {
+                name: "Negate All",
+                type: "boolean"
+            },
+            {
+                name: "K Rack: Addition",
+                type: "label"
+            },
+            {
+                name: "Add-Q1",
+                type: "boolean"
+            },
+            {
+                name: "Add-Q2",
+                type: "boolean"
+            },
+            {
+                name: "Add-Q3",
+                type: "boolean"
+            },
+            {
+                name: "Add-Q4",
+                type: "boolean"
+            },
+            {
+                name: "Add-Q5",
+                type: "boolean"
+            },
+            {
+                name: "Add-Equals",
+                type: "editableOptionShort",
+                value: SWITCHES,
+                defaultIndex: 1
+            },
+            {
+                name: "Add-Counter1",
+                type: "boolean"
+            },
+            {
+                name: "Add Negate All",
+                type: "boolean"
+            },
+            {
+                name: "Total Motor",
+                type: "editableOptionShort",
+                value: SWITCHES,
+                defaultIndex: 1
+            },
+            {
+                name: "Master Control Panel",
+                type: "label"
+            },
+            {
+                name: "Set Total",
+                type: "number",
+                value: 0
+            },
+            {
+                name: "Fast Step",
+                type: "option",
+                value: ["", "X1", "X2", "X3", "X4", "X5", "M37", "M61", "S1", "S2", "S3", "S4", "S5"]
+            },
+            {
+                name: "Slow Step",
+                type: "option",
+                value: ["", "X1", "X2", "X3", "X4", "X5", "M37", "M61", "S1", "S2", "S3", "S4", "S5"]
+            },
+            {
+                name: "Start Χ1",
+                type: "number",
+                value: 1
+            },
+            {
+                name: "Start Χ2",
+                type: "number",
+                value: 1
+            },
+            {
+                name: "Start Χ3",
+                type: "number",
+                value: 1
+            },
+            {
+                name: "Start Χ4",
+                type: "number",
+                value: 1
+            },
+            {
+                name: "Start Χ5",
+                type: "number",
+                value: 1
+            },
+            {
+                name: "Start M61",
+                type: "number",
+                value: 1
+            },
+            {
+                name: "Start M37",
+                type: "number",
+                value: 1
+            },
+            {
+                name: "Start Ψ1",
+                type: "number",
+                value: 1
+            },
+            {
+                name: "Start Ψ2",
+                type: "number",
+                value: 1
+            },
+            {
+                name: "Start Ψ3",
+                type: "number",
+                value: 1
+            },
+            {
+                name: "Start Ψ4",
+                type: "number",
+                value: 1
+            },
+            {
+                name: "Start Ψ5",
+                type: "number",
+                value: 1
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {Object}
+     */
+    run(input, args) {
+        input = input.toUpperCase();
+        for (const character of input) {
+            if (VALID_ITA2.indexOf(character) === -1) {
+                let errltr = character;
+                if (errltr === "\n") errltr = "Carriage Return";
+                if (errltr === " ") errltr = "Space";
+                throw new OperationError("Invalid ITA2 character : " + errltr);
+            }
+        }
+
+        const pattern = args[1];
+        const qbusin = {
+            "Z": args[2],
+            "Chi": args[3],
+            "Psi": args[4],
+        };
+
+        const limitation = args[5];
+        const lm = [false, false, false];
+        if (limitation.includes("Χ2")) lm[0] = true;
+        if (limitation.includes("Ψ1")) lm[1] = true;
+        if (limitation.includes("P5")) lm[2] = true;
+        const limit = {
+            X2: lm[0], S1: lm[1], P5: lm[2]
+        };
+
+        const KRackOpt = args[6];
+        const setProgram = args[7];
+
+        if (KRackOpt === "Select Program" && setProgram !== "") {
+            args = this.selectProgram(setProgram, args);
+        }
+
+        const re = new RegExp("^$|^[.x]$");
+        for (let qr=0;qr<3;qr++) {
+            for (let a=0;a<5;a++) {
+                if (!re.test(args[((qr*7)+(a+9))]))
+                    throw new OperationError("Switch R"+(qr+1)+"-Q"+(a+1)+" can only be set to blank, . or x");
+            }
+        }
+
+        if (!re.test(args[37])) throw new OperationError("Switch Add-Equals can only be set to blank, . or x");
+        if (!re.test(args[40])) throw new OperationError("Switch Total Motor can only be set to blank, . or x");
+
+        // Q1,Q2,Q3,Q4,Q5,negate,counter1
+        const qbusswitches = {
+            condition: [
+                {Qswitches: [args[9], args[10], args[11], args[12], args[13]], Negate: args[14], Counter: args[15]},
+                {Qswitches: [args[16], args[17], args[18], args[19], args[20]], Negate: args[21], Counter: args[22]},
+                {Qswitches: [args[23], args[24], args[25], args[26], args[27]], Negate: args[28], Counter: args[29]}
+            ],
+            condNegateAll: args[30],
+            addition: [
+                {Qswitches: [args[32], args[33], args[34], args[35], args[36]], Equals: args[37], C1: args[38]}
+            ],
+            addNegateAll: args[39],
+            totalMotor: args[40]
+        };
+
+        const settotal = parseInt(args[42], 10);
+        if (settotal < 0 || settotal > 9999)
+            throw new OperationError("Set Total must be between 0000 and 9999");
+
+        // null|fast|slow for each of S1-5,M1-2,X1-5
+        const control = {
+            fast: args[43],
+            slow: args[44]
+        };
+
+        // Start positions
+        if (args[52]<1 || args[52]>43) throw new OperationError("Ψ1 start must be between 1 and 43");
+        if (args[53]<1 || args[53]>47) throw new OperationError("Ψ2 start must be between 1 and 47");
+        if (args[54]<1 || args[54]>51) throw new OperationError("Ψ3 start must be between 1 and 51");
+        if (args[55]<1 || args[55]>53) throw new OperationError("Ψ4 start must be between 1 and 53");
+        if (args[56]<1 || args[57]>59) throw new OperationError("Ψ5 start must be between 1 and 59");
+        if (args[51]<1 || args[51]>37) throw new OperationError("Μ37 start must be between 1 and 37");
+        if (args[50]<1 || args[50]>61) throw new OperationError("Μ61 start must be between 1 and 61");
+        if (args[45]<1 || args[45]>41) throw new OperationError("Χ1 start must be between 1 and 41");
+        if (args[46]<1 || args[46]>31) throw new OperationError("Χ2 start must be between 1 and 31");
+        if (args[47]<1 || args[47]>29) throw new OperationError("Χ3 start must be between 1 and 29");
+        if (args[48]<1 || args[48]>26) throw new OperationError("Χ4 start must be between 1 and 26");
+        if (args[49]<1 || args[49]>23) throw new OperationError("Χ5 start must be between 1 and 23");
+
+        const starts = {
+            X1: args[45], X2: args[46], X3: args[47], X4: args[48], X5: args[49],
+            M61: args[50], M37: args[51],
+            S1: args[52], S2: args[53], S3: args[54], S4: args[55], S5: args[56]
+        };
+
+        const colossus = new ColossusComputer(input, pattern, qbusin, qbusswitches, control, starts, settotal, limit);
+        const result = colossus.run();
+
+        return result;
+    }
+
+    /**
+     * Select Program
+     *
+     * @param {string} progname
+     * @param {Object[]} args
+     * @returns {Object[]}
+     */
+    selectProgram(progname, args) {
+
+        // Basic Letter Count
+        if (progname === "Letter Count") {
+            // Set Conditional R1 : count every character into counter 1
+            args[9] = "";
+            args[10] = "";
+            args[11] = "";
+            args[12] = "";
+            args[13] = "";
+            args[14] = false;
+            args[15] = "1";
+            // clear Conditional R2 & R3
+            args[22] = "";
+            args[29] = "";
+            // Clear Negate result
+            args[30] = false;
+            // Clear Addition row counter
+            args[38] = false;
+        }
+
+        // Bill Tutte's 1+2 Break In
+        if (progname === "1+2=. (1+2 Break In, Find X1,X2)") {
+            // Clear any other counters
+            args[15] = ""; // Conditional R1
+            args[22] = ""; // Conditional R2
+            args[29] = ""; // Conditional R3
+            // Set Add Q1+Q2=. into Counter 1
+            args[32] = true;
+            args[33] = true;
+            args[34] = false;
+            args[35] = false;
+            args[36] = false;
+            args[37] = ".";
+            args[38] = true;
+        }
+
+        // 4=3=/1=2 : Find X4 & X5 where X1 & X2 are known
+        if (progname === "4=5=/1=2 (Given X1,X2 find X4,X5)") {
+            // Set Conditional R1 : Match NOT ..?.. into counter 1
+            args[9] = ".";
+            args[10] = ".";
+            args[11] = "";
+            args[12] = ".";
+            args[13] = ".";
+            args[14] = true;
+            args[15] = "1";
+            // Set Conditional R2 : AND Match NOT xx?xx into counter 1
+            args[16] = "x";
+            args[17] = "x";
+            args[18] = "";
+            args[19] = "x";
+            args[20] = "x";
+            args[21] = true;
+            args[22] = "1";
+            // clear Conditional R3
+            args[29] = "";
+            // Negate result, giving NOT(NOT Q1 AND NOT Q2) which is equivalent to Q1 OR Q2
+            args[30] = true;
+            // Clear Addition row counter
+            args[38] = false;
+        }
+
+        // /,5,U : Count number of matches of /, 5 & U to find X3
+        if (progname === "/,5,U (Count chars to find X3)") {
+            // Set Conditional R1 : Match / char, ITA2 = ..... into counter 1
+            args[9] = ".";
+            args[10] = ".";
+            args[11] = ".";
+            args[12] = ".";
+            args[13] = ".";
+            args[14] = false;
+            args[15] = "1";
+            // Set Conditional R2 : Match 5 char, ITA2 = xx.xx into counter 2
+            args[16] = "x";
+            args[17] = "x";
+            args[18] = ".";
+            args[19] = "x";
+            args[20] = "x";
+            args[21] = false;
+            args[22] = "2";
+            // Set Conditional R3 : Match U char, ITA2 = xxx.. into counter 3
+            args[23] = "x";
+            args[24] = "x";
+            args[25] = "x";
+            args[26] = ".";
+            args[27] = ".";
+            args[28] = false;
+            args[29] = "3";
+            // Clear Negate result
+            args[30] = false;
+            // Clear Addition row counter
+            args[38] = false;
+        }
+
+        return args;
+    }
+
+    /**
+     * Displays Colossus results in an HTML table
+     *
+     * @param {Object} output
+     * @param {Object[]} output.counters
+     * @returns {html}
+     */
+    present(output) {
+        let html = "Colossus Printer\n\n";
+        html += output.printout + "\n\n";
+        html += "Colossus Counters\n\n";
+        html += "<table class='table table-hover table-sm table-bordered table-nonfluid'><tr><th>C1</th>  <th>C2</th>  <th>C3</th>  <th>C4</th>  <th>C5</th></tr>\n";
+        html += "<tr>";
+        for (const ct of output.counters) {
+            html += `<td>${ct}</td>\n`;
+        }
+        html += "</tr>";
+        html += "</table>";
+        return html;
+    }
+
+}
+
+export default Colossus;

src/core/operations/CompareCTPHHashes.mjs

@@ -24,7 +24,7 @@ class CompareCTPHHashes extends Operation {
         this.name = "Compare CTPH hashes";
         this.module = "Crypto";
         this.description = "Compares two Context Triggered Piecewise Hashing (CTPH) fuzzy hashes to determine the similarity between them on a scale of 0 to 100.";
-        this.infoURL = "https://forensicswiki.org/wiki/Context_Triggered_Piecewise_Hashing";
+        this.infoURL = "https://forensicswiki.xyz/wiki/index.php?title=Context_Triggered_Piecewise_Hashing";
         this.inputType = "string";
         this.outputType = "Number";
         this.args = [

src/core/operations/CompareSSDEEPHashes.mjs

@@ -24,7 +24,7 @@ class CompareSSDEEPHashes extends Operation {
         this.name = "Compare SSDEEP hashes";
         this.module = "Crypto";
         this.description = "Compares two SSDEEP fuzzy hashes to determine the similarity between them on a scale of 0 to 100.";
-        this.infoURL = "https://forensicswiki.org/wiki/Ssdeep";
+        this.infoURL = "https://forensicswiki.xyz/wiki/index.php?title=Ssdeep";
         this.inputType = "string";
         this.outputType = "Number";
         this.args = [

src/core/operations/ContainImage.mjs

@@ -9,7 +9,8 @@ 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";
+import jimplib from "jimp/es/index.js";
+const jimp = jimplib.default ? jimplib.default : jimplib;
 
 /**
  * Contain Image operation

src/core/operations/ConvertImageFormat.mjs

@@ -8,7 +8,8 @@ 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";
+import jimplib from "jimp/es/index.js";
+const jimp = jimplib.default ? jimplib.default : jimplib;
 
 /**
  * Convert Image Format operation
@@ -88,7 +89,7 @@ class ConvertImageFormat extends Operation {
             "Sub": jimp.PNG_FILTER_SUB,
             "Up": jimp.PNG_FILTER_UP,
             "Average": jimp.PNG_FILTER_AVERAGE,
-            "Paeth": jimp.PNG_FILTER_PATH // Incorrect spelling in Jimp library
+            "Paeth": jimp.PNG_FILTER_PATH
         };
 
         const mime = formatMap[format];

src/core/operations/ConvertToNATOAlphabet.mjs

@@ -0,0 +1,82 @@
+/**
+ * @author MarvinJWendt [git@marvinjwendt.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+
+/**
+ * Convert to NATO alphabet operation
+ */
+class ConvertToNATOAlphabet extends Operation {
+    /**
+     * ConvertToNATOAlphabet constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Convert to NATO alphabet";
+        this.module = "Default";
+        this.description = "Converts characters to their representation in the NATO phonetic alphabet.";
+        this.infoURL = "https://wikipedia.org/wiki/NATO_phonetic_alphabet";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        return input.replace(/[a-z0-9,/.]/ig, letter => {
+            return lookup[letter.toUpperCase()];
+        });
+    }
+}
+
+const lookup = {
+    "A": "Alfa ",
+    "B": "Bravo ",
+    "C": "Charlie ",
+    "D": "Delta ",
+    "E": "Echo ",
+    "F": "Foxtrot ",
+    "G": "Golf ",
+    "H": "Hotel ",
+    "I": "India ",
+    "J": "Juliett ",
+    "K": "Kilo ",
+    "L": "Lima ",
+    "M": "Mike ",
+    "N": "November ",
+    "O": "Oscar ",
+    "P": "Papa ",
+    "Q": "Quebec ",
+    "R": "Romeo ",
+    "S": "Sierra ",
+    "T": "Tango ",
+    "U": "Uniform ",
+    "V": "Victor ",
+    "W": "Whiskey ",
+    "X": "X-ray ",
+    "Y": "Yankee ",
+    "Z": "Zulu ",
+    "0": "Zero ",
+    "1": "One ",
+    "2": "Two ",
+    "3": "Three ",
+    "4": "Four ",
+    "5": "Five ",
+    "6": "Six ",
+    "7": "Seven ",
+    "8": "Eight ",
+    "9": "Nine ",
+    ",": "Comma ",
+    "/": "Fraction bar ",
+    ".": "Full stop ",
+};
+
+export default ConvertToNATOAlphabet;

src/core/operations/CoverImage.mjs

@@ -9,7 +9,8 @@ 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";
+import jimplib from "jimp/es/index.js";
+const jimp = jimplib.default ? jimplib.default : jimplib;
 
 /**
  * Cover Image operation

src/core/operations/CropImage.mjs

@@ -9,7 +9,8 @@ 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";
+import jimplib from "jimp/es/index.js";
+const jimp = jimplib.default ? jimplib.default : jimplib;
 
 /**
  * Crop Image operation

src/core/operations/DESDecrypt.mjs

@@ -7,7 +7,7 @@
 import Operation from "../Operation.mjs";
 import Utils from "../Utils.mjs";
 import OperationError from "../errors/OperationError.mjs";
-import forge from "node-forge/dist/forge.min.js";
+import forge from "node-forge";
 
 /**
  * DES Decrypt operation

src/core/operations/DESEncrypt.mjs

@@ -7,7 +7,7 @@
 import Operation from "../Operation.mjs";
 import Utils from "../Utils.mjs";
 import OperationError from "../errors/OperationError.mjs";
-import forge from "node-forge/dist/forge.min.js";
+import forge from "node-forge";
 
 /**
  * DES Encrypt operation

src/core/operations/DechunkHTTPResponse.mjs

@@ -24,6 +24,13 @@ class DechunkHTTPResponse extends Operation {
         this.inputType = "string";
         this.outputType = "string";
         this.args = [];
+        this.checks = [
+            {
+                pattern:  "^[0-9A-F]+\r\n",
+                flags:  "i",
+                args:   []
+            }
+        ];
     }
 
     /**

src/core/operations/DecodeNetBIOSName.mjs

@@ -30,6 +30,13 @@ class DecodeNetBIOSName extends Operation {
                 "value": 65
             }
         ];
+        this.checks = [
+            {
+                pattern:  "^\\s*\\S{32}$",
+                flags:  "",
+                args:   [65]
+            }
+        ];
     }
 
     /**

src/core/operations/DefangIPAddresses.mjs

@@ -25,7 +25,17 @@ class DefangIPAddresses extends Operation {
         this.inputType = "string";
         this.outputType = "string";
         this.args = [];
-
+        this.checks = [
+            {
+                pattern: "^\\s*(([0-9]{1,3}\\.){3}[0-9]{1,3}|([0-9a-f]{4}:){7}[0-9a-f]{4})\\s*$",
+                flags: "i",
+                args: [],
+                output: {
+                    pattern: "^\\s*(([0-9]{1,3}\\[\\.\\]){3}[0-9]{1,3}|([0-9a-f]{4}\\[\\:\\]){7}[0-9a-f]{4})\\s*$",
+                    flags: "i"
+                }
+            }
+        ];
     }
 
     /**

src/core/operations/DerivePBKDF2Key.mjs

@@ -6,7 +6,7 @@
 
 import Operation from "../Operation.mjs";
 import Utils from "../Utils.mjs";
-import forge from "node-forge/dist/forge.min.js";
+import forge from "node-forge";
 
 /**
  * Derive PBKDF2 key operation

src/core/operations/DitherImage.mjs

@@ -9,7 +9,8 @@ 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";
+import jimplib from "jimp/es/index.js";
+const jimp = jimplib.default ? jimplib.default : jimplib;
 
 /**
  * Image Dither operation

src/core/operations/EscapeUnicodeCharacters.mjs

@@ -44,22 +44,22 @@ class EscapeUnicodeCharacters extends Operation {
                 "value": true
             }
         ];
-        this.patterns = [
+        this.checks = [
             {
-                match: "\\\\u(?:[\\da-f]{4,6})",
+                pattern: "\\\\u(?:[\\da-f]{4,6})",
                 flags: "i",
                 args: ["\\u"]
             },
             {
-                match: "%u(?:[\\da-f]{4,6})",
+                pattern: "%u(?:[\\da-f]{4,6})",
                 flags: "i",
                 args: ["%u"]
             },
             {
-                match: "U\\+(?:[\\da-f]{4,6})",
+                pattern: "U\\+(?:[\\da-f]{4,6})",
                 flags: "i",
                 args: ["U+"]
-            },
+            }
         ];
     }
 

src/core/operations/ExtractFiles.mjs

@@ -24,7 +24,7 @@ class ExtractFiles extends Operation {
         this.name = "Extract Files";
         this.module = "Default";
         this.description = "Performs file carving to attempt to extract files from the input.<br><br>This operation is currently capable of carving out the following formats:<ul><li>JPG</li><li>EXE</li><li>ZIP</li><li>PDF</li><li>PNG</li><li>BMP</li><li>FLV</li><li>RTF</li><li>DOCX, PPTX, XLSX</li><li>EPUB</li><li>GZIP</li><li>ZLIB</li><li>ELF, BIN, AXF, O, PRX, SO</li></ul>";
-        this.infoURL = "https://forensicswiki.org/wiki/File_Carving";
+        this.infoURL = "https://forensicswiki.xyz/wiki/index.php?title=File_Carving";
         this.inputType = "ArrayBuffer";
         this.outputType = "List<File>";
         this.presentType = "html";

src/core/operations/ExtractLSB.mjs

@@ -9,7 +9,8 @@ import OperationError from "../errors/OperationError.mjs";
 import Utils from "../Utils.mjs";
 import { fromBinary } from "../lib/Binary.mjs";
 import { isImage } from "../lib/FileType.mjs";
-import jimp from "jimp";
+import jimplib from "jimp/es/index.js";
+const jimp = jimplib.default ? jimplib.default : jimplib;
 
 /**
  * Extract LSB operation

src/core/operations/ExtractRGBA.mjs

@@ -7,7 +7,8 @@
 import Operation from "../Operation.mjs";
 import OperationError from "../errors/OperationError.mjs";
 import { isImage } from "../lib/FileType.mjs";
-import jimp from "jimp";
+import jimplib from "jimp/es/index.js";
+const jimp = jimplib.default ? jimplib.default : jimplib;
 
 import {RGBA_DELIM_OPTIONS} from "../lib/Delim.mjs";
 

src/core/operations/FlipImage.mjs

@@ -9,7 +9,8 @@ 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";
+import jimplib from "jimp/es/index.js";
+const jimp = jimplib.default ? jimplib.default : jimplib;
 
 /**
  * Flip Image operation

src/core/operations/FromBCD.mjs

@@ -49,9 +49,9 @@ class FromBCD extends Operation {
                 "value": FORMAT
             }
         ];
-        this.patterns = [
+        this.checks = [
             {
-                match: "^(?:\\d{4} ){3,}\\d{4}$",
+                pattern: "^(?:\\d{4} ){3,}\\d{4}$",
                 flags: "",
                 args: ["8 4 2 1", true, false, "Nibbles"]
             },

src/core/operations/FromBase32.mjs

@@ -36,12 +36,12 @@ class FromBase32 extends Operation {
                 value: true
             }
         ];
-        this.patterns = [
+        this.checks = [
             {
-                match: "^(?:[A-Z2-7]{8})+(?:[A-Z2-7]{2}={6}|[A-Z2-7]{4}={4}|[A-Z2-7]{5}={3}|[A-Z2-7]{7}={1})?$",
+                pattern: "^(?:[A-Z2-7]{8})+(?:[A-Z2-7]{2}={6}|[A-Z2-7]{4}={4}|[A-Z2-7]{5}={3}|[A-Z2-7]{7}={1})?$",
                 flags: "",
                 args: ["A-Z2-7=", false]
-            },
+            }
         ];
     }
 

src/core/operations/FromBase58.mjs

@@ -38,14 +38,14 @@ class FromBase58 extends Operation {
                 "value": true
             }
         ];
-        this.patterns = [
+        this.checks = [
             {
-                match: "^[1-9A-HJ-NP-Za-km-z]{20,}$",
+                pattern: "^[1-9A-HJ-NP-Za-km-z]{20,}$",
                 flags: "",
                 args: ["123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz", false]
             },
             {
-                match: "^[1-9A-HJ-NP-Za-km-z]{20,}$",
+                pattern: "^[1-9A-HJ-NP-Za-km-z]{20,}$",
                 flags: "",
                 args: ["rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz", false]
             },

src/core/operations/FromBase64.mjs

@@ -36,69 +36,69 @@ class FromBase64 extends Operation {
                 value: true
             }
         ];
-        this.patterns = [
+        this.checks = [
             {
-                match: "^\\s*(?:[A-Z\\d+/]{4})+(?:[A-Z\\d+/]{2}==|[A-Z\\d+/]{3}=)?\\s*$",
+                pattern: "^\\s*(?:[A-Z\\d+/]{4})+(?:[A-Z\\d+/]{2}==|[A-Z\\d+/]{3}=)?\\s*$",
                 flags: "i",
                 args: ["A-Za-z0-9+/=", true]
             },
             {
-                match: "^\\s*[A-Z\\d\\-_]{20,}\\s*$",
+                pattern: "^\\s*[A-Z\\d\\-_]{20,}\\s*$",
                 flags: "i",
                 args: ["A-Za-z0-9-_", true]
             },
             {
-                match: "^\\s*(?:[A-Z\\d+\\-]{4}){5,}(?:[A-Z\\d+\\-]{2}==|[A-Z\\d+\\-]{3}=)?\\s*$",
+                pattern: "^\\s*(?:[A-Z\\d+\\-]{4}){5,}(?:[A-Z\\d+\\-]{2}==|[A-Z\\d+\\-]{3}=)?\\s*$",
                 flags: "i",
                 args: ["A-Za-z0-9+\\-=", true]
             },
             {
-                match: "^\\s*(?:[A-Z\\d./]{4}){5,}(?:[A-Z\\d./]{2}==|[A-Z\\d./]{3}=)?\\s*$",
+                pattern: "^\\s*(?:[A-Z\\d./]{4}){5,}(?:[A-Z\\d./]{2}==|[A-Z\\d./]{3}=)?\\s*$",
                 flags: "i",
                 args: ["./0-9A-Za-z=", true]
             },
             {
-                match: "^\\s*[A-Z\\d_.]{20,}\\s*$",
+                pattern: "^\\s*[A-Z\\d_.]{20,}\\s*$",
                 flags: "i",
                 args: ["A-Za-z0-9_.", true]
             },
             {
-                match: "^\\s*(?:[A-Z\\d._]{4}){5,}(?:[A-Z\\d._]{2}--|[A-Z\\d._]{3}-)?\\s*$",
+                pattern: "^\\s*(?:[A-Z\\d._]{4}){5,}(?:[A-Z\\d._]{2}--|[A-Z\\d._]{3}-)?\\s*$",
                 flags: "i",
                 args: ["A-Za-z0-9._-", true]
             },
             {
-                match: "^\\s*(?:[A-Z\\d+/]{4}){5,}(?:[A-Z\\d+/]{2}==|[A-Z\\d+/]{3}=)?\\s*$",
+                pattern: "^\\s*(?:[A-Z\\d+/]{4}){5,}(?:[A-Z\\d+/]{2}==|[A-Z\\d+/]{3}=)?\\s*$",
                 flags: "i",
                 args: ["0-9a-zA-Z+/=", true]
             },
             {
-                match: "^\\s*(?:[A-Z\\d+/]{4}){5,}(?:[A-Z\\d+/]{2}==|[A-Z\\d+/]{3}=)?\\s*$",
+                pattern: "^\\s*(?:[A-Z\\d+/]{4}){5,}(?:[A-Z\\d+/]{2}==|[A-Z\\d+/]{3}=)?\\s*$",
                 flags: "i",
                 args: ["0-9A-Za-z+/=", true]
             },
             {
-                match: "^[ !\"#$%&'()*+,\\-./\\d:;<=>?@A-Z[\\\\\\]^_]{20,}$",
+                pattern: "^[ !\"#$%&'()*+,\\-./\\d:;<=>?@A-Z[\\\\\\]^_]{20,}$",
                 flags: "",
                 args: [" -_", false]
             },
             {
-                match: "^\\s*[A-Z\\d+\\-]{20,}\\s*$",
+                pattern: "^\\s*[A-Z\\d+\\-]{20,}\\s*$",
                 flags: "i",
                 args: ["+\\-0-9A-Za-z", true]
             },
             {
-                match: "^\\s*[!\"#$%&'()*+,\\-0-689@A-NP-VX-Z[`a-fh-mp-r]{20,}\\s*$",
+                pattern: "^\\s*[!\"#$%&'()*+,\\-0-689@A-NP-VX-Z[`a-fh-mp-r]{20,}\\s*$",
                 flags: "",
                 args: ["!-,-0-689@A-NP-VX-Z[`a-fh-mp-r", true]
             },
             {
-                match: "^\\s*(?:[N-ZA-M\\d+/]{4}){5,}(?:[N-ZA-M\\d+/]{2}==|[N-ZA-M\\d+/]{3}=)?\\s*$",
+                pattern: "^\\s*(?:[N-ZA-M\\d+/]{4}){5,}(?:[N-ZA-M\\d+/]{2}==|[N-ZA-M\\d+/]{3}=)?\\s*$",
                 flags: "i",
                 args: ["N-ZA-Mn-za-m0-9+/=", true]
             },
             {
-                match: "^\\s*[A-Z\\d./]{20,}\\s*$",
+                pattern: "^\\s*[A-Z\\d./]{20,}\\s*$",
                 flags: "i",
                 args: ["./0-9A-Za-z", true]
             },

src/core/operations/FromBinary.mjs

@@ -31,41 +31,46 @@ class FromBinary extends Operation {
                 "name": "Delimiter",
                 "type": "option",
                 "value": BIN_DELIM_OPTIONS
+            },
+            {
+                "name": "Byte Length",
+                "type": "number",
+                "value": 8
             }
         ];
-        this.patterns = [
+        this.checks = [
             {
-                match: "^(?:[01]{8})+$",
+                pattern: "^(?:[01]{8})+$",
                 flags: "",
                 args: ["None"]
             },
             {
-                match: "^(?:[01]{8})(?: [01]{8})*$",
+                pattern: "^(?:[01]{8})(?: [01]{8})*$",
                 flags: "",
                 args: ["Space"]
             },
             {
-                match: "^(?:[01]{8})(?:,[01]{8})*$",
+                pattern: "^(?:[01]{8})(?:,[01]{8})*$",
                 flags: "",
                 args: ["Comma"]
             },
             {
-                match: "^(?:[01]{8})(?:;[01]{8})*$",
+                pattern: "^(?:[01]{8})(?:;[01]{8})*$",
                 flags: "",
                 args: ["Semi-colon"]
             },
             {
-                match: "^(?:[01]{8})(?::[01]{8})*$",
+                pattern: "^(?:[01]{8})(?::[01]{8})*$",
                 flags: "",
                 args: ["Colon"]
             },
             {
-                match: "^(?:[01]{8})(?:\\n[01]{8})*$",
+                pattern: "^(?:[01]{8})(?:\\n[01]{8})*$",
                 flags: "",
                 args: ["Line feed"]
             },
             {
-                match: "^(?:[01]{8})(?:\\r\\n[01]{8})*$",
+                pattern: "^(?:[01]{8})(?:\\r\\n[01]{8})*$",
                 flags: "",
                 args: ["CRLF"]
             },
@@ -78,7 +83,8 @@ class FromBinary extends Operation {
      * @returns {byteArray}
      */
     run(input, args) {
-        return fromBinary(input, args[0]);
+        const byteLen = args[1] ? args[1] : 8;
+        return fromBinary(input, args[0], byteLen);
     }
 
     /**

src/core/operations/FromDecimal.mjs

@@ -36,37 +36,37 @@ class FromDecimal extends Operation {
                 "value": false
             }
         ];
-        this.patterns = [
+        this.checks = [
             {
-                match: "^(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5])(?: (?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5]))*$",
+                pattern: "^(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5])(?: (?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5]))*$",
                 flags: "",
                 args: ["Space", false]
             },
             {
-                match: "^(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5])(?:,(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5]))*$",
+                pattern: "^(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5])(?:,(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5]))*$",
                 flags: "",
                 args: ["Comma", false]
             },
             {
-                match: "^(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5])(?:;(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5]))*$",
+                pattern: "^(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5])(?:;(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5]))*$",
                 flags: "",
                 args: ["Semi-colon", false]
             },
             {
-                match: "^(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5])(?::(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5]))*$",
+                pattern: "^(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5])(?::(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5]))*$",
                 flags: "",
                 args: ["Colon", false]
             },
             {
-                match: "^(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5])(?:\\n(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5]))*$",
+                pattern: "^(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5])(?:\\n(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5]))*$",
                 flags: "",
                 args: ["Line feed", false]
             },
             {
-                match: "^(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5])(?:\\r\\n(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5]))*$",
+                pattern: "^(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5])(?:\\r\\n(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5]))*$",
                 flags: "",
                 args: ["CRLF", false]
-            },
+            }
         ];
     }
 

src/core/operations/FromHTMLEntity.mjs

@@ -25,12 +25,12 @@ class FromHTMLEntity extends Operation {
         this.inputType = "string";
         this.outputType = "string";
         this.args = [];
-        this.patterns = [
+        this.checks = [
             {
-                match: "&(?:#\\d{2,3}|#x[\\da-f]{2}|[a-z]{2,6});",
+                pattern: "&(?:#\\d{2,3}|#x[\\da-f]{2}|[a-z]{2,6});",
                 flags: "i",
                 args: []
-            },
+            }
         ];
     }
 

src/core/operations/FromHex.mjs

@@ -32,49 +32,54 @@ class FromHex extends Operation {
                 value: FROM_HEX_DELIM_OPTIONS
             }
         ];
-        this.patterns = [
+        this.checks = [
             {
-                match: "^(?:[\\dA-F]{2})+$",
+                pattern: "^(?:[\\dA-F]{2})+$",
                 flags: "i",
                 args: ["None"]
             },
             {
-                match: "^[\\dA-F]{2}(?: [\\dA-F]{2})*$",
+                pattern: "^[\\dA-F]{2}(?: [\\dA-F]{2})*$",
                 flags: "i",
                 args: ["Space"]
             },
             {
-                match: "^[\\dA-F]{2}(?:,[\\dA-F]{2})*$",
+                pattern: "^[\\dA-F]{2}(?:,[\\dA-F]{2})*$",
                 flags: "i",
                 args: ["Comma"]
             },
             {
-                match: "^[\\dA-F]{2}(?:;[\\dA-F]{2})*$",
+                pattern: "^[\\dA-F]{2}(?:;[\\dA-F]{2})*$",
                 flags: "i",
                 args: ["Semi-colon"]
             },
             {
-                match: "^[\\dA-F]{2}(?::[\\dA-F]{2})*$",
+                pattern: "^[\\dA-F]{2}(?::[\\dA-F]{2})*$",
                 flags: "i",
                 args: ["Colon"]
             },
             {
-                match: "^[\\dA-F]{2}(?:\\n[\\dA-F]{2})*$",
+                pattern: "^[\\dA-F]{2}(?:\\n[\\dA-F]{2})*$",
                 flags: "i",
                 args: ["Line feed"]
             },
             {
-                match: "^[\\dA-F]{2}(?:\\r\\n[\\dA-F]{2})*$",
+                pattern: "^[\\dA-F]{2}(?:\\r\\n[\\dA-F]{2})*$",
                 flags: "i",
                 args: ["CRLF"]
             },
             {
-                match: "^[\\dA-F]{2}(?:0x[\\dA-F]{2})*$",
+                pattern: "^(?:0x[\\dA-F]{2})+$",
                 flags: "i",
                 args: ["0x"]
             },
             {
-                match: "^[\\dA-F]{2}(?:\\\\x[\\dA-F]{2})*$",
+                pattern: "^0x[\\dA-F]{2}(?:,0x[\\dA-F]{2})*$",
+                flags: "i",
+                args: ["0x with comma"]
+            },
+            {
+                pattern: "^(?:\\\\x[\\dA-F]{2})+$",
                 flags: "i",
                 args: ["\\x"]
             }

src/core/operations/FromHexContent.mjs

@@ -26,6 +26,13 @@ class FromHexContent extends Operation {
         this.inputType = "string";
         this.outputType = "byteArray";
         this.args = [];
+        this.checks = [
+            {
+                pattern:  "\\|([\\da-f]{2} ?)+\\|",
+                flags:  "i",
+                args:   []
+            }
+        ];
     }
 
     /**

src/core/operations/FromHexdump.mjs

@@ -27,9 +27,9 @@ class FromHexdump extends Operation {
         this.inputType = "string";
         this.outputType = "byteArray";
         this.args = [];
-        this.patterns = [
+        this.checks = [
             {
-                match: "^(?:(?:[\\dA-F]{4,16}h?:?)?[ \\t]*((?:[\\dA-F]{2} ){1,8}(?:[ \\t]|[\\dA-F]{2}-)(?:[\\dA-F]{2} ){1,8}|(?:[\\dA-F]{4} )*[\\dA-F]{4}|(?:[\\dA-F]{2} )*[\\dA-F]{2})[^\\n]*\\n?){2,}$",
+                pattern: "^(?:(?:[\\dA-F]{4,16}h?:?)?[ \\t]*((?:[\\dA-F]{2} ){1,8}(?:[ \\t]|[\\dA-F]{2}-)(?:[\\dA-F]{2} ){1,8}|(?:[\\dA-F]{4} )*[\\dA-F]{4}|(?:[\\dA-F]{2} )*[\\dA-F]{2})[^\\n]*\\n?){2,}$",
                 flags: "i",
                 args: []
             },

src/core/operations/FromMorseCode.mjs

@@ -37,12 +37,12 @@ class FromMorseCode extends Operation {
                 "value": WORD_DELIM_OPTIONS
             }
         ];
-        this.patterns = [
+        this.checks = [
             {
-                match: "(?:^[-. \\n]{5,}$|^[_. \\n]{5,}$|^(?:dash|dot| |\\n){5,}$)",
+                pattern: "(?:^[-. \\n]{5,}$|^[_. \\n]{5,}$|^(?:dash|dot| |\\n){5,}$)",
                 flags: "i",
                 args: ["Space", "Line feed"]
-            },
+            }
         ];
     }
 

src/core/operations/FromOctal.mjs

@@ -32,37 +32,37 @@ class FromOctal extends Operation {
                 "value": DELIM_OPTIONS
             }
         ];
-        this.patterns = [
+        this.checks = [
             {
-                match: "^(?:[0-7]{1,2}|[123][0-7]{2})(?: (?:[0-7]{1,2}|[123][0-7]{2}))*$",
+                pattern: "^(?:[0-7]{1,2}|[123][0-7]{2})(?: (?:[0-7]{1,2}|[123][0-7]{2}))*$",
                 flags: "",
                 args: ["Space"]
             },
             {
-                match: "^(?:[0-7]{1,2}|[123][0-7]{2})(?:,(?:[0-7]{1,2}|[123][0-7]{2}))*$",
+                pattern: "^(?:[0-7]{1,2}|[123][0-7]{2})(?:,(?:[0-7]{1,2}|[123][0-7]{2}))*$",
                 flags: "",
                 args: ["Comma"]
             },
             {
-                match: "^(?:[0-7]{1,2}|[123][0-7]{2})(?:;(?:[0-7]{1,2}|[123][0-7]{2}))*$",
+                pattern: "^(?:[0-7]{1,2}|[123][0-7]{2})(?:;(?:[0-7]{1,2}|[123][0-7]{2}))*$",
                 flags: "",
                 args: ["Semi-colon"]
             },
             {
-                match: "^(?:[0-7]{1,2}|[123][0-7]{2})(?::(?:[0-7]{1,2}|[123][0-7]{2}))*$",
+                pattern: "^(?:[0-7]{1,2}|[123][0-7]{2})(?::(?:[0-7]{1,2}|[123][0-7]{2}))*$",
                 flags: "",
                 args: ["Colon"]
             },
             {
-                match: "^(?:[0-7]{1,2}|[123][0-7]{2})(?:\\n(?:[0-7]{1,2}|[123][0-7]{2}))*$",
+                pattern: "^(?:[0-7]{1,2}|[123][0-7]{2})(?:\\n(?:[0-7]{1,2}|[123][0-7]{2}))*$",
                 flags: "",
                 args: ["Line feed"]
             },
             {
-                match: "^(?:[0-7]{1,2}|[123][0-7]{2})(?:\\r\\n(?:[0-7]{1,2}|[123][0-7]{2}))*$",
+                pattern: "^(?:[0-7]{1,2}|[123][0-7]{2})(?:\\r\\n(?:[0-7]{1,2}|[123][0-7]{2}))*$",
                 flags: "",
                 args: ["CRLF"]
-            },
+            }
         ];
     }
 

src/core/operations/FromQuotedPrintable.mjs

@@ -28,9 +28,9 @@ class FromQuotedPrintable extends Operation {
         this.inputType = "string";
         this.outputType = "byteArray";
         this.args = [];
-        this.patterns = [
+        this.checks = [
             {
-                match: "^[\\x21-\\x3d\\x3f-\\x7e \\t]{0,76}(?:=[\\da-f]{2}|=\\r?\\n)(?:[\\x21-\\x3d\\x3f-\\x7e \\t]|=[\\da-f]{2}|=\\r?\\n)*$",
+                pattern: "^[\\x21-\\x3d\\x3f-\\x7e \\t]{0,76}(?:=[\\da-f]{2}|=\\r?\\n)(?:[\\x21-\\x3d\\x3f-\\x7e \\t]|=[\\da-f]{2}|=\\r?\\n)*$",
                 flags: "i",
                 args: []
             },

src/core/operations/FromUNIXTimestamp.mjs

@@ -33,27 +33,27 @@ class FromUNIXTimestamp extends Operation {
                 "value": UNITS
             }
         ];
-        this.patterns = [
+        this.checks = [
             {
-                match: "^1?\\d{9}$",
+                pattern: "^1?\\d{9}$",
                 flags: "",
                 args: ["Seconds (s)"]
             },
             {
-                match: "^1?\\d{12}$",
+                pattern: "^1?\\d{12}$",
                 flags: "",
                 args: ["Milliseconds (ms)"]
             },
             {
-                match: "^1?\\d{15}$",
+                pattern: "^1?\\d{15}$",
                 flags: "",
                 args: ["Microseconds (μs)"]
             },
             {
-                match: "^1?\\d{18}$",
+                pattern: "^1?\\d{18}$",
                 flags: "",
                 args: ["Nanoseconds (ns)"]
-            },
+            }
         ];
     }
 

src/core/operations/GenerateHOTP.mjs

@@ -21,7 +21,7 @@ class GenerateHOTP extends Operation {
 
         this.name = "Generate HOTP";
         this.module = "Default";
-        this.description = "The HMAC-based One-Time Password algorithm (HOTP) is an algorithm that computes a one-time password from a shared secret key and an incrementing counter. It has been adopted as Internet Engineering Task Force standard RFC 4226, is the cornerstone of Initiative For Open Authentication (OATH), and is used in a number of two-factor authentication systems.<br><br>Enter the secret as the input or leave it blank for a random secret to be generated.";
+        this.description = "The HMAC-based One-Time Password algorithm (HOTP) is an algorithm that computes a one-time password from a shared secret key and an incrementing counter. It has been adopted as Internet Engineering Task Force standard RFC 4226, is the cornerstone of Initiative For Open Authentication (OAUTH), and is used in a number of two-factor authentication systems.<br><br>Enter the secret as the input or leave it blank for a random secret to be generated.";
         this.infoURL = "https://wikipedia.org/wiki/HMAC-based_One-time_Password_algorithm";
         this.inputType = "ArrayBuffer";
         this.outputType = "string";
@@ -59,7 +59,7 @@ class GenerateHOTP extends Operation {
             name: args[0],
             keySize: args[1],
             codeLength: args[2],
-            secret: (new ToBase32).run(input, []),
+            secret: (new ToBase32).run(input, []).split("=")[0],
         });
         const counter = args[3];
         return `URI: ${otpObj.hotpURL}\n\nPassword: ${otpObj.hotp(counter)}`;

src/core/operations/GenerateImage.mjs

@@ -0,0 +1,185 @@
+/**
+ * @author pointhi [thomas.pointhuber@gmx.at]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import Utils from "../Utils.mjs";
+import {isImage} from "../lib/FileType.mjs";
+import {toBase64} from "../lib/Base64.mjs";
+import {isWorkerEnvironment} from "../Utils.mjs";
+import jimplib from "jimp/es/index.js";
+const jimp = jimplib.default ? jimplib.default : jimplib;
+
+/**
+ * Generate Image operation
+ */
+class GenerateImage extends Operation {
+
+    /**
+     * GenerateImage constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Generate Image";
+        this.module = "Image";
+        this.description = "Generates an image using the input as pixel values.";
+        this.infoURL = "";
+        this.inputType = "ArrayBuffer";
+        this.outputType = "ArrayBuffer";
+        this.presentType = "html";
+        this.args = [
+            {
+                "name": "Mode",
+                "type": "option",
+                "value": ["Greyscale", "RG", "RGB", "RGBA", "Bits"]
+            },
+            {
+                "name": "Pixel Scale Factor",
+                "type": "number",
+                "value": 8,
+            },
+            {
+                "name": "Pixels per row",
+                "type": "number",
+                "value": 64,
+            }
+        ];
+    }
+
+    /**
+     * @param {byteArray} input
+     * @param {Object[]} args
+     * @returns {ArrayBuffer}
+     */
+    async run(input, args) {
+        const [mode, scale, width] = args;
+        input = new Uint8Array(input);
+
+        if (scale <= 0) {
+            throw new OperationError("Pixel Scale Factor needs to be > 0");
+        }
+
+        if (width <= 0) {
+            throw new OperationError("Pixels per Row needs to be > 0");
+        }
+
+        const bytePerPixelMap = {
+            "Greyscale": 1,
+            "RG": 2,
+            "RGB": 3,
+            "RGBA": 4,
+            "Bits": 1/8,
+        };
+
+        const bytesPerPixel = bytePerPixelMap[mode];
+
+        if (bytesPerPixel > 0 && input.length % bytesPerPixel  !== 0) {
+            throw new OperationError(`Number of bytes is not a divisor of ${bytesPerPixel}`);
+        }
+
+        const height = Math.ceil(input.length / bytesPerPixel / width);
+        const image = await new jimp(width, height, (err, image) => {});
+
+        if (isWorkerEnvironment())
+            self.sendStatusMessage("Generating image from data...");
+
+        if (mode === "Bits") {
+            let index = 0;
+            for (let j = 0; j < input.length; j++) {
+                const curByte = Utils.bin(input[j]);
+                for (let k = 0; k < 8; k++, index++) {
+                    const x = index % width;
+                    const y = Math.floor(index / width);
+
+                    const value = curByte[k] === "0" ? 0xFF : 0x00;
+                    const pixel = jimp.rgbaToInt(value, value, value, 0xFF);
+                    image.setPixelColor(pixel, x, y);
+                }
+            }
+        } else {
+            let i = 0;
+            while (i < input.length) {
+                const index = i / bytesPerPixel;
+                const x = index % width;
+                const y = Math.floor(index / width);
+
+                let red = 0x00;
+                let green = 0x00;
+                let blue = 0x00;
+                let alpha = 0xFF;
+
+                switch (mode) {
+                    case "Greyscale":
+                        red = green = blue = input[i++];
+                        break;
+
+                    case "RG":
+                        red = input[i++];
+                        green = input[i++];
+                        break;
+
+                    case "RGB":
+                        red = input[i++];
+                        green = input[i++];
+                        blue = input[i++];
+                        break;
+
+                    case "RGBA":
+                        red = input[i++];
+                        green = input[i++];
+                        blue = input[i++];
+                        alpha = input[i++];
+                        break;
+
+                    default:
+                        throw new OperationError(`Unsupported Mode: (${mode})`);
+                }
+
+                try {
+                    const pixel = jimp.rgbaToInt(red, green, blue, alpha);
+                    image.setPixelColor(pixel, x, y);
+                } catch (err) {
+                    throw new OperationError(`Error while generating image from pixel values. (${err})`);
+                }
+            }
+        }
+
+        if (scale !== 1) {
+            if (isWorkerEnvironment())
+                self.sendStatusMessage("Scaling image...");
+
+            image.scaleToFit(width*scale, height*scale, jimp.RESIZE_NEAREST_NEIGHBOR);
+        }
+
+        try {
+            const imageBuffer = await image.getBufferAsync(jimp.MIME_PNG);
+            return imageBuffer.buffer;
+        } catch (err) {
+            throw new OperationError(`Error generating image. (${err})`);
+        }
+    }
+
+    /**
+     * Displays the generated image using HTML for web apps
+     * @param {ArrayBuffer} data
+     * @returns {html}
+     */
+    present(data) {
+        if (!data.byteLength) return "";
+        const dataArray = new Uint8Array(data);
+
+        const type = isImage(dataArray);
+        if (!type) {
+            throw new OperationError("Invalid file type.");
+        }
+
+        return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
+    }
+
+}
+
+export default GenerateImage;

src/core/operations/GeneratePGPKeyPair.mjs

@@ -33,7 +33,7 @@ class GeneratePGPKeyPair extends Operation {
             {
                 "name": "Key type",
                 "type": "option",
-                "value": ["RSA-1024", "RSA-2048", "RSA-4096", "ECC-256", "ECC-384"]
+                "value": ["RSA-1024", "RSA-2048", "RSA-4096", "ECC-256", "ECC-384", "ECC-521"]
             },
             {
                 "name": "Password (optional)",
@@ -59,12 +59,15 @@ class GeneratePGPKeyPair extends Operation {
      * @returns {string}
      */
     async run(input, args) {
-        const [keyType, keySize] = args[0].split("-"),
-            password = args[1],
+        let [keyType, keySize] = args[0].split("-");
+        const password = args[1],
             name = args[2],
             email = args[3];
         let userIdentifier = "";
 
+        keyType = keyType.toLowerCase();
+        keySize = parseInt(keySize, 10);
+
         if (name) userIdentifier += name;
         if (email) userIdentifier += ` <${email}>`;
 

src/core/operations/GenerateTOTP.mjs

@@ -21,7 +21,7 @@ class GenerateTOTP extends Operation {
 
         this.name = "Generate TOTP";
         this.module = "Default";
-        this.description = "The Time-based One-Time Password algorithm (TOTP) is an algorithm that computes a one-time password from a shared secret key and the current time. It has been adopted as Internet Engineering Task Force standard RFC 6238, is the cornerstone of Initiative For Open Authentication (OATH), and is used in a number of two-factor authentication systems. A TOTP is an HOTP where the counter is the current time.<br><br>Enter the secret as the input or leave it blank for a random secret to be generated. T0 and T1 are in seconds.";
+        this.description = "The Time-based One-Time Password algorithm (TOTP) is an algorithm that computes a one-time password from a shared secret key and the current time. It has been adopted as Internet Engineering Task Force standard RFC 6238, is the cornerstone of Initiative For Open Authentication (OAUTH), and is used in a number of two-factor authentication systems. A TOTP is an HOTP where the counter is the current time.<br><br>Enter the secret as the input or leave it blank for a random secret to be generated. T0 and T1 are in seconds.";
         this.infoURL = "https://wikipedia.org/wiki/Time-based_One-time_Password_algorithm";
         this.inputType = "ArrayBuffer";
         this.outputType = "string";
@@ -64,7 +64,7 @@ class GenerateTOTP extends Operation {
             name: args[0],
             keySize: args[1],
             codeLength: args[2],
-            secret: (new ToBase32).run(input, []),
+            secret: (new ToBase32).run(input, []).split("=")[0],
             epoch: args[3],
             timeSlice: args[4]
         });

src/core/operations/Gunzip.mjs

@@ -5,9 +5,9 @@
  */
 
 import Operation from "../Operation.mjs";
-import zlibAndGzip from "zlibjs/bin/zlib_and_gzip.min.js";
+import gunzip from "zlibjs/bin/gunzip.min.js";
 
-const Zlib = zlibAndGzip.Zlib;
+const Zlib = gunzip.Zlib;
 
 /**
  * Gunzip operation
@@ -27,12 +27,12 @@ class Gunzip extends Operation {
         this.inputType = "ArrayBuffer";
         this.outputType = "ArrayBuffer";
         this.args = [];
-        this.patterns = [
+        this.checks = [
             {
-                match: "^\\x1f\\x8b\\x08",
+                pattern: "^\\x1f\\x8b\\x08",
                 flags: "",
                 args: []
-            },
+            }
         ];
     }
 
@@ -42,8 +42,8 @@ class Gunzip extends Operation {
      * @returns {File}
      */
     run(input, args) {
-        const gunzip = new Zlib.Gunzip(new Uint8Array(input));
-        return new Uint8Array(gunzip.decompress()).buffer;
+        const gzipObj = new Zlib.Gunzip(new Uint8Array(input));
+        return new Uint8Array(gzipObj.decompress()).buffer;
     }
 
 }

src/core/operations/Gzip.mjs

@@ -6,9 +6,9 @@
 
 import Operation from "../Operation.mjs";
 import {COMPRESSION_TYPE, ZLIB_COMPRESSION_TYPE_LOOKUP} from "../lib/Zlib.mjs";
-import zlibAndGzip from "zlibjs/bin/zlib_and_gzip.min.js";
+import gzip from "zlibjs/bin/gzip.min.js";
 
-const Zlib = zlibAndGzip.Zlib;
+const Zlib = gzip.Zlib;
 
 /**
  * Gzip operation
@@ -73,12 +73,15 @@ class Gzip extends Operation {
             options.filename = filename;
         }
         if (comment.length) {
-            options.flags.fcommenct = true;
+            options.flags.comment = true;
             options.comment = comment;
         }
-
-        const gzip = new Zlib.Gzip(new Uint8Array(input), options);
-        return new Uint8Array(gzip.compress()).buffer;
+        const gzipObj = new Zlib.Gzip(new Uint8Array(input), options);
+        const compressed = new Uint8Array(gzipObj.compress());
+        if (options.flags.comment && !(compressed[3] & 0x10)) {
+            compressed[3] |= 0x10;
+        }
+        return compressed.buffer;
     }
 
 }

src/core/operations/HaversineDistance.mjs

@@ -41,8 +41,8 @@ class HaversineDistance extends Operation {
 
         const lat1 = parseFloat(values[1]);
         const lng1 = parseFloat(values[3]);
-        const lat2 = parseFloat(values[6]);
-        const lng2 = parseFloat(values[8]);
+        const lat2 = parseFloat(values[5]);
+        const lng2 = parseFloat(values[7]);
 
         const TO_RAD = Math.PI / 180;
         const dLat = (lat2-lat1) * TO_RAD;

src/core/operations/ImageBrightnessContrast.mjs

@@ -9,7 +9,8 @@ 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";
+import jimplib from "jimp/es/index.js";
+const jimp = jimplib.default ? jimplib.default : jimplib;
 
 /**
  * Image Brightness / Contrast operation

src/core/operations/ImageFilter.mjs

@@ -9,7 +9,8 @@ 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";
+import jimplib from "jimp/es/index.js";
+const jimp = jimplib.default ? jimplib.default : jimplib;
 
 /**
  * Image Filter operation

src/core/operations/ImageHueSaturationLightness.mjs

@@ -9,7 +9,8 @@ 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";
+import jimplib from "jimp/es/index.js";
+const jimp = jimplib.default ? jimplib.default : jimplib;
 
 /**
  * Image Hue/Saturation/Lightness operation

src/core/operations/ImageOpacity.mjs

@@ -9,7 +9,8 @@ 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";
+import jimplib from "jimp/es/index.js";
+const jimp = jimplib.default ? jimplib.default : jimplib;
 
 /**
  * Image Opacity operation

src/core/operations/InvertImage.mjs

@@ -9,7 +9,8 @@ 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";
+import jimplib from "jimp/es/index.js";
+const jimp = jimplib.default ? jimplib.default : jimplib;
 
 /**
  * Invert Image operation

src/core/operations/JavaScriptMinify.mjs

@@ -4,10 +4,9 @@
  * @license Apache-2.0
  */
 
+import OperationError from "../errors/OperationError.mjs";
 import Operation from "../Operation.mjs";
-import * as esprima from "esprima";
-import escodegen from "escodegen";
-import esmangle from "esmangle";
+import * as terser from "terser";
 
 /**
  * JavaScript Minify operation
@@ -33,23 +32,12 @@ class JavaScriptMinify extends Operation {
      * @param {Object[]} args
      * @returns {string}
      */
-    run(input, args) {
-        let result = "";
-        const AST = esprima.parseScript(input),
-            optimisedAST = esmangle.optimize(AST, null),
-            mangledAST = esmangle.mangle(optimisedAST);
-
-        result = escodegen.generate(mangledAST, {
-            format: {
-                renumber:    true,
-                hexadecimal: true,
-                escapeless:  true,
-                compact:     true,
-                semicolons:  false,
-                parentheses: false
-            }
-        });
-        return result;
+    async run(input, args) {
+        const result = await terser.minify(input);
+        if (result.error) {
+            throw new OperationError(`Error minifying JavaScript. (${result.error})`);
+        }
+        return result.code;
     }
 
 }

src/core/operations/Lorenz.mjs

@@ -22,7 +22,7 @@ class Lorenz extends Operation {
 
         this.name = "Lorenz";
         this.module = "Bletchley";
-        this.description = "The Lorenz SZ40/42 cipher attachment was a WW2 German rotor cipher machine with twelve rotors which attached in-line between remote teleprinters.<br><br>It used the Vernam cipher with two groups of five rotors (named the psi(ψ) wheels and chi(χ) wheels at Bletchley Park) to create two pseudorandom streams of five bits, encoded in ITA2, which were XOR added to the plaintext. Two other rotors, dubbed the mu(μ) or motor wheels, could hold up the stepping of the psi wheels meaning they stepped intermittently.<br><br>Each rotor has a different number of cams/lugs around their circumference which could be set active or inactive changing the key stream.<br><br>Three models of the Lorenz are emulated, SZ40, SZ42a and SZ42b and three example wheel patterns (the lug settings) are included (KH, ZMUG & BREAM) with the option to set a custom set using the letter 'x' for active or '.' for an inactive lug.<br><br>The input can either be plaintext or ITA2 when sending and ITA2 when receiving.<br><br>To learn more, Virtual Lorenz, an online, browser based simulation of the Lorenz SZ40/42 is available at <a href='https://lorenz.virtualcolossus.co.uk' target='_blank'>https://lorenz.virtualcolossus.co.uk</a>.<br><br>A more detailed description of this operation can be found <a href='https://github.com/gchq/CyberChef/wiki/Lorenz-SZ' target='_blank'>here</a>.";
+        this.description = "The Lorenz SZ40/42 cipher attachment was a WW2 German rotor cipher machine with twelve rotors which attached in-line between remote teleprinters.<br><br>It used the Vernam cipher with two groups of five rotors (named the psi(ψ) wheels and chi(χ) wheels at Bletchley Park) to create two pseudorandom streams of five bits, encoded in ITA2, which were XOR added to the plaintext. Two other rotors, dubbed the mu(μ) or motor wheels, could hold up the stepping of the psi wheels meaning they stepped intermittently.<br><br>Each rotor has a different number of cams/lugs around their circumference which could be set active or inactive changing the key stream.<br><br>Three models of the Lorenz are emulated, SZ40, SZ42a and SZ42b and three example wheel patterns (the lug settings) are included (KH, ZMUG & BREAM) with the option to set a custom set using the letter 'x' for active or '.' for an inactive lug.<br><br>The input can either be plaintext or ITA2 when sending and ITA2 when receiving.<br><br>To learn more, Virtual Lorenz, an online, browser based simulation of the Lorenz SZ40/42 is available at <a href='https://lorenz.virtualcolossus.co.uk' target='_blank'>lorenz.virtualcolossus.co.uk</a>.<br><br>A more detailed description of this operation can be found <a href='https://github.com/gchq/CyberChef/wiki/Lorenz-SZ' target='_blank'>here</a>.";
         this.infoURL = "https://wikipedia.org/wiki/Lorenz_cipher";
         this.inputType = "string";
         this.outputType = "string";
@@ -293,8 +293,8 @@ class Lorenz extends Operation {
             chosenSetting.S[3] = this.readLugs(lugs3);
             chosenSetting.S[4] = this.readLugs(lugs4);
             chosenSetting.S[5] = this.readLugs(lugs5);
-            chosenSetting.M[1] = this.readLugs(lugm37);
-            chosenSetting.M[2] = this.readLugs(lugm61);
+            chosenSetting.M[1] = this.readLugs(lugm61);
+            chosenSetting.M[2] = this.readLugs(lugm37);
             chosenSetting.X[1] = this.readLugs(lugx1);
             chosenSetting.X[2] = this.readLugs(lugx2);
             chosenSetting.X[3] = this.readLugs(lugx3);

src/core/operations/LuhnChecksum.mjs

@@ -0,0 +1,77 @@
+/**
+ * @author n1073645 [n1073645@gmail.com]
+ * @copyright Crown Copyright 2020
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+
+/**
+ * Luhn Checksum operation
+ */
+class LuhnChecksum extends Operation {
+
+    /**
+     * LuhnChecksum constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Luhn Checksum";
+        this.module = "Default";
+        this.description = "The Luhn algorithm, also known as the modulus 10 or mod 10 algorithm, is a simple checksum formula used to validate a variety of identification numbers, such as credit card numbers, IMEI numbers and Canadian Social Insurance Numbers.";
+        this.infoURL = "https://wikipedia.org/wiki/Luhn_algorithm";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [];
+    }
+
+    /**
+     * Generates the Luhn Checksum from the input.
+     *
+     * @param {string} inputStr
+     * @returns {number}
+     */
+    checksum(inputStr) {
+        let even = false;
+        return inputStr.split("").reverse().reduce((acc, elem) => {
+            // Convert element to integer.
+            let temp = parseInt(elem, 10);
+
+            // If element is not an integer.
+            if (isNaN(temp))
+                throw new OperationError("Character: " + elem + " is not a digit.");
+
+            // If element is in an even position
+            if (even) {
+                // Double the element and add the quotient and remainder together.
+                temp = 2 * elem;
+                temp = Math.floor(temp/10) + (temp % 10);
+            }
+
+            even = !even;
+            return acc + temp;
+        }, 0)  % 10;
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        if (!input) return "";
+
+        const checkSum = this.checksum(input);
+        let checkDigit = this.checksum(input + "0");
+        checkDigit = checkDigit === 0 ? 0 : (10-checkDigit);
+
+        return `Checksum: ${checkSum}
+Checkdigit: ${checkDigit}
+Luhn Validated String: ${input + "" + checkDigit}`;
+    }
+
+}
+
+export default LuhnChecksum;

src/core/operations/MultipleBombe.mjs

@@ -144,7 +144,7 @@ class MultipleBombe extends Operation {
      * @param {number} progress - Progress (as a float in the range 0..1)
      */
     updateStatus(nLoops, nStops, progress, start) {
-        const elapsed = new Date().getTime() - start;
+        const elapsed = Date.now() - start;
         const remaining = (elapsed / progress) * (1 - progress) / 1000;
         const hours = Math.floor(remaining / 3600);
         const minutes = `0${Math.floor((remaining % 3600) / 60)}`.slice(-2);
@@ -237,7 +237,7 @@ class MultipleBombe extends Operation {
         const totalRuns = choose(rotors.length, 3) * 6 * fourthRotors.length * reflectors.length;
         let nRuns = 0;
         let nStops = 0;
-        const start = new Date().getTime();
+        const start = Date.now();
         for (const rotor1 of rotors) {
             for (const rotor2 of rotors) {
                 if (rotor2 === rotor1) {

src/core/operations/NormaliseImage.mjs

@@ -8,7 +8,8 @@ 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";
+import jimplib from "jimp/es/index.js";
+const jimp = jimplib.default ? jimplib.default : jimplib;
 
 /**
  * Normalise Image operation

src/core/operations/NormaliseUnicode.mjs

@@ -0,0 +1,62 @@
+/**
+ * @author Matthieu [m@tthieu.xyz]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import {UNICODE_NORMALISATION_FORMS} from "../lib/ChrEnc.mjs";
+import unorm from "unorm";
+
+/**
+ * Normalise Unicode operation
+ */
+class NormaliseUnicode extends Operation {
+
+    /**
+     * NormaliseUnicode constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Normalise Unicode";
+        this.module = "Encodings";
+        this.description = "Transform Unicode characters to one of the Normalisation Forms";
+        this.infoURL = "https://wikipedia.org/wiki/Unicode_equivalence#Normal_forms";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Normal Form",
+                type: "option",
+                value: UNICODE_NORMALISATION_FORMS
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const [normalForm] = args;
+
+        switch (normalForm) {
+            case "NFD":
+                return unorm.nfd(input);
+            case "NFC":
+                return unorm.nfc(input);
+            case "NFKD":
+                return unorm.nfkd(input);
+            case "NFKC":
+                return unorm.nfkc(input);
+            default:
+                throw new OperationError("Unknown Normalisation Form");
+        }
+    }
+
+}
+
+export default NormaliseUnicode;

src/core/operations/OpticalCharacterRecognition.mjs

@@ -1,6 +1,7 @@
 /**
  * @author n1474335 [n1474335@gmail.com]
  * @author mshwed [m@ttshwed.com]
+ * @author Matt C [me@mitt.dev]
  * @copyright Crown Copyright 2019
  * @license Apache-2.0
  */
@@ -12,7 +13,7 @@ import { toBase64 } from "../lib/Base64.mjs";
 import { isWorkerEnvironment } from "../Utils.mjs";
 
 import Tesseract from "tesseract.js";
-const { TesseractWorker } = Tesseract;
+const { createWorker } = Tesseract;
 
 import process from "process";
 
@@ -60,23 +61,30 @@ class OpticalCharacterRecognition extends Operation {
         const assetDir = isWorkerEnvironment() ? `${self.docURL}/assets/` : `${process.cwd()}/src/core/vendor/`;
 
         try {
+            self.sendStatusMessage("Spinning up Tesseract worker...");
             const image = `data:${type};base64,${toBase64(input)}`;
-            const worker = new TesseractWorker({
+            const worker = createWorker({
                 workerPath: `${assetDir}tesseract/worker.min.js`,
                 langPath: `${assetDir}tesseract/lang-data`,
                 corePath: `${assetDir}tesseract/tesseract-core.wasm.js`,
-            });
-            const result = await worker.recognize(image)
-                .progress(progress => {
+                logger: progress => {
                     if (isWorkerEnvironment()) {
-                        self.sendStatusMessage(`Status: ${progress.status} - ${(parseFloat(progress.progress)*100).toFixed(2)}%`);
+                        self.sendStatusMessage(`Status: ${progress.status}${progress.status === "recognizing text" ? ` - ${(parseFloat(progress.progress)*100).toFixed(2)}%`: "" }`);
                     }
-                });
+                }
+            });
+            await worker.load();
+            self.sendStatusMessage("Loading English language...");
+            await worker.loadLanguage("eng");
+            self.sendStatusMessage("Intialising Tesseract API...");
+            await worker.initialize("eng");
+            self.sendStatusMessage("Finding text...");
+            const result = await worker.recognize(image);
 
             if (showConfidence) {
-                return `Confidence: ${result.confidence}%\n\n${result.text}`;
+                return `Confidence: ${result.data.confidence}%\n\n${result.data.text}`;
             } else {
-                return result.text;
+                return result.data.text;
             }
         } catch (err) {
             throw new OperationError(`Error performing OCR on image. (${err})`);

src/core/operations/ParseObjectIDTimestamp.mjs

@@ -0,0 +1,47 @@
+/**
+ * @author dmfj [dominic@dmfj.io]
+ * @copyright Crown Copyright 2020
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import BSON from "bson";
+
+/**
+ * Parse ObjectID timestamp operation
+ */
+class ParseObjectIDTimestamp extends Operation {
+
+    /**
+     * ParseObjectIDTimestamp constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Parse ObjectID timestamp";
+        this.module = "Serialise";
+        this.description = "Parse timestamp from MongoDB/BSON ObjectID hex string.";
+        this.infoURL = "https://docs.mongodb.com/manual/reference/method/ObjectId.getTimestamp/";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        try {
+            const objectId = new BSON.ObjectID(input);
+            return objectId.getTimestamp().toISOString();
+        } catch (err) {
+            throw new OperationError(err);
+        }
+    }
+
+}
+
+export default ParseObjectIDTimestamp;

src/core/operations/ParseQRCode.mjs

@@ -33,9 +33,9 @@ class ParseQRCode extends Operation {
                 "value": false
             }
         ];
-        this.patterns = [
+        this.checks = [
             {
-                "match": "^(?:\\xff\\xd8\\xff|\\x89\\x50\\x4e\\x47|\\x47\\x49\\x46|.{8}\\x57\\x45\\x42\\x50|\\x42\\x4d)",
+                "pattern": "^(?:\\xff\\xd8\\xff|\\x89\\x50\\x4e\\x47|\\x47\\x49\\x46|.{8}\\x57\\x45\\x42\\x50|\\x42\\x4d)",
                 "flags": "",
                 "args": [false],
                 "useful": true

src/core/operations/ParseSSHHostKey.mjs

@@ -38,6 +38,13 @@ class ParseSSHHostKey extends Operation {
                 ]
             }
         ];
+        this.checks = [
+            {
+                pattern:  "^\\s*([A-F\\d]{2}[,;:]){15,}[A-F\\d]{2}\\s*$",
+                flags:  "i",
+                args:   ["Hex"]
+            }
+        ];
     }
 
     /**

src/core/operations/ParseUNIXFilePermissions.mjs

@@ -25,6 +25,13 @@ class ParseUNIXFilePermissions extends Operation {
         this.inputType = "string";
         this.outputType = "string";
         this.args = [];
+        this.checks = [
+            {
+                pattern:  "^\\s*d[rxw-]{9}\\s*$",
+                flags:  "",
+                args:   []
+            }
+        ];
     }
 
     /**

src/core/operations/ParseUserAgent.mjs

@@ -25,6 +25,13 @@ class ParseUserAgent extends Operation {
         this.inputType = "string";
         this.outputType = "string";
         this.args = [];
+        this.checks = [
+            {
+                pattern:  "^(User-Agent:|Mozilla\\/)[^\\n\\r]+\\s*$",
+                flags:  "i",
+                args:   []
+            }
+        ];
     }
 
     /**

src/core/operations/ParseX509Certificate.mjs

@@ -35,13 +35,11 @@ class ParseX509Certificate extends Operation {
                 "value": ["PEM", "DER Hex", "Base64", "Raw"]
             }
         ];
-        this.patterns = [
+        this.checks = [
             {
-                "match": "^-+BEGIN CERTIFICATE-+\\r?\\n[\\da-z+/\\n\\r]+-+END CERTIFICATE-+\\r?\\n?$",
+                "pattern": "^-+BEGIN CERTIFICATE-+\\r?\\n[\\da-z+/\\n\\r]+-+END CERTIFICATE-+\\r?\\n?$",
                 "flags": "i",
-                "args": [
-                    "PEM"
-                ]
+                "args": ["PEM"]
             }
         ];
     }

src/core/operations/PseudoRandomNumberGenerator.mjs

@@ -6,7 +6,7 @@
 
 import Operation from "../Operation.mjs";
 import Utils from "../Utils.mjs";
-import forge from "node-forge/dist/forge.min.js";
+import forge from "node-forge";
 import BigNumber from "bignumber.js";
 import { isWorkerEnvironment } from "../Utils.mjs";
 

src/core/operations/RC2Decrypt.mjs

@@ -6,7 +6,7 @@
 
 import Operation from "../Operation.mjs";
 import Utils from "../Utils.mjs";
-import forge from "node-forge/dist/forge.min.js";
+import forge from "node-forge";
 
 /**
  * RC2 Decrypt operation

src/core/operations/RC2Encrypt.mjs

@@ -6,7 +6,7 @@
 
 import Operation from "../Operation.mjs";
 import Utils from "../Utils.mjs";
-import forge from "node-forge/dist/forge.min.js";
+import forge from "node-forge";
 
 
 /**