diff --git a/.env b/.env
new file mode 100644
index 0000000..b553ebc
--- /dev/null
+++ b/.env
@@ -0,0 +1,2 @@
+ADMINPASS=put_password_here
+SALT=seed_here
diff --git a/config.js b/config.js
index 0497b8a..c9ab3fc 100644
--- a/config.js
+++ b/config.js
@@ -1,10 +1,10 @@
module.exports = Object.seal({
port: "8080",
motd: "You agree to read this message.",
- _id_PrivateKey: "boppity",
+ _id_PrivateKey: process.env.SALT,
defaultUsername: "Anonymous",
defaultRoomColor: "#3b5054",
defaultLobbyColor: "#19b4b9",
defaultLobbyColor2: "#801014",
- adminpass: "adminpass"
+ adminpass: process.env.ADMINPASS
})
diff --git a/index.js b/index.js
index 3f047d8..2363750 100644
--- a/index.js
+++ b/index.js
@@ -1,3 +1,6 @@
+// dotenv to keep secret variables in (they won't show on github)
+require('dotenv').config();
+
//call new Server
global.WebSocket = require('ws');
global.EventEmitter = require('events').EventEmitter;
diff --git a/node_modules/.package-lock.json b/node_modules/.package-lock.json
new file mode 100644
index 0000000..b1fbe29
--- /dev/null
+++ b/node_modules/.package-lock.json
@@ -0,0 +1,122 @@
+{
+ "name": "mpp-server-master",
+ "version": "1.0.0",
+ "lockfileVersion": 2,
+ "requires": true,
+ "packages": {
+ "node_modules/asyncconsole": {
+ "version": "1.3.9",
+ "resolved": "https://registry.npmjs.org/asyncconsole/-/asyncconsole-1.3.9.tgz",
+ "integrity": "sha1-+YpGz4b1ix0I43grYMaLhCLLtgY="
+ },
+ "node_modules/bindings": {
+ "version": "1.5.0",
+ "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.5.0.tgz",
+ "integrity": "sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==",
+ "dependencies": {
+ "file-uri-to-path": "1.0.0"
+ }
+ },
+ "node_modules/colors": {
+ "version": "1.4.0",
+ "resolved": "https://registry.npmjs.org/colors/-/colors-1.4.0.tgz",
+ "integrity": "sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA==",
+ "engines": {
+ "node": ">=0.1.90"
+ }
+ },
+ "node_modules/dotenv": {
+ "version": "8.2.0",
+ "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-8.2.0.tgz",
+ "integrity": "sha512-8sJ78ElpbDJBHNeBzUbUVLsqKdccaa/BXF1uPTw3GrvQTBgrQrtObr2mUrE38vzYd8cEv+m/JBfDLioYcfXoaw==",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/events": {
+ "version": "3.3.0",
+ "resolved": "https://registry.npmjs.org/events/-/events-3.3.0.tgz",
+ "integrity": "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==",
+ "engines": {
+ "node": ">=0.8.x"
+ }
+ },
+ "node_modules/file-uri-to-path": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz",
+ "integrity": "sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw=="
+ },
+ "node_modules/inherits": {
+ "version": "2.0.4",
+ "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+ "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
+ },
+ "node_modules/keccak": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/keccak/-/keccak-2.1.0.tgz",
+ "integrity": "sha512-m1wbJRTo+gWbctZWay9i26v5fFnYkOn7D5PCxJ3fZUGUEb49dE1Pm4BREUYCt/aoO6di7jeoGmhvqN9Nzylm3Q==",
+ "hasInstallScript": true,
+ "dependencies": {
+ "bindings": "^1.5.0",
+ "inherits": "^2.0.4",
+ "nan": "^2.14.0",
+ "safe-buffer": "^5.2.0"
+ },
+ "engines": {
+ "node": ">=5.12.0"
+ }
+ },
+ "node_modules/nan": {
+ "version": "2.14.2",
+ "resolved": "https://registry.npmjs.org/nan/-/nan-2.14.2.tgz",
+ "integrity": "sha512-M2ufzIiINKCuDfBSAUr1vWQ+vuVcA9kqx8JJUsbQi6yf1uGRyb7HfpdfUr5qLXf3B/t8dPvcjhKMmlfnP47EzQ=="
+ },
+ "node_modules/node-json-color-stringify": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/node-json-color-stringify/-/node-json-color-stringify-1.1.0.tgz",
+ "integrity": "sha1-i7Ek+ROFlZEFgCZRMSHWYJ1u9bc=",
+ "dependencies": {
+ "colors": "^1.1.2"
+ }
+ },
+ "node_modules/safe-buffer": {
+ "version": "5.2.1",
+ "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+ "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/feross"
+ },
+ {
+ "type": "patreon",
+ "url": "https://www.patreon.com/feross"
+ },
+ {
+ "type": "consulting",
+ "url": "https://feross.org/support"
+ }
+ ]
+ },
+ "node_modules/ws": {
+ "version": "7.4.4",
+ "resolved": "https://registry.npmjs.org/ws/-/ws-7.4.4.tgz",
+ "integrity": "sha512-Qm8k8ojNQIMx7S+Zp8u/uHOx7Qazv3Yv4q68MiWWWOJhiwG5W3x7iqmRtJo8xxrciZUY4vRxUTJCKuRnF28ZZw==",
+ "engines": {
+ "node": ">=8.3.0"
+ },
+ "peerDependencies": {
+ "bufferutil": "^4.0.1",
+ "utf-8-validate": "^5.0.2"
+ },
+ "peerDependenciesMeta": {
+ "bufferutil": {
+ "optional": true
+ },
+ "utf-8-validate": {
+ "optional": true
+ }
+ }
+ }
+ }
+}
diff --git a/node_modules/asyncconsole/LICENSE b/node_modules/asyncconsole/LICENSE
new file mode 100644
index 0000000..dbbe355
--- /dev/null
+++ b/node_modules/asyncconsole/LICENSE
@@ -0,0 +1,661 @@
+ GNU AFFERO GENERAL PUBLIC LICENSE
+ Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc.
+ Copyright (C)
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published
+ by the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see (/Users/nrajlich/ref/lib/ref.js:5:47)
+ at Module._compile (module.js:449:26)
+ at Object.Module._extensions..js (module.js:467:10)
+ at Module.load (module.js:356:32)
+ at Function.Module._load (module.js:312:12)
+ ...
+```
+
+The searching for the `.node` file will originate from the first directory in which has a `package.json` file is found.
+
+License
+-------
+
+(The MIT License)
+
+Copyright (c) 2012 Nathan Rajlich <nathan@tootallnate.net>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/bindings/bindings.js b/node_modules/bindings/bindings.js
new file mode 100644
index 0000000..727413a
--- /dev/null
+++ b/node_modules/bindings/bindings.js
@@ -0,0 +1,221 @@
+/**
+ * Module dependencies.
+ */
+
+var fs = require('fs'),
+ path = require('path'),
+ fileURLToPath = require('file-uri-to-path'),
+ join = path.join,
+ dirname = path.dirname,
+ exists =
+ (fs.accessSync &&
+ function(path) {
+ try {
+ fs.accessSync(path);
+ } catch (e) {
+ return false;
+ }
+ return true;
+ }) ||
+ fs.existsSync ||
+ path.existsSync,
+ defaults = {
+ arrow: process.env.NODE_BINDINGS_ARROW || ' → ',
+ compiled: process.env.NODE_BINDINGS_COMPILED_DIR || 'compiled',
+ platform: process.platform,
+ arch: process.arch,
+ nodePreGyp:
+ 'node-v' +
+ process.versions.modules +
+ '-' +
+ process.platform +
+ '-' +
+ process.arch,
+ version: process.versions.node,
+ bindings: 'bindings.node',
+ try: [
+ // node-gyp's linked version in the "build" dir
+ ['module_root', 'build', 'bindings'],
+ // node-waf and gyp_addon (a.k.a node-gyp)
+ ['module_root', 'build', 'Debug', 'bindings'],
+ ['module_root', 'build', 'Release', 'bindings'],
+ // Debug files, for development (legacy behavior, remove for node v0.9)
+ ['module_root', 'out', 'Debug', 'bindings'],
+ ['module_root', 'Debug', 'bindings'],
+ // Release files, but manually compiled (legacy behavior, remove for node v0.9)
+ ['module_root', 'out', 'Release', 'bindings'],
+ ['module_root', 'Release', 'bindings'],
+ // Legacy from node-waf, node <= 0.4.x
+ ['module_root', 'build', 'default', 'bindings'],
+ // Production "Release" buildtype binary (meh...)
+ ['module_root', 'compiled', 'version', 'platform', 'arch', 'bindings'],
+ // node-qbs builds
+ ['module_root', 'addon-build', 'release', 'install-root', 'bindings'],
+ ['module_root', 'addon-build', 'debug', 'install-root', 'bindings'],
+ ['module_root', 'addon-build', 'default', 'install-root', 'bindings'],
+ // node-pre-gyp path ./lib/binding/{node_abi}-{platform}-{arch}
+ ['module_root', 'lib', 'binding', 'nodePreGyp', 'bindings']
+ ]
+ };
+
+/**
+ * The main `bindings()` function loads the compiled bindings for a given module.
+ * It uses V8's Error API to determine the parent filename that this function is
+ * being invoked from, which is then used to find the root directory.
+ */
+
+function bindings(opts) {
+ // Argument surgery
+ if (typeof opts == 'string') {
+ opts = { bindings: opts };
+ } else if (!opts) {
+ opts = {};
+ }
+
+ // maps `defaults` onto `opts` object
+ Object.keys(defaults).map(function(i) {
+ if (!(i in opts)) opts[i] = defaults[i];
+ });
+
+ // Get the module root
+ if (!opts.module_root) {
+ opts.module_root = exports.getRoot(exports.getFileName());
+ }
+
+ // Ensure the given bindings name ends with .node
+ if (path.extname(opts.bindings) != '.node') {
+ opts.bindings += '.node';
+ }
+
+ // https://github.com/webpack/webpack/issues/4175#issuecomment-342931035
+ var requireFunc =
+ typeof __webpack_require__ === 'function'
+ ? __non_webpack_require__
+ : require;
+
+ var tries = [],
+ i = 0,
+ l = opts.try.length,
+ n,
+ b,
+ err;
+
+ for (; i < l; i++) {
+ n = join.apply(
+ null,
+ opts.try[i].map(function(p) {
+ return opts[p] || p;
+ })
+ );
+ tries.push(n);
+ try {
+ b = opts.path ? requireFunc.resolve(n) : requireFunc(n);
+ if (!opts.path) {
+ b.path = n;
+ }
+ return b;
+ } catch (e) {
+ if (e.code !== 'MODULE_NOT_FOUND' &&
+ e.code !== 'QUALIFIED_PATH_RESOLUTION_FAILED' &&
+ !/not find/i.test(e.message)) {
+ throw e;
+ }
+ }
+ }
+
+ err = new Error(
+ 'Could not locate the bindings file. Tried:\n' +
+ tries
+ .map(function(a) {
+ return opts.arrow + a;
+ })
+ .join('\n')
+ );
+ err.tries = tries;
+ throw err;
+}
+module.exports = exports = bindings;
+
+/**
+ * Gets the filename of the JavaScript file that invokes this function.
+ * Used to help find the root directory of a module.
+ * Optionally accepts an filename argument to skip when searching for the invoking filename
+ */
+
+exports.getFileName = function getFileName(calling_file) {
+ var origPST = Error.prepareStackTrace,
+ origSTL = Error.stackTraceLimit,
+ dummy = {},
+ fileName;
+
+ Error.stackTraceLimit = 10;
+
+ Error.prepareStackTrace = function(e, st) {
+ for (var i = 0, l = st.length; i < l; i++) {
+ fileName = st[i].getFileName();
+ if (fileName !== __filename) {
+ if (calling_file) {
+ if (fileName !== calling_file) {
+ return;
+ }
+ } else {
+ return;
+ }
+ }
+ }
+ };
+
+ // run the 'prepareStackTrace' function above
+ Error.captureStackTrace(dummy);
+ dummy.stack;
+
+ // cleanup
+ Error.prepareStackTrace = origPST;
+ Error.stackTraceLimit = origSTL;
+
+ // handle filename that starts with "file://"
+ var fileSchema = 'file://';
+ if (fileName.indexOf(fileSchema) === 0) {
+ fileName = fileURLToPath(fileName);
+ }
+
+ return fileName;
+};
+
+/**
+ * Gets the root directory of a module, given an arbitrary filename
+ * somewhere in the module tree. The "root directory" is the directory
+ * containing the `package.json` file.
+ *
+ * In: /home/nate/node-native-module/lib/index.js
+ * Out: /home/nate/node-native-module
+ */
+
+exports.getRoot = function getRoot(file) {
+ var dir = dirname(file),
+ prev;
+ while (true) {
+ if (dir === '.') {
+ // Avoids an infinite loop in rare cases, like the REPL
+ dir = process.cwd();
+ }
+ if (
+ exists(join(dir, 'package.json')) ||
+ exists(join(dir, 'node_modules'))
+ ) {
+ // Found the 'package.json' file or 'node_modules' dir; we're done
+ return dir;
+ }
+ if (prev === dir) {
+ // Got to the top
+ throw new Error(
+ 'Could not find module root given file: "' +
+ file +
+ '". Do you have a `package.json` file? '
+ );
+ }
+ // Try the parent dir next
+ prev = dir;
+ dir = join(dir, '..');
+ }
+};
diff --git a/node_modules/bindings/package.json b/node_modules/bindings/package.json
new file mode 100644
index 0000000..d027ee7
--- /dev/null
+++ b/node_modules/bindings/package.json
@@ -0,0 +1,28 @@
+{
+ "name": "bindings",
+ "description": "Helper module for loading your native module's .node file",
+ "keywords": [
+ "native",
+ "addon",
+ "bindings",
+ "gyp",
+ "waf",
+ "c",
+ "c++"
+ ],
+ "version": "1.5.0",
+ "author": "Nathan Rajlich (http://tootallnate.net)",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/TooTallNate/node-bindings.git"
+ },
+ "main": "./bindings.js",
+ "bugs": {
+ "url": "https://github.com/TooTallNate/node-bindings/issues"
+ },
+ "homepage": "https://github.com/TooTallNate/node-bindings",
+ "license": "MIT",
+ "dependencies": {
+ "file-uri-to-path": "1.0.0"
+ }
+}
diff --git a/node_modules/colors/LICENSE b/node_modules/colors/LICENSE
new file mode 100644
index 0000000..17880ff
--- /dev/null
+++ b/node_modules/colors/LICENSE
@@ -0,0 +1,25 @@
+MIT License
+
+Original Library
+ - Copyright (c) Marak Squires
+
+Additional Functionality
+ - Copyright (c) Sindre Sorhus (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/node_modules/colors/README.md b/node_modules/colors/README.md
new file mode 100644
index 0000000..fabe558
--- /dev/null
+++ b/node_modules/colors/README.md
@@ -0,0 +1,221 @@
+# colors.js
+[](https://travis-ci.org/Marak/colors.js)
+[](https://www.npmjs.org/package/colors)
+[](https://david-dm.org/Marak/colors.js)
+[](https://david-dm.org/Marak/colors.js#info=devDependencies)
+
+Please check out the [roadmap](ROADMAP.md) for upcoming features and releases. Please open Issues to provide feedback, and check the `develop` branch for the latest bleeding-edge updates.
+
+## get color and style in your node.js console
+
+
+
+## Installation
+
+ npm install colors
+
+## colors and styles!
+
+### text colors
+
+ - black
+ - red
+ - green
+ - yellow
+ - blue
+ - magenta
+ - cyan
+ - white
+ - gray
+ - grey
+
+### bright text colors
+
+ - brightRed
+ - brightGreen
+ - brightYellow
+ - brightBlue
+ - brightMagenta
+ - brightCyan
+ - brightWhite
+
+### background colors
+
+ - bgBlack
+ - bgRed
+ - bgGreen
+ - bgYellow
+ - bgBlue
+ - bgMagenta
+ - bgCyan
+ - bgWhite
+ - bgGray
+ - bgGrey
+
+### bright background colors
+
+ - bgBrightRed
+ - bgBrightGreen
+ - bgBrightYellow
+ - bgBrightBlue
+ - bgBrightMagenta
+ - bgBrightCyan
+ - bgBrightWhite
+
+### styles
+
+ - reset
+ - bold
+ - dim
+ - italic
+ - underline
+ - inverse
+ - hidden
+ - strikethrough
+
+### extras
+
+ - rainbow
+ - zebra
+ - america
+ - trap
+ - random
+
+
+## Usage
+
+By popular demand, `colors` now ships with two types of usages!
+
+The super nifty way
+
+```js
+var colors = require('colors');
+
+console.log('hello'.green); // outputs green text
+console.log('i like cake and pies'.underline.red) // outputs red underlined text
+console.log('inverse the color'.inverse); // inverses the color
+console.log('OMG Rainbows!'.rainbow); // rainbow
+console.log('Run the trap'.trap); // Drops the bass
+
+```
+
+or a slightly less nifty way which doesn't extend `String.prototype`
+
+```js
+var colors = require('colors/safe');
+
+console.log(colors.green('hello')); // outputs green text
+console.log(colors.red.underline('i like cake and pies')) // outputs red underlined text
+console.log(colors.inverse('inverse the color')); // inverses the color
+console.log(colors.rainbow('OMG Rainbows!')); // rainbow
+console.log(colors.trap('Run the trap')); // Drops the bass
+
+```
+
+I prefer the first way. Some people seem to be afraid of extending `String.prototype` and prefer the second way.
+
+If you are writing good code you will never have an issue with the first approach. If you really don't want to touch `String.prototype`, the second usage will not touch `String` native object.
+
+## Enabling/Disabling Colors
+
+The package will auto-detect whether your terminal can use colors and enable/disable accordingly. When colors are disabled, the color functions do nothing. You can override this with a command-line flag:
+
+```bash
+node myapp.js --no-color
+node myapp.js --color=false
+
+node myapp.js --color
+node myapp.js --color=true
+node myapp.js --color=always
+
+FORCE_COLOR=1 node myapp.js
+```
+
+Or in code:
+
+```javascript
+var colors = require('colors');
+colors.enable();
+colors.disable();
+```
+
+## Console.log [string substitution](http://nodejs.org/docs/latest/api/console.html#console_console_log_data)
+
+```js
+var name = 'Marak';
+console.log(colors.green('Hello %s'), name);
+// outputs -> 'Hello Marak'
+```
+
+## Custom themes
+
+### Using standard API
+
+```js
+
+var colors = require('colors');
+
+colors.setTheme({
+ silly: 'rainbow',
+ input: 'grey',
+ verbose: 'cyan',
+ prompt: 'grey',
+ info: 'green',
+ data: 'grey',
+ help: 'cyan',
+ warn: 'yellow',
+ debug: 'blue',
+ error: 'red'
+});
+
+// outputs red text
+console.log("this is an error".error);
+
+// outputs yellow text
+console.log("this is a warning".warn);
+```
+
+### Using string safe API
+
+```js
+var colors = require('colors/safe');
+
+// set single property
+var error = colors.red;
+error('this is red');
+
+// set theme
+colors.setTheme({
+ silly: 'rainbow',
+ input: 'grey',
+ verbose: 'cyan',
+ prompt: 'grey',
+ info: 'green',
+ data: 'grey',
+ help: 'cyan',
+ warn: 'yellow',
+ debug: 'blue',
+ error: 'red'
+});
+
+// outputs red text
+console.log(colors.error("this is an error"));
+
+// outputs yellow text
+console.log(colors.warn("this is a warning"));
+
+```
+
+### Combining Colors
+
+```javascript
+var colors = require('colors');
+
+colors.setTheme({
+ custom: ['red', 'underline']
+});
+
+console.log('test'.custom);
+```
+
+*Protip: There is a secret undocumented style in `colors`. If you find the style you can summon him.*
diff --git a/node_modules/colors/examples/normal-usage.js b/node_modules/colors/examples/normal-usage.js
new file mode 100644
index 0000000..822db1c
--- /dev/null
+++ b/node_modules/colors/examples/normal-usage.js
@@ -0,0 +1,82 @@
+var colors = require('../lib/index');
+
+console.log('First some yellow text'.yellow);
+
+console.log('Underline that text'.yellow.underline);
+
+console.log('Make it bold and red'.red.bold);
+
+console.log(('Double Raindows All Day Long').rainbow);
+
+console.log('Drop the bass'.trap);
+
+console.log('DROP THE RAINBOW BASS'.trap.rainbow);
+
+// styles not widely supported
+console.log('Chains are also cool.'.bold.italic.underline.red);
+
+// styles not widely supported
+console.log('So '.green + 'are'.underline + ' ' + 'inverse'.inverse
+ + ' styles! '.yellow.bold);
+console.log('Zebras are so fun!'.zebra);
+
+//
+// Remark: .strikethrough may not work with Mac OS Terminal App
+//
+console.log('This is ' + 'not'.strikethrough + ' fun.');
+
+console.log('Background color attack!'.black.bgWhite);
+console.log('Use random styles on everything!'.random);
+console.log('America, Heck Yeah!'.america);
+
+console.log('Blindingly '.brightCyan + 'bright? '.brightRed + 'Why '.brightYellow + 'not?!'.brightGreen);
+
+console.log('Setting themes is useful');
+
+//
+// Custom themes
+//
+console.log('Generic logging theme as JSON'.green.bold.underline);
+// Load theme with JSON literal
+colors.setTheme({
+ silly: 'rainbow',
+ input: 'grey',
+ verbose: 'cyan',
+ prompt: 'grey',
+ info: 'green',
+ data: 'grey',
+ help: 'cyan',
+ warn: 'yellow',
+ debug: 'blue',
+ error: 'red',
+});
+
+// outputs red text
+console.log('this is an error'.error);
+
+// outputs yellow text
+console.log('this is a warning'.warn);
+
+// outputs grey text
+console.log('this is an input'.input);
+
+console.log('Generic logging theme as file'.green.bold.underline);
+
+// Load a theme from file
+try {
+ colors.setTheme(require(__dirname + '/../themes/generic-logging.js'));
+} catch (err) {
+ console.log(err);
+}
+
+// outputs red text
+console.log('this is an error'.error);
+
+// outputs yellow text
+console.log('this is a warning'.warn);
+
+// outputs grey text
+console.log('this is an input'.input);
+
+// console.log("Don't summon".zalgo)
+
diff --git a/node_modules/colors/examples/safe-string.js b/node_modules/colors/examples/safe-string.js
new file mode 100644
index 0000000..5bc0168
--- /dev/null
+++ b/node_modules/colors/examples/safe-string.js
@@ -0,0 +1,79 @@
+var colors = require('../safe');
+
+console.log(colors.yellow('First some yellow text'));
+
+console.log(colors.yellow.underline('Underline that text'));
+
+console.log(colors.red.bold('Make it bold and red'));
+
+console.log(colors.rainbow('Double Raindows All Day Long'));
+
+console.log(colors.trap('Drop the bass'));
+
+console.log(colors.rainbow(colors.trap('DROP THE RAINBOW BASS')));
+
+// styles not widely supported
+console.log(colors.bold.italic.underline.red('Chains are also cool.'));
+
+// styles not widely supported
+console.log(colors.green('So ') + colors.underline('are') + ' '
+ + colors.inverse('inverse') + colors.yellow.bold(' styles! '));
+
+console.log(colors.zebra('Zebras are so fun!'));
+
+console.log('This is ' + colors.strikethrough('not') + ' fun.');
+
+
+console.log(colors.black.bgWhite('Background color attack!'));
+console.log(colors.random('Use random styles on everything!'));
+console.log(colors.america('America, Heck Yeah!'));
+
+console.log(colors.brightCyan('Blindingly ') + colors.brightRed('bright? ') + colors.brightYellow('Why ') + colors.brightGreen('not?!'));
+
+console.log('Setting themes is useful');
+
+//
+// Custom themes
+//
+// console.log('Generic logging theme as JSON'.green.bold.underline);
+// Load theme with JSON literal
+colors.setTheme({
+ silly: 'rainbow',
+ input: 'blue',
+ verbose: 'cyan',
+ prompt: 'grey',
+ info: 'green',
+ data: 'grey',
+ help: 'cyan',
+ warn: 'yellow',
+ debug: 'blue',
+ error: 'red',
+});
+
+// outputs red text
+console.log(colors.error('this is an error'));
+
+// outputs yellow text
+console.log(colors.warn('this is a warning'));
+
+// outputs blue text
+console.log(colors.input('this is an input'));
+
+
+// console.log('Generic logging theme as file'.green.bold.underline);
+
+// Load a theme from file
+colors.setTheme(require(__dirname + '/../themes/generic-logging.js'));
+
+// outputs red text
+console.log(colors.error('this is an error'));
+
+// outputs yellow text
+console.log(colors.warn('this is a warning'));
+
+// outputs grey text
+console.log(colors.input('this is an input'));
+
+// console.log(colors.zalgo("Don't summon him"))
+
+
diff --git a/node_modules/colors/index.d.ts b/node_modules/colors/index.d.ts
new file mode 100644
index 0000000..baa7068
--- /dev/null
+++ b/node_modules/colors/index.d.ts
@@ -0,0 +1,136 @@
+// Type definitions for Colors.js 1.2
+// Project: https://github.com/Marak/colors.js
+// Definitions by: Bart van der Schoor , Staffan Eketorp
+// Definitions: https://github.com/Marak/colors.js
+
+export interface Color {
+ (text: string): string;
+
+ strip: Color;
+ stripColors: Color;
+
+ black: Color;
+ red: Color;
+ green: Color;
+ yellow: Color;
+ blue: Color;
+ magenta: Color;
+ cyan: Color;
+ white: Color;
+ gray: Color;
+ grey: Color;
+
+ bgBlack: Color;
+ bgRed: Color;
+ bgGreen: Color;
+ bgYellow: Color;
+ bgBlue: Color;
+ bgMagenta: Color;
+ bgCyan: Color;
+ bgWhite: Color;
+
+ reset: Color;
+ bold: Color;
+ dim: Color;
+ italic: Color;
+ underline: Color;
+ inverse: Color;
+ hidden: Color;
+ strikethrough: Color;
+
+ rainbow: Color;
+ zebra: Color;
+ america: Color;
+ trap: Color;
+ random: Color;
+ zalgo: Color;
+}
+
+export function enable(): void;
+export function disable(): void;
+export function setTheme(theme: any): void;
+
+export let enabled: boolean;
+
+export const strip: Color;
+export const stripColors: Color;
+
+export const black: Color;
+export const red: Color;
+export const green: Color;
+export const yellow: Color;
+export const blue: Color;
+export const magenta: Color;
+export const cyan: Color;
+export const white: Color;
+export const gray: Color;
+export const grey: Color;
+
+export const bgBlack: Color;
+export const bgRed: Color;
+export const bgGreen: Color;
+export const bgYellow: Color;
+export const bgBlue: Color;
+export const bgMagenta: Color;
+export const bgCyan: Color;
+export const bgWhite: Color;
+
+export const reset: Color;
+export const bold: Color;
+export const dim: Color;
+export const italic: Color;
+export const underline: Color;
+export const inverse: Color;
+export const hidden: Color;
+export const strikethrough: Color;
+
+export const rainbow: Color;
+export const zebra: Color;
+export const america: Color;
+export const trap: Color;
+export const random: Color;
+export const zalgo: Color;
+
+declare global {
+ interface String {
+ strip: string;
+ stripColors: string;
+
+ black: string;
+ red: string;
+ green: string;
+ yellow: string;
+ blue: string;
+ magenta: string;
+ cyan: string;
+ white: string;
+ gray: string;
+ grey: string;
+
+ bgBlack: string;
+ bgRed: string;
+ bgGreen: string;
+ bgYellow: string;
+ bgBlue: string;
+ bgMagenta: string;
+ bgCyan: string;
+ bgWhite: string;
+
+ reset: string;
+ // @ts-ignore
+ bold: string;
+ dim: string;
+ italic: string;
+ underline: string;
+ inverse: string;
+ hidden: string;
+ strikethrough: string;
+
+ rainbow: string;
+ zebra: string;
+ america: string;
+ trap: string;
+ random: string;
+ zalgo: string;
+ }
+}
diff --git a/node_modules/colors/lib/colors.js b/node_modules/colors/lib/colors.js
new file mode 100644
index 0000000..9c7f1d1
--- /dev/null
+++ b/node_modules/colors/lib/colors.js
@@ -0,0 +1,211 @@
+/*
+
+The MIT License (MIT)
+
+Original Library
+ - Copyright (c) Marak Squires
+
+Additional functionality
+ - Copyright (c) Sindre Sorhus (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+*/
+
+var colors = {};
+module['exports'] = colors;
+
+colors.themes = {};
+
+var util = require('util');
+var ansiStyles = colors.styles = require('./styles');
+var defineProps = Object.defineProperties;
+var newLineRegex = new RegExp(/[\r\n]+/g);
+
+colors.supportsColor = require('./system/supports-colors').supportsColor;
+
+if (typeof colors.enabled === 'undefined') {
+ colors.enabled = colors.supportsColor() !== false;
+}
+
+colors.enable = function() {
+ colors.enabled = true;
+};
+
+colors.disable = function() {
+ colors.enabled = false;
+};
+
+colors.stripColors = colors.strip = function(str) {
+ return ('' + str).replace(/\x1B\[\d+m/g, '');
+};
+
+// eslint-disable-next-line no-unused-vars
+var stylize = colors.stylize = function stylize(str, style) {
+ if (!colors.enabled) {
+ return str+'';
+ }
+
+ var styleMap = ansiStyles[style];
+
+ // Stylize should work for non-ANSI styles, too
+ if(!styleMap && style in colors){
+ // Style maps like trap operate as functions on strings;
+ // they don't have properties like open or close.
+ return colors[style](str);
+ }
+
+ return styleMap.open + str + styleMap.close;
+};
+
+var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
+var escapeStringRegexp = function(str) {
+ if (typeof str !== 'string') {
+ throw new TypeError('Expected a string');
+ }
+ return str.replace(matchOperatorsRe, '\\$&');
+};
+
+function build(_styles) {
+ var builder = function builder() {
+ return applyStyle.apply(builder, arguments);
+ };
+ builder._styles = _styles;
+ // __proto__ is used because we must return a function, but there is
+ // no way to create a function with a different prototype.
+ builder.__proto__ = proto;
+ return builder;
+}
+
+var styles = (function() {
+ var ret = {};
+ ansiStyles.grey = ansiStyles.gray;
+ Object.keys(ansiStyles).forEach(function(key) {
+ ansiStyles[key].closeRe =
+ new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g');
+ ret[key] = {
+ get: function() {
+ return build(this._styles.concat(key));
+ },
+ };
+ });
+ return ret;
+})();
+
+var proto = defineProps(function colors() {}, styles);
+
+function applyStyle() {
+ var args = Array.prototype.slice.call(arguments);
+
+ var str = args.map(function(arg) {
+ // Use weak equality check so we can colorize null/undefined in safe mode
+ if (arg != null && arg.constructor === String) {
+ return arg;
+ } else {
+ return util.inspect(arg);
+ }
+ }).join(' ');
+
+ if (!colors.enabled || !str) {
+ return str;
+ }
+
+ var newLinesPresent = str.indexOf('\n') != -1;
+
+ var nestedStyles = this._styles;
+
+ var i = nestedStyles.length;
+ while (i--) {
+ var code = ansiStyles[nestedStyles[i]];
+ str = code.open + str.replace(code.closeRe, code.open) + code.close;
+ if (newLinesPresent) {
+ str = str.replace(newLineRegex, function(match) {
+ return code.close + match + code.open;
+ });
+ }
+ }
+
+ return str;
+}
+
+colors.setTheme = function(theme) {
+ if (typeof theme === 'string') {
+ console.log('colors.setTheme now only accepts an object, not a string. ' +
+ 'If you are trying to set a theme from a file, it is now your (the ' +
+ 'caller\'s) responsibility to require the file. The old syntax ' +
+ 'looked like colors.setTheme(__dirname + ' +
+ '\'/../themes/generic-logging.js\'); The new syntax looks like '+
+ 'colors.setTheme(require(__dirname + ' +
+ '\'/../themes/generic-logging.js\'));');
+ return;
+ }
+ for (var style in theme) {
+ (function(style) {
+ colors[style] = function(str) {
+ if (typeof theme[style] === 'object') {
+ var out = str;
+ for (var i in theme[style]) {
+ out = colors[theme[style][i]](out);
+ }
+ return out;
+ }
+ return colors[theme[style]](str);
+ };
+ })(style);
+ }
+};
+
+function init() {
+ var ret = {};
+ Object.keys(styles).forEach(function(name) {
+ ret[name] = {
+ get: function() {
+ return build([name]);
+ },
+ };
+ });
+ return ret;
+}
+
+var sequencer = function sequencer(map, str) {
+ var exploded = str.split('');
+ exploded = exploded.map(map);
+ return exploded.join('');
+};
+
+// custom formatter methods
+colors.trap = require('./custom/trap');
+colors.zalgo = require('./custom/zalgo');
+
+// maps
+colors.maps = {};
+colors.maps.america = require('./maps/america')(colors);
+colors.maps.zebra = require('./maps/zebra')(colors);
+colors.maps.rainbow = require('./maps/rainbow')(colors);
+colors.maps.random = require('./maps/random')(colors);
+
+for (var map in colors.maps) {
+ (function(map) {
+ colors[map] = function(str) {
+ return sequencer(colors.maps[map], str);
+ };
+ })(map);
+}
+
+defineProps(colors, init());
diff --git a/node_modules/colors/lib/custom/trap.js b/node_modules/colors/lib/custom/trap.js
new file mode 100644
index 0000000..fbccf88
--- /dev/null
+++ b/node_modules/colors/lib/custom/trap.js
@@ -0,0 +1,46 @@
+module['exports'] = function runTheTrap(text, options) {
+ var result = '';
+ text = text || 'Run the trap, drop the bass';
+ text = text.split('');
+ var trap = {
+ a: ['\u0040', '\u0104', '\u023a', '\u0245', '\u0394', '\u039b', '\u0414'],
+ b: ['\u00df', '\u0181', '\u0243', '\u026e', '\u03b2', '\u0e3f'],
+ c: ['\u00a9', '\u023b', '\u03fe'],
+ d: ['\u00d0', '\u018a', '\u0500', '\u0501', '\u0502', '\u0503'],
+ e: ['\u00cb', '\u0115', '\u018e', '\u0258', '\u03a3', '\u03be', '\u04bc',
+ '\u0a6c'],
+ f: ['\u04fa'],
+ g: ['\u0262'],
+ h: ['\u0126', '\u0195', '\u04a2', '\u04ba', '\u04c7', '\u050a'],
+ i: ['\u0f0f'],
+ j: ['\u0134'],
+ k: ['\u0138', '\u04a0', '\u04c3', '\u051e'],
+ l: ['\u0139'],
+ m: ['\u028d', '\u04cd', '\u04ce', '\u0520', '\u0521', '\u0d69'],
+ n: ['\u00d1', '\u014b', '\u019d', '\u0376', '\u03a0', '\u048a'],
+ o: ['\u00d8', '\u00f5', '\u00f8', '\u01fe', '\u0298', '\u047a', '\u05dd',
+ '\u06dd', '\u0e4f'],
+ p: ['\u01f7', '\u048e'],
+ q: ['\u09cd'],
+ r: ['\u00ae', '\u01a6', '\u0210', '\u024c', '\u0280', '\u042f'],
+ s: ['\u00a7', '\u03de', '\u03df', '\u03e8'],
+ t: ['\u0141', '\u0166', '\u0373'],
+ u: ['\u01b1', '\u054d'],
+ v: ['\u05d8'],
+ w: ['\u0428', '\u0460', '\u047c', '\u0d70'],
+ x: ['\u04b2', '\u04fe', '\u04fc', '\u04fd'],
+ y: ['\u00a5', '\u04b0', '\u04cb'],
+ z: ['\u01b5', '\u0240'],
+ };
+ text.forEach(function(c) {
+ c = c.toLowerCase();
+ var chars = trap[c] || [' '];
+ var rand = Math.floor(Math.random() * chars.length);
+ if (typeof trap[c] !== 'undefined') {
+ result += trap[c][rand];
+ } else {
+ result += c;
+ }
+ });
+ return result;
+};
diff --git a/node_modules/colors/lib/custom/zalgo.js b/node_modules/colors/lib/custom/zalgo.js
new file mode 100644
index 0000000..0ef2b01
--- /dev/null
+++ b/node_modules/colors/lib/custom/zalgo.js
@@ -0,0 +1,110 @@
+// please no
+module['exports'] = function zalgo(text, options) {
+ text = text || ' he is here ';
+ var soul = {
+ 'up': [
+ '̍', '̎', '̄', '̅',
+ '̿', '̑', '̆', '̐',
+ '͒', '͗', '͑', '̇',
+ '̈', '̊', '͂', '̓',
+ '̈', '͊', '͋', '͌',
+ '̃', '̂', '̌', '͐',
+ '̀', '́', '̋', '̏',
+ '̒', '̓', '̔', '̽',
+ '̉', 'ͣ', 'ͤ', 'ͥ',
+ 'ͦ', 'ͧ', 'ͨ', 'ͩ',
+ 'ͪ', 'ͫ', 'ͬ', 'ͭ',
+ 'ͮ', 'ͯ', '̾', '͛',
+ '͆', '̚',
+ ],
+ 'down': [
+ '̖', '̗', '̘', '̙',
+ '̜', '̝', '̞', '̟',
+ '̠', '̤', '̥', '̦',
+ '̩', '̪', '̫', '̬',
+ '̭', '̮', '̯', '̰',
+ '̱', '̲', '̳', '̹',
+ '̺', '̻', '̼', 'ͅ',
+ '͇', '͈', '͉', '͍',
+ '͎', '͓', '͔', '͕',
+ '͖', '͙', '͚', '̣',
+ ],
+ 'mid': [
+ '̕', '̛', '̀', '́',
+ '͘', '̡', '̢', '̧',
+ '̨', '̴', '̵', '̶',
+ '͜', '͝', '͞',
+ '͟', '͠', '͢', '̸',
+ '̷', '͡', ' ҉',
+ ],
+ };
+ var all = [].concat(soul.up, soul.down, soul.mid);
+
+ function randomNumber(range) {
+ var r = Math.floor(Math.random() * range);
+ return r;
+ }
+
+ function isChar(character) {
+ var bool = false;
+ all.filter(function(i) {
+ bool = (i === character);
+ });
+ return bool;
+ }
+
+
+ function heComes(text, options) {
+ var result = '';
+ var counts;
+ var l;
+ options = options || {};
+ options['up'] =
+ typeof options['up'] !== 'undefined' ? options['up'] : true;
+ options['mid'] =
+ typeof options['mid'] !== 'undefined' ? options['mid'] : true;
+ options['down'] =
+ typeof options['down'] !== 'undefined' ? options['down'] : true;
+ options['size'] =
+ typeof options['size'] !== 'undefined' ? options['size'] : 'maxi';
+ text = text.split('');
+ for (l in text) {
+ if (isChar(l)) {
+ continue;
+ }
+ result = result + text[l];
+ counts = {'up': 0, 'down': 0, 'mid': 0};
+ switch (options.size) {
+ case 'mini':
+ counts.up = randomNumber(8);
+ counts.mid = randomNumber(2);
+ counts.down = randomNumber(8);
+ break;
+ case 'maxi':
+ counts.up = randomNumber(16) + 3;
+ counts.mid = randomNumber(4) + 1;
+ counts.down = randomNumber(64) + 3;
+ break;
+ default:
+ counts.up = randomNumber(8) + 1;
+ counts.mid = randomNumber(6) / 2;
+ counts.down = randomNumber(8) + 1;
+ break;
+ }
+
+ var arr = ['up', 'mid', 'down'];
+ for (var d in arr) {
+ var index = arr[d];
+ for (var i = 0; i <= counts[index]; i++) {
+ if (options[index]) {
+ result = result + soul[index][randomNumber(soul[index].length)];
+ }
+ }
+ }
+ }
+ return result;
+ }
+ // don't summon him
+ return heComes(text, options);
+};
+
diff --git a/node_modules/colors/lib/extendStringPrototype.js b/node_modules/colors/lib/extendStringPrototype.js
new file mode 100644
index 0000000..46fd386
--- /dev/null
+++ b/node_modules/colors/lib/extendStringPrototype.js
@@ -0,0 +1,110 @@
+var colors = require('./colors');
+
+module['exports'] = function() {
+ //
+ // Extends prototype of native string object to allow for "foo".red syntax
+ //
+ var addProperty = function(color, func) {
+ String.prototype.__defineGetter__(color, func);
+ };
+
+ addProperty('strip', function() {
+ return colors.strip(this);
+ });
+
+ addProperty('stripColors', function() {
+ return colors.strip(this);
+ });
+
+ addProperty('trap', function() {
+ return colors.trap(this);
+ });
+
+ addProperty('zalgo', function() {
+ return colors.zalgo(this);
+ });
+
+ addProperty('zebra', function() {
+ return colors.zebra(this);
+ });
+
+ addProperty('rainbow', function() {
+ return colors.rainbow(this);
+ });
+
+ addProperty('random', function() {
+ return colors.random(this);
+ });
+
+ addProperty('america', function() {
+ return colors.america(this);
+ });
+
+ //
+ // Iterate through all default styles and colors
+ //
+ var x = Object.keys(colors.styles);
+ x.forEach(function(style) {
+ addProperty(style, function() {
+ return colors.stylize(this, style);
+ });
+ });
+
+ function applyTheme(theme) {
+ //
+ // Remark: This is a list of methods that exist
+ // on String that you should not overwrite.
+ //
+ var stringPrototypeBlacklist = [
+ '__defineGetter__', '__defineSetter__', '__lookupGetter__',
+ '__lookupSetter__', 'charAt', 'constructor', 'hasOwnProperty',
+ 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString',
+ 'valueOf', 'charCodeAt', 'indexOf', 'lastIndexOf', 'length',
+ 'localeCompare', 'match', 'repeat', 'replace', 'search', 'slice',
+ 'split', 'substring', 'toLocaleLowerCase', 'toLocaleUpperCase',
+ 'toLowerCase', 'toUpperCase', 'trim', 'trimLeft', 'trimRight',
+ ];
+
+ Object.keys(theme).forEach(function(prop) {
+ if (stringPrototypeBlacklist.indexOf(prop) !== -1) {
+ console.log('warn: '.red + ('String.prototype' + prop).magenta +
+ ' is probably something you don\'t want to override. ' +
+ 'Ignoring style name');
+ } else {
+ if (typeof(theme[prop]) === 'string') {
+ colors[prop] = colors[theme[prop]];
+ addProperty(prop, function() {
+ return colors[prop](this);
+ });
+ } else {
+ var themePropApplicator = function(str) {
+ var ret = str || this;
+ for (var t = 0; t < theme[prop].length; t++) {
+ ret = colors[theme[prop][t]](ret);
+ }
+ return ret;
+ };
+ addProperty(prop, themePropApplicator);
+ colors[prop] = function(str) {
+ return themePropApplicator(str);
+ };
+ }
+ }
+ });
+ }
+
+ colors.setTheme = function(theme) {
+ if (typeof theme === 'string') {
+ console.log('colors.setTheme now only accepts an object, not a string. ' +
+ 'If you are trying to set a theme from a file, it is now your (the ' +
+ 'caller\'s) responsibility to require the file. The old syntax ' +
+ 'looked like colors.setTheme(__dirname + ' +
+ '\'/../themes/generic-logging.js\'); The new syntax looks like '+
+ 'colors.setTheme(require(__dirname + ' +
+ '\'/../themes/generic-logging.js\'));');
+ return;
+ } else {
+ applyTheme(theme);
+ }
+ };
+};
diff --git a/node_modules/colors/lib/index.js b/node_modules/colors/lib/index.js
new file mode 100644
index 0000000..9df5ab7
--- /dev/null
+++ b/node_modules/colors/lib/index.js
@@ -0,0 +1,13 @@
+var colors = require('./colors');
+module['exports'] = colors;
+
+// Remark: By default, colors will add style properties to String.prototype.
+//
+// If you don't wish to extend String.prototype, you can do this instead and
+// native String will not be touched:
+//
+// var colors = require('colors/safe);
+// colors.red("foo")
+//
+//
+require('./extendStringPrototype')();
diff --git a/node_modules/colors/lib/maps/america.js b/node_modules/colors/lib/maps/america.js
new file mode 100644
index 0000000..dc96903
--- /dev/null
+++ b/node_modules/colors/lib/maps/america.js
@@ -0,0 +1,10 @@
+module['exports'] = function(colors) {
+ return function(letter, i, exploded) {
+ if (letter === ' ') return letter;
+ switch (i%3) {
+ case 0: return colors.red(letter);
+ case 1: return colors.white(letter);
+ case 2: return colors.blue(letter);
+ }
+ };
+};
diff --git a/node_modules/colors/lib/maps/rainbow.js b/node_modules/colors/lib/maps/rainbow.js
new file mode 100644
index 0000000..2b00ac0
--- /dev/null
+++ b/node_modules/colors/lib/maps/rainbow.js
@@ -0,0 +1,12 @@
+module['exports'] = function(colors) {
+ // RoY G BiV
+ var rainbowColors = ['red', 'yellow', 'green', 'blue', 'magenta'];
+ return function(letter, i, exploded) {
+ if (letter === ' ') {
+ return letter;
+ } else {
+ return colors[rainbowColors[i++ % rainbowColors.length]](letter);
+ }
+ };
+};
+
diff --git a/node_modules/colors/lib/maps/random.js b/node_modules/colors/lib/maps/random.js
new file mode 100644
index 0000000..3d82a39
--- /dev/null
+++ b/node_modules/colors/lib/maps/random.js
@@ -0,0 +1,11 @@
+module['exports'] = function(colors) {
+ var available = ['underline', 'inverse', 'grey', 'yellow', 'red', 'green',
+ 'blue', 'white', 'cyan', 'magenta', 'brightYellow', 'brightRed',
+ 'brightGreen', 'brightBlue', 'brightWhite', 'brightCyan', 'brightMagenta'];
+ return function(letter, i, exploded) {
+ return letter === ' ' ? letter :
+ colors[
+ available[Math.round(Math.random() * (available.length - 2))]
+ ](letter);
+ };
+};
diff --git a/node_modules/colors/lib/maps/zebra.js b/node_modules/colors/lib/maps/zebra.js
new file mode 100644
index 0000000..fa73623
--- /dev/null
+++ b/node_modules/colors/lib/maps/zebra.js
@@ -0,0 +1,5 @@
+module['exports'] = function(colors) {
+ return function(letter, i, exploded) {
+ return i % 2 === 0 ? letter : colors.inverse(letter);
+ };
+};
diff --git a/node_modules/colors/lib/styles.js b/node_modules/colors/lib/styles.js
new file mode 100644
index 0000000..011dafd
--- /dev/null
+++ b/node_modules/colors/lib/styles.js
@@ -0,0 +1,95 @@
+/*
+The MIT License (MIT)
+
+Copyright (c) Sindre Sorhus (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+*/
+
+var styles = {};
+module['exports'] = styles;
+
+var codes = {
+ reset: [0, 0],
+
+ bold: [1, 22],
+ dim: [2, 22],
+ italic: [3, 23],
+ underline: [4, 24],
+ inverse: [7, 27],
+ hidden: [8, 28],
+ strikethrough: [9, 29],
+
+ black: [30, 39],
+ red: [31, 39],
+ green: [32, 39],
+ yellow: [33, 39],
+ blue: [34, 39],
+ magenta: [35, 39],
+ cyan: [36, 39],
+ white: [37, 39],
+ gray: [90, 39],
+ grey: [90, 39],
+
+ brightRed: [91, 39],
+ brightGreen: [92, 39],
+ brightYellow: [93, 39],
+ brightBlue: [94, 39],
+ brightMagenta: [95, 39],
+ brightCyan: [96, 39],
+ brightWhite: [97, 39],
+
+ bgBlack: [40, 49],
+ bgRed: [41, 49],
+ bgGreen: [42, 49],
+ bgYellow: [43, 49],
+ bgBlue: [44, 49],
+ bgMagenta: [45, 49],
+ bgCyan: [46, 49],
+ bgWhite: [47, 49],
+ bgGray: [100, 49],
+ bgGrey: [100, 49],
+
+ bgBrightRed: [101, 49],
+ bgBrightGreen: [102, 49],
+ bgBrightYellow: [103, 49],
+ bgBrightBlue: [104, 49],
+ bgBrightMagenta: [105, 49],
+ bgBrightCyan: [106, 49],
+ bgBrightWhite: [107, 49],
+
+ // legacy styles for colors pre v1.0.0
+ blackBG: [40, 49],
+ redBG: [41, 49],
+ greenBG: [42, 49],
+ yellowBG: [43, 49],
+ blueBG: [44, 49],
+ magentaBG: [45, 49],
+ cyanBG: [46, 49],
+ whiteBG: [47, 49],
+
+};
+
+Object.keys(codes).forEach(function(key) {
+ var val = codes[key];
+ var style = styles[key] = [];
+ style.open = '\u001b[' + val[0] + 'm';
+ style.close = '\u001b[' + val[1] + 'm';
+});
diff --git a/node_modules/colors/lib/system/has-flag.js b/node_modules/colors/lib/system/has-flag.js
new file mode 100644
index 0000000..a347dd4
--- /dev/null
+++ b/node_modules/colors/lib/system/has-flag.js
@@ -0,0 +1,35 @@
+/*
+MIT License
+
+Copyright (c) Sindre Sorhus (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+'use strict';
+
+module.exports = function(flag, argv) {
+ argv = argv || process.argv;
+
+ var terminatorPos = argv.indexOf('--');
+ var prefix = /^-{1,2}/.test(flag) ? '' : '--';
+ var pos = argv.indexOf(prefix + flag);
+
+ return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
+};
diff --git a/node_modules/colors/lib/system/supports-colors.js b/node_modules/colors/lib/system/supports-colors.js
new file mode 100644
index 0000000..f1f9c8f
--- /dev/null
+++ b/node_modules/colors/lib/system/supports-colors.js
@@ -0,0 +1,151 @@
+/*
+The MIT License (MIT)
+
+Copyright (c) Sindre Sorhus (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+*/
+
+'use strict';
+
+var os = require('os');
+var hasFlag = require('./has-flag.js');
+
+var env = process.env;
+
+var forceColor = void 0;
+if (hasFlag('no-color') || hasFlag('no-colors') || hasFlag('color=false')) {
+ forceColor = false;
+} else if (hasFlag('color') || hasFlag('colors') || hasFlag('color=true')
+ || hasFlag('color=always')) {
+ forceColor = true;
+}
+if ('FORCE_COLOR' in env) {
+ forceColor = env.FORCE_COLOR.length === 0
+ || parseInt(env.FORCE_COLOR, 10) !== 0;
+}
+
+function translateLevel(level) {
+ if (level === 0) {
+ return false;
+ }
+
+ return {
+ level: level,
+ hasBasic: true,
+ has256: level >= 2,
+ has16m: level >= 3,
+ };
+}
+
+function supportsColor(stream) {
+ if (forceColor === false) {
+ return 0;
+ }
+
+ if (hasFlag('color=16m') || hasFlag('color=full')
+ || hasFlag('color=truecolor')) {
+ return 3;
+ }
+
+ if (hasFlag('color=256')) {
+ return 2;
+ }
+
+ if (stream && !stream.isTTY && forceColor !== true) {
+ return 0;
+ }
+
+ var min = forceColor ? 1 : 0;
+
+ if (process.platform === 'win32') {
+ // Node.js 7.5.0 is the first version of Node.js to include a patch to
+ // libuv that enables 256 color output on Windows. Anything earlier and it
+ // won't work. However, here we target Node.js 8 at minimum as it is an LTS
+ // release, and Node.js 7 is not. Windows 10 build 10586 is the first
+ // Windows release that supports 256 colors. Windows 10 build 14931 is the
+ // first release that supports 16m/TrueColor.
+ var osRelease = os.release().split('.');
+ if (Number(process.versions.node.split('.')[0]) >= 8
+ && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+ return Number(osRelease[2]) >= 14931 ? 3 : 2;
+ }
+
+ return 1;
+ }
+
+ if ('CI' in env) {
+ if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(function(sign) {
+ return sign in env;
+ }) || env.CI_NAME === 'codeship') {
+ return 1;
+ }
+
+ return min;
+ }
+
+ if ('TEAMCITY_VERSION' in env) {
+ return (/^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0
+ );
+ }
+
+ if ('TERM_PROGRAM' in env) {
+ var version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+
+ switch (env.TERM_PROGRAM) {
+ case 'iTerm.app':
+ return version >= 3 ? 3 : 2;
+ case 'Hyper':
+ return 3;
+ case 'Apple_Terminal':
+ return 2;
+ // No default
+ }
+ }
+
+ if (/-256(color)?$/i.test(env.TERM)) {
+ return 2;
+ }
+
+ if (/^screen|^xterm|^vt100|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+ return 1;
+ }
+
+ if ('COLORTERM' in env) {
+ return 1;
+ }
+
+ if (env.TERM === 'dumb') {
+ return min;
+ }
+
+ return min;
+}
+
+function getSupportLevel(stream) {
+ var level = supportsColor(stream);
+ return translateLevel(level);
+}
+
+module.exports = {
+ supportsColor: getSupportLevel,
+ stdout: getSupportLevel(process.stdout),
+ stderr: getSupportLevel(process.stderr),
+};
diff --git a/node_modules/colors/package.json b/node_modules/colors/package.json
new file mode 100644
index 0000000..dbd71ba
--- /dev/null
+++ b/node_modules/colors/package.json
@@ -0,0 +1,45 @@
+{
+ "name": "colors",
+ "description": "get colors in your node.js console",
+ "version": "1.4.0",
+ "author": "Marak Squires",
+ "contributors": [
+ {
+ "name": "DABH",
+ "url": "https://github.com/DABH"
+ }
+ ],
+ "homepage": "https://github.com/Marak/colors.js",
+ "bugs": "https://github.com/Marak/colors.js/issues",
+ "keywords": [
+ "ansi",
+ "terminal",
+ "colors"
+ ],
+ "repository": {
+ "type": "git",
+ "url": "http://github.com/Marak/colors.js.git"
+ },
+ "license": "MIT",
+ "scripts": {
+ "lint": "eslint . --fix",
+ "test": "node tests/basic-test.js && node tests/safe-test.js"
+ },
+ "engines": {
+ "node": ">=0.1.90"
+ },
+ "main": "lib/index.js",
+ "files": [
+ "examples",
+ "lib",
+ "LICENSE",
+ "safe.js",
+ "themes",
+ "index.d.ts",
+ "safe.d.ts"
+ ],
+ "devDependencies": {
+ "eslint": "^5.2.0",
+ "eslint-config-google": "^0.11.0"
+ }
+}
diff --git a/node_modules/colors/safe.d.ts b/node_modules/colors/safe.d.ts
new file mode 100644
index 0000000..2bafc27
--- /dev/null
+++ b/node_modules/colors/safe.d.ts
@@ -0,0 +1,48 @@
+// Type definitions for Colors.js 1.2
+// Project: https://github.com/Marak/colors.js
+// Definitions by: Bart van der Schoor , Staffan Eketorp
+// Definitions: https://github.com/Marak/colors.js
+
+export const enabled: boolean;
+export function enable(): void;
+export function disable(): void;
+export function setTheme(theme: any): void;
+
+export function strip(str: string): string;
+export function stripColors(str: string): string;
+
+export function black(str: string): string;
+export function red(str: string): string;
+export function green(str: string): string;
+export function yellow(str: string): string;
+export function blue(str: string): string;
+export function magenta(str: string): string;
+export function cyan(str: string): string;
+export function white(str: string): string;
+export function gray(str: string): string;
+export function grey(str: string): string;
+
+export function bgBlack(str: string): string;
+export function bgRed(str: string): string;
+export function bgGreen(str: string): string;
+export function bgYellow(str: string): string;
+export function bgBlue(str: string): string;
+export function bgMagenta(str: string): string;
+export function bgCyan(str: string): string;
+export function bgWhite(str: string): string;
+
+export function reset(str: string): string;
+export function bold(str: string): string;
+export function dim(str: string): string;
+export function italic(str: string): string;
+export function underline(str: string): string;
+export function inverse(str: string): string;
+export function hidden(str: string): string;
+export function strikethrough(str: string): string;
+
+export function rainbow(str: string): string;
+export function zebra(str: string): string;
+export function america(str: string): string;
+export function trap(str: string): string;
+export function random(str: string): string;
+export function zalgo(str: string): string;
diff --git a/node_modules/colors/safe.js b/node_modules/colors/safe.js
new file mode 100644
index 0000000..a013d54
--- /dev/null
+++ b/node_modules/colors/safe.js
@@ -0,0 +1,10 @@
+//
+// Remark: Requiring this file will use the "safe" colors API,
+// which will not touch String.prototype.
+//
+// var colors = require('colors/safe');
+// colors.red("foo")
+//
+//
+var colors = require('./lib/colors');
+module['exports'] = colors;
diff --git a/node_modules/colors/themes/generic-logging.js b/node_modules/colors/themes/generic-logging.js
new file mode 100644
index 0000000..63adfe4
--- /dev/null
+++ b/node_modules/colors/themes/generic-logging.js
@@ -0,0 +1,12 @@
+module['exports'] = {
+ silly: 'rainbow',
+ input: 'grey',
+ verbose: 'cyan',
+ prompt: 'grey',
+ info: 'green',
+ data: 'grey',
+ help: 'cyan',
+ warn: 'yellow',
+ debug: 'blue',
+ error: 'red',
+};
diff --git a/node_modules/dotenv/CHANGELOG.md b/node_modules/dotenv/CHANGELOG.md
new file mode 100644
index 0000000..7bf933b
--- /dev/null
+++ b/node_modules/dotenv/CHANGELOG.md
@@ -0,0 +1,155 @@
+# Changelog
+
+All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+
+## [8.2.0](https://github.com/motdotla/dotenv/compare/v8.1.0...v8.2.0) (2019-10-16)
+
+## [8.1.0](https://github.com/motdotla/dotenv/compare/v7.0.0...v8.1.0) (2019-08-18)
+
+
+### ⚠ BREAKING CHANGES
+
+* dropping Node v6 support because end-of-life
+
+* Drop support for Node v6 (#392) ([2e9636a](https://github.com/motdotla/dotenv/commit/2e9636a)), closes [#392](https://github.com/motdotla/dotenv/issues/392)
+
+# [8.0.0](https://github.com/motdotla/dotenv/compare/v7.0.0...v8.0.0) (2019-05-02)
+
+- Drop support for Node v6 (#392) ([2e9636a](https://github.com/motdotla/dotenv/commit/2e9636a)), closes [#392](https://github.com/motdotla/dotenv/issues/392)
+
+### BREAKING CHANGES
+
+- dropping Node v6 support because end-of-life
+
+## [7.0.0] - 2019-03-12
+
+### Fixed
+
+- Fix removing unbalanced quotes ([#376](https://github.com/motdotla/dotenv/pull/376))
+
+### Removed
+
+- Removed `load` alias for `config` for consistency throughout code and documentation.
+
+## [6.2.0] - 2018-12-03
+
+### Added
+
+- Support preload configuration via environment variables ([#351](https://github.com/motdotla/dotenv/issues/351))
+
+## [6.1.0] - 2018-10-08
+
+### Added
+
+- `debug` option for `config` and `parse` methods will turn on logging
+
+## [6.0.0] - 2018-06-02
+
+### Changed
+
+- _Breaking:_ drop support for Node v4 ([#304](https://github.com/motdotla/dotenv/pull/304))
+
+## [5.0.0] - 2018-01-29
+
+### Added
+
+- Testing against Node v8 and v9
+- Documentation on trim behavior of values
+- Documentation on how to use with `import`
+
+### Changed
+
+- _Breaking_: default `path` is now `path.resolve(process.cwd(), '.env')`
+- _Breaking_: does not write over keys already in `process.env` if the key has a falsy value
+- using `const` and `let` instead of `var`
+
+### Removed
+
+- Testing against Node v7
+
+## [4.0.0] - 2016-12-23
+
+### Changed
+
+- Return Object with parsed content or error instead of false ([#165](https://github.com/motdotla/dotenv/pull/165)).
+
+### Removed
+
+- `verbose` option removed in favor of returning result.
+
+## [3.0.0] - 2016-12-20
+
+### Added
+
+- `verbose` option will log any error messages. Off by default.
+- parses email addresses correctly
+- allow importing config method directly in ES6
+
+### Changed
+
+- Suppress error messages by default ([#154](https://github.com/motdotla/dotenv/pull/154))
+- Ignoring more files for NPM to make package download smaller
+
+### Fixed
+
+- False positive test due to case-sensitive variable ([#124](https://github.com/motdotla/dotenv/pull/124))
+
+### Removed
+
+- `silent` option removed in favor of `verbose`
+
+## [2.0.0] - 2016-01-20
+
+### Added
+
+- CHANGELOG to ["make it easier for users and contributors to see precisely what notable changes have been made between each release"](http://keepachangelog.com/). Linked to from README
+- LICENSE to be more explicit about what was defined in `package.json`. Linked to from README
+- Testing nodejs v4 on travis-ci
+- added examples of how to use dotenv in different ways
+- return parsed object on success rather than boolean true
+
+### Changed
+
+- README has shorter description not referencing ruby gem since we don't have or want feature parity
+
+### Removed
+
+- Variable expansion and escaping so environment variables are encouraged to be fully orthogonal
+
+## [1.2.0] - 2015-06-20
+
+### Added
+
+- Preload hook to require dotenv without including it in your code
+
+### Changed
+
+- clarified license to be "BSD-2-Clause" in `package.json`
+
+### Fixed
+
+- retain spaces in string vars
+
+## [1.1.0] - 2015-03-31
+
+### Added
+
+- Silent option to silence `console.log` when `.env` missing
+
+## [1.0.0] - 2015-03-13
+
+### Removed
+
+- support for multiple `.env` files. should always use one `.env` file for the current environment
+
+[7.0.0]: https://github.com/motdotla/dotenv/compare/v6.2.0...v7.0.0
+[6.2.0]: https://github.com/motdotla/dotenv/compare/v6.1.0...v6.2.0
+[6.1.0]: https://github.com/motdotla/dotenv/compare/v6.0.0...v6.1.0
+[6.0.0]: https://github.com/motdotla/dotenv/compare/v5.0.0...v6.0.0
+[5.0.0]: https://github.com/motdotla/dotenv/compare/v4.0.0...v5.0.0
+[4.0.0]: https://github.com/motdotla/dotenv/compare/v3.0.0...v4.0.0
+[3.0.0]: https://github.com/motdotla/dotenv/compare/v2.0.0...v3.0.0
+[2.0.0]: https://github.com/motdotla/dotenv/compare/v1.2.0...v2.0.0
+[1.2.0]: https://github.com/motdotla/dotenv/compare/v1.1.0...v1.2.0
+[1.1.0]: https://github.com/motdotla/dotenv/compare/v1.0.0...v1.1.0
+[1.0.0]: https://github.com/motdotla/dotenv/compare/v0.4.0...v1.0.0
diff --git a/node_modules/dotenv/LICENSE b/node_modules/dotenv/LICENSE
new file mode 100644
index 0000000..c430ad8
--- /dev/null
+++ b/node_modules/dotenv/LICENSE
@@ -0,0 +1,23 @@
+Copyright (c) 2015, Scott Motte
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/node_modules/dotenv/README.md b/node_modules/dotenv/README.md
new file mode 100644
index 0000000..cf65c9e
--- /dev/null
+++ b/node_modules/dotenv/README.md
@@ -0,0 +1,271 @@
+# dotenv
+
+=value`
+
+```bash
+$ node -r dotenv/config your_script.js dotenv_config_path=/custom/path/to/your/env/vars
+```
+
+Additionally, you can use environment variables to set configuration options. Command line arguments will precede these.
+
+```bash
+$ DOTENV_CONFIG_ =value node -r dotenv/config your_script.js
+```
+
+```bash
+$ DOTENV_CONFIG_ENCODING=latin1 node -r dotenv/config your_script.js dotenv_config_path=/custom/path/to/.env
+```
+
+## Config
+
+`config` will read your `.env` file, parse the contents, assign it to
+[`process.env`](https://nodejs.org/docs/latest/api/process.html#process_process_env),
+and return an Object with a `parsed` key containing the loaded content or an `error` key if it failed.
+
+```js
+const result = dotenv.config()
+
+if (result.error) {
+ throw result.error
+}
+
+console.log(result.parsed)
+```
+
+You can additionally, pass options to `config`.
+
+### Options
+
+#### Path
+
+Default: `path.resolve(process.cwd(), '.env')`
+
+You may specify a custom path if your file containing environment variables is located elsewhere.
+
+```js
+require('dotenv').config({ path: '/full/custom/path/to/your/env/vars' })
+```
+
+#### Encoding
+
+Default: `utf8`
+
+You may specify the encoding of your file containing environment variables.
+
+```js
+require('dotenv').config({ encoding: 'latin1' })
+```
+
+#### Debug
+
+Default: `false`
+
+You may turn on logging to help debug why certain keys or values are not being set as you expect.
+
+```js
+require('dotenv').config({ debug: process.env.DEBUG })
+```
+
+## Parse
+
+The engine which parses the contents of your file containing environment
+variables is available to use. It accepts a String or Buffer and will return
+an Object with the parsed keys and values.
+
+```js
+const dotenv = require('dotenv')
+const buf = Buffer.from('BASIC=basic')
+const config = dotenv.parse(buf) // will return an object
+console.log(typeof config, config) // object { BASIC : 'basic' }
+```
+
+### Options
+
+#### Debug
+
+Default: `false`
+
+You may turn on logging to help debug why certain keys or values are not being set as you expect.
+
+```js
+const dotenv = require('dotenv')
+const buf = Buffer.from('hello world')
+const opt = { debug: true }
+const config = dotenv.parse(buf, opt)
+// expect a debug message because the buffer is not in KEY=VAL form
+```
+
+### Rules
+
+The parsing engine currently supports the following rules:
+
+- `BASIC=basic` becomes `{BASIC: 'basic'}`
+- empty lines are skipped
+- lines beginning with `#` are treated as comments
+- empty values become empty strings (`EMPTY=` becomes `{EMPTY: ''}`)
+- inner quotes are maintained (think JSON) (`JSON={"foo": "bar"}` becomes `{JSON:"{\"foo\": \"bar\"}"`)
+- whitespace is removed from both ends of unquoted values (see more on [`trim`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim)) (`FOO= some value ` becomes `{FOO: 'some value'}`)
+- single and double quoted values are escaped (`SINGLE_QUOTE='quoted'` becomes `{SINGLE_QUOTE: "quoted"}`)
+- single and double quoted values maintain whitespace from both ends (`FOO=" some value "` becomes `{FOO: ' some value '}`)
+- double quoted values expand new lines (`MULTILINE="new\nline"` becomes
+
+```
+{MULTILINE: 'new
+line'}
+```
+
+## FAQ
+
+### Should I commit my `.env` file?
+
+No. We **strongly** recommend against committing your `.env` file to version
+control. It should only include environment-specific values such as database
+passwords or API keys. Your production database should have a different
+password than your development database.
+
+### Should I have multiple `.env` files?
+
+No. We **strongly** recommend against having a "main" `.env` file and an "environment" `.env` file like `.env.test`. Your config should vary between deploys, and you should not be sharing values between environments.
+
+> In a twelve-factor app, env vars are granular controls, each fully orthogonal to other env vars. They are never grouped together as “environments”, but instead are independently managed for each deploy. This is a model that scales up smoothly as the app naturally expands into more deploys over its lifetime.
+>
+> – [The Twelve-Factor App](http://12factor.net/config)
+
+### What happens to environment variables that were already set?
+
+We will never modify any environment variables that have already been set. In particular, if there is a variable in your `.env` file which collides with one that already exists in your environment, then that variable will be skipped. This behavior allows you to override all `.env` configurations with a machine-specific environment, although it is not recommended.
+
+If you want to override `process.env` you can do something like this:
+
+```javascript
+const fs = require('fs')
+const dotenv = require('dotenv')
+const envConfig = dotenv.parse(fs.readFileSync('.env.override'))
+for (const k in envConfig) {
+ process.env[k] = envConfig[k]
+}
+```
+
+### Can I customize/write plugins for dotenv?
+
+For `dotenv@2.x.x`: Yes. `dotenv.config()` now returns an object representing
+the parsed `.env` file. This gives you everything you need to continue
+setting values on `process.env`. For example:
+
+```js
+const dotenv = require('dotenv')
+const variableExpansion = require('dotenv-expand')
+const myEnv = dotenv.config()
+variableExpansion(myEnv)
+```
+
+### What about variable expansion?
+
+Try [dotenv-expand](https://github.com/motdotla/dotenv-expand)
+
+### How do I use dotenv with `import`?
+
+ES2015 and beyond offers modules that allow you to `export` any top-level `function`, `class`, `var`, `let`, or `const`.
+
+> When you run a module containing an `import` declaration, the modules it imports are loaded first, then each module body is executed in a depth-first traversal of the dependency graph, avoiding cycles by skipping anything already executed.
+>
+> – [ES6 In Depth: Modules](https://hacks.mozilla.org/2015/08/es6-in-depth-modules/)
+
+You must run `dotenv.config()` before referencing any environment variables. Here's an example of problematic code:
+
+`errorReporter.js`:
+
+```js
+import { Client } from 'best-error-reporting-service'
+
+export const client = new Client(process.env.BEST_API_KEY)
+```
+
+`index.js`:
+
+```js
+import dotenv from 'dotenv'
+import errorReporter from './errorReporter'
+
+dotenv.config()
+errorReporter.client.report(new Error('faq example'))
+```
+
+`client` will not be configured correctly because it was constructed before `dotenv.config()` was executed. There are (at least) 3 ways to make this work.
+
+1. Preload dotenv: `node --require dotenv/config index.js` (_Note: you do not need to `import` dotenv with this approach_)
+2. Import `dotenv/config` instead of `dotenv` (_Note: you do not need to call `dotenv.config()` and must pass options via the command line or environment variables with this approach_)
+3. Create a separate file that will execute `config` first as outlined in [this comment on #133](https://github.com/motdotla/dotenv/issues/133#issuecomment-255298822)
+
+## Contributing Guide
+
+See [CONTRIBUTING.md](CONTRIBUTING.md)
+
+## Change Log
+
+See [CHANGELOG.md](CHANGELOG.md)
+
+## Who's using dotenv?
+
+[These npm modules depend on it.](https://www.npmjs.com/browse/depended/dotenv)
+
+Projects that expand it often use the [keyword "dotenv" on npm](https://www.npmjs.com/search?q=keywords:dotenv).
diff --git a/node_modules/dotenv/config.js b/node_modules/dotenv/config.js
new file mode 100644
index 0000000..c7e6447
--- /dev/null
+++ b/node_modules/dotenv/config.js
@@ -0,0 +1,11 @@
+/* @flow */
+
+(function () {
+ require('./lib/main').config(
+ Object.assign(
+ {},
+ require('./lib/env-options'),
+ require('./lib/cli-options')(process.argv)
+ )
+ )
+})()
diff --git a/node_modules/dotenv/lib/cli-options.js b/node_modules/dotenv/lib/cli-options.js
new file mode 100644
index 0000000..ad69fab
--- /dev/null
+++ b/node_modules/dotenv/lib/cli-options.js
@@ -0,0 +1,13 @@
+/* @flow */
+
+const re = /^dotenv_config_(encoding|path|debug)=(.+)$/
+
+module.exports = function optionMatcher (args /*: Array */) {
+ return args.reduce(function (acc, cur) {
+ const matches = cur.match(re)
+ if (matches) {
+ acc[matches[1]] = matches[2]
+ }
+ return acc
+ }, {})
+}
diff --git a/node_modules/dotenv/lib/env-options.js b/node_modules/dotenv/lib/env-options.js
new file mode 100644
index 0000000..b4c4a60
--- /dev/null
+++ b/node_modules/dotenv/lib/env-options.js
@@ -0,0 +1,18 @@
+/* @flow */
+
+// ../config.js accepts options via environment variables
+const options = {}
+
+if (process.env.DOTENV_CONFIG_ENCODING != null) {
+ options.encoding = process.env.DOTENV_CONFIG_ENCODING
+}
+
+if (process.env.DOTENV_CONFIG_PATH != null) {
+ options.path = process.env.DOTENV_CONFIG_PATH
+}
+
+if (process.env.DOTENV_CONFIG_DEBUG != null) {
+ options.debug = process.env.DOTENV_CONFIG_DEBUG
+}
+
+module.exports = options
diff --git a/node_modules/dotenv/lib/main.js b/node_modules/dotenv/lib/main.js
new file mode 100644
index 0000000..e6c591c
--- /dev/null
+++ b/node_modules/dotenv/lib/main.js
@@ -0,0 +1,113 @@
+/* @flow */
+/*::
+
+type DotenvParseOptions = {
+ debug?: boolean
+}
+
+// keys and values from src
+type DotenvParseOutput = { [string]: string }
+
+type DotenvConfigOptions = {
+ path?: string, // path to .env file
+ encoding?: string, // encoding of .env file
+ debug?: string // turn on logging for debugging purposes
+}
+
+type DotenvConfigOutput = {
+ parsed?: DotenvParseOutput,
+ error?: Error
+}
+
+*/
+
+const fs = require('fs')
+const path = require('path')
+
+function log (message /*: string */) {
+ console.log(`[dotenv][DEBUG] ${message}`)
+}
+
+const NEWLINE = '\n'
+const RE_INI_KEY_VAL = /^\s*([\w.-]+)\s*=\s*(.*)?\s*$/
+const RE_NEWLINES = /\\n/g
+const NEWLINES_MATCH = /\n|\r|\r\n/
+
+// Parses src into an Object
+function parse (src /*: string | Buffer */, options /*: ?DotenvParseOptions */) /*: DotenvParseOutput */ {
+ const debug = Boolean(options && options.debug)
+ const obj = {}
+
+ // convert Buffers before splitting into lines and processing
+ src.toString().split(NEWLINES_MATCH).forEach(function (line, idx) {
+ // matching "KEY' and 'VAL' in 'KEY=VAL'
+ const keyValueArr = line.match(RE_INI_KEY_VAL)
+ // matched?
+ if (keyValueArr != null) {
+ const key = keyValueArr[1]
+ // default undefined or missing values to empty string
+ let val = (keyValueArr[2] || '')
+ const end = val.length - 1
+ const isDoubleQuoted = val[0] === '"' && val[end] === '"'
+ const isSingleQuoted = val[0] === "'" && val[end] === "'"
+
+ // if single or double quoted, remove quotes
+ if (isSingleQuoted || isDoubleQuoted) {
+ val = val.substring(1, end)
+
+ // if double quoted, expand newlines
+ if (isDoubleQuoted) {
+ val = val.replace(RE_NEWLINES, NEWLINE)
+ }
+ } else {
+ // remove surrounding whitespace
+ val = val.trim()
+ }
+
+ obj[key] = val
+ } else if (debug) {
+ log(`did not match key and value when parsing line ${idx + 1}: ${line}`)
+ }
+ })
+
+ return obj
+}
+
+// Populates process.env from .env file
+function config (options /*: ?DotenvConfigOptions */) /*: DotenvConfigOutput */ {
+ let dotenvPath = path.resolve(process.cwd(), '.env')
+ let encoding /*: string */ = 'utf8'
+ let debug = false
+
+ if (options) {
+ if (options.path != null) {
+ dotenvPath = options.path
+ }
+ if (options.encoding != null) {
+ encoding = options.encoding
+ }
+ if (options.debug != null) {
+ debug = true
+ }
+ }
+
+ try {
+ // specifying an encoding returns a string instead of a buffer
+ const parsed = parse(fs.readFileSync(dotenvPath, { encoding }), { debug })
+
+ Object.keys(parsed).forEach(function (key) {
+ if (!Object.prototype.hasOwnProperty.call(process.env, key)) {
+ process.env[key] = parsed[key]
+ } else if (debug) {
+ log(`"${key}" is already defined in \`process.env\` and will not be overwritten`)
+ }
+ })
+
+ return { parsed }
+ } catch (e) {
+ return { error: e }
+ }
+}
+
+module.exports.config = config
+module.exports.parse = parse
diff --git a/node_modules/dotenv/package.json b/node_modules/dotenv/package.json
new file mode 100644
index 0000000..648dcf8
--- /dev/null
+++ b/node_modules/dotenv/package.json
@@ -0,0 +1,51 @@
+{
+ "name": "dotenv",
+ "version": "8.2.0",
+ "description": "Loads environment variables from .env file",
+ "main": "lib/main.js",
+ "types": "types",
+ "scripts": {
+ "flow": "flow",
+ "dtslint": "dtslint types",
+ "lint": "standard",
+ "postlint": "standard-markdown",
+ "pretest": "npm run lint && npm run dtslint",
+ "test": "tap tests/*.js --100",
+ "prerelease": "npm test",
+ "release": "standard-version"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/motdotla/dotenv.git"
+ },
+ "keywords": [
+ "dotenv",
+ "env",
+ ".env",
+ "environment",
+ "variables",
+ "config",
+ "settings"
+ ],
+ "readmeFilename": "README.md",
+ "license": "BSD-2-Clause",
+ "devDependencies": {
+ "decache": "^4.5.1",
+ "dtslint": "^0.9.8",
+ "flow-bin": "^0.109.0",
+ "sinon": "^7.5.0",
+ "standard": "^13.1.0",
+ "standard-markdown": "^5.1.0",
+ "standard-version": "^7.0.0",
+ "tap": "^14.7.0"
+ },
+ "dependencies": {},
+ "engines": {
+ "node": ">=8"
+ },
+ "standard": {
+ "ignore": [
+ "flow-typed/"
+ ]
+ }
+}
diff --git a/node_modules/dotenv/types/index.d.ts b/node_modules/dotenv/types/index.d.ts
new file mode 100644
index 0000000..a83184c
--- /dev/null
+++ b/node_modules/dotenv/types/index.d.ts
@@ -0,0 +1,59 @@
+// TypeScript Version: 3.0
+/// (http://jeditoolkit.com)",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/Gozala/events.git",
+ "web": "https://github.com/Gozala/events"
+ },
+ "bugs": {
+ "url": "http://github.com/Gozala/events/issues/"
+ },
+ "main": "./events.js",
+ "engines": {
+ "node": ">=0.8.x"
+ },
+ "devDependencies": {
+ "airtap": "^1.0.0",
+ "functions-have-names": "^1.2.1",
+ "has": "^1.0.3",
+ "has-symbols": "^1.0.1",
+ "isarray": "^2.0.5",
+ "tape": "^5.0.0"
+ },
+ "scripts": {
+ "test": "node tests/index.js",
+ "test:browsers": "airtap -- tests/index.js"
+ },
+ "license": "MIT"
+}
diff --git a/node_modules/events/security.md b/node_modules/events/security.md
new file mode 100644
index 0000000..a14ace6
--- /dev/null
+++ b/node_modules/events/security.md
@@ -0,0 +1,10 @@
+# Security Policy
+
+## Supported Versions
+Only the latest major version is supported at any given time.
+
+## Reporting a Vulnerability
+
+To report a security vulnerability, please use the
+[Tidelift security contact](https://tidelift.com/security).
+Tidelift will coordinate the fix and disclosure.
diff --git a/node_modules/events/tests/add-listeners.js b/node_modules/events/tests/add-listeners.js
new file mode 100644
index 0000000..9b57827
--- /dev/null
+++ b/node_modules/events/tests/add-listeners.js
@@ -0,0 +1,111 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var common = require('./common');
+var assert = require('assert');
+var EventEmitter = require('../');
+
+{
+ var ee = new EventEmitter();
+ var events_new_listener_emitted = [];
+ var listeners_new_listener_emitted = [];
+
+ // Sanity check
+ assert.strictEqual(ee.addListener, ee.on);
+
+ ee.on('newListener', function(event, listener) {
+ // Don't track newListener listeners.
+ if (event === 'newListener')
+ return;
+
+ events_new_listener_emitted.push(event);
+ listeners_new_listener_emitted.push(listener);
+ });
+
+ var hello = common.mustCall(function(a, b) {
+ assert.strictEqual('a', a);
+ assert.strictEqual('b', b);
+ });
+
+ ee.once('newListener', function(name, listener) {
+ assert.strictEqual(name, 'hello');
+ assert.strictEqual(listener, hello);
+
+ var listeners = this.listeners('hello');
+ assert.ok(Array.isArray(listeners));
+ assert.strictEqual(listeners.length, 0);
+ });
+
+ ee.on('hello', hello);
+ ee.once('foo', assert.fail);
+
+ assert.ok(Array.isArray(events_new_listener_emitted));
+ assert.strictEqual(events_new_listener_emitted.length, 2);
+ assert.strictEqual(events_new_listener_emitted[0], 'hello');
+ assert.strictEqual(events_new_listener_emitted[1], 'foo');
+
+ assert.ok(Array.isArray(listeners_new_listener_emitted));
+ assert.strictEqual(listeners_new_listener_emitted.length, 2);
+ assert.strictEqual(listeners_new_listener_emitted[0], hello);
+ assert.strictEqual(listeners_new_listener_emitted[1], assert.fail);
+
+ ee.emit('hello', 'a', 'b');
+}
+
+// just make sure that this doesn't throw:
+{
+ var f = new EventEmitter();
+
+ f.setMaxListeners(0);
+}
+
+{
+ var listen1 = function() {};
+ var listen2 = function() {};
+ var ee = new EventEmitter();
+
+ ee.once('newListener', function() {
+ var listeners = ee.listeners('hello');
+ assert.ok(Array.isArray(listeners));
+ assert.strictEqual(listeners.length, 0);
+ ee.once('newListener', function() {
+ var listeners = ee.listeners('hello');
+ assert.ok(Array.isArray(listeners));
+ assert.strictEqual(listeners.length, 0);
+ });
+ ee.on('hello', listen2);
+ });
+ ee.on('hello', listen1);
+ // The order of listeners on an event is not always the order in which the
+ // listeners were added.
+ var listeners = ee.listeners('hello');
+ assert.ok(Array.isArray(listeners));
+ assert.strictEqual(listeners.length, 2);
+ assert.strictEqual(listeners[0], listen2);
+ assert.strictEqual(listeners[1], listen1);
+}
+
+// Verify that the listener must be a function
+assert.throws(function() {
+ var ee = new EventEmitter();
+
+ ee.on('foo', null);
+}, /^TypeError: The "listener" argument must be of type Function. Received type object$/);
diff --git a/node_modules/events/tests/check-listener-leaks.js b/node_modules/events/tests/check-listener-leaks.js
new file mode 100644
index 0000000..7fce48f
--- /dev/null
+++ b/node_modules/events/tests/check-listener-leaks.js
@@ -0,0 +1,101 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var common = require('./common');
+var assert = require('assert');
+var events = require('../');
+
+// Redirect warning output to tape.
+var consoleWarn = console.warn;
+console.warn = common.test.comment;
+
+common.test.on('end', function () {
+ console.warn = consoleWarn;
+});
+
+// default
+{
+ var e = new events.EventEmitter();
+
+ for (var i = 0; i < 10; i++) {
+ e.on('default', common.mustNotCall());
+ }
+ assert.ok(!e._events['default'].hasOwnProperty('warned'));
+ e.on('default', common.mustNotCall());
+ assert.ok(e._events['default'].warned);
+
+ // specific
+ e.setMaxListeners(5);
+ for (var i = 0; i < 5; i++) {
+ e.on('specific', common.mustNotCall());
+ }
+ assert.ok(!e._events['specific'].hasOwnProperty('warned'));
+ e.on('specific', common.mustNotCall());
+ assert.ok(e._events['specific'].warned);
+
+ // only one
+ e.setMaxListeners(1);
+ e.on('only one', common.mustNotCall());
+ assert.ok(!e._events['only one'].hasOwnProperty('warned'));
+ e.on('only one', common.mustNotCall());
+ assert.ok(e._events['only one'].hasOwnProperty('warned'));
+
+ // unlimited
+ e.setMaxListeners(0);
+ for (var i = 0; i < 1000; i++) {
+ e.on('unlimited', common.mustNotCall());
+ }
+ assert.ok(!e._events['unlimited'].hasOwnProperty('warned'));
+}
+
+// process-wide
+{
+ events.EventEmitter.defaultMaxListeners = 42;
+ var e = new events.EventEmitter();
+
+ for (var i = 0; i < 42; ++i) {
+ e.on('fortytwo', common.mustNotCall());
+ }
+ assert.ok(!e._events['fortytwo'].hasOwnProperty('warned'));
+ e.on('fortytwo', common.mustNotCall());
+ assert.ok(e._events['fortytwo'].hasOwnProperty('warned'));
+ delete e._events['fortytwo'].warned;
+
+ events.EventEmitter.defaultMaxListeners = 44;
+ e.on('fortytwo', common.mustNotCall());
+ assert.ok(!e._events['fortytwo'].hasOwnProperty('warned'));
+ e.on('fortytwo', common.mustNotCall());
+ assert.ok(e._events['fortytwo'].hasOwnProperty('warned'));
+}
+
+// but _maxListeners still has precedence over defaultMaxListeners
+{
+ events.EventEmitter.defaultMaxListeners = 42;
+ var e = new events.EventEmitter();
+ e.setMaxListeners(1);
+ e.on('uno', common.mustNotCall());
+ assert.ok(!e._events['uno'].hasOwnProperty('warned'));
+ e.on('uno', common.mustNotCall());
+ assert.ok(e._events['uno'].hasOwnProperty('warned'));
+
+ // chainable
+ assert.strictEqual(e, e.setMaxListeners(1));
+}
diff --git a/node_modules/events/tests/common.js b/node_modules/events/tests/common.js
new file mode 100644
index 0000000..49569b0
--- /dev/null
+++ b/node_modules/events/tests/common.js
@@ -0,0 +1,104 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var test = require('tape');
+var assert = require('assert');
+
+var noop = function() {};
+
+var mustCallChecks = [];
+
+function runCallChecks(exitCode) {
+ if (exitCode !== 0) return;
+
+ var failed = filter(mustCallChecks, function(context) {
+ if ('minimum' in context) {
+ context.messageSegment = 'at least ' + context.minimum;
+ return context.actual < context.minimum;
+ } else {
+ context.messageSegment = 'exactly ' + context.exact;
+ return context.actual !== context.exact;
+ }
+ });
+
+ for (var i = 0; i < failed.length; i++) {
+ var context = failed[i];
+ console.log('Mismatched %s function calls. Expected %s, actual %d.',
+ context.name,
+ context.messageSegment,
+ context.actual);
+ // IE8 has no .stack
+ if (context.stack) console.log(context.stack.split('\n').slice(2).join('\n'));
+ }
+
+ assert.strictEqual(failed.length, 0);
+}
+
+exports.mustCall = function(fn, exact) {
+ return _mustCallInner(fn, exact, 'exact');
+};
+
+function _mustCallInner(fn, criteria, field) {
+ if (typeof criteria == 'undefined') criteria = 1;
+
+ if (typeof fn === 'number') {
+ criteria = fn;
+ fn = noop;
+ } else if (fn === undefined) {
+ fn = noop;
+ }
+
+ if (typeof criteria !== 'number')
+ throw new TypeError('Invalid ' + field + ' value: ' + criteria);
+
+ var context = {
+ actual: 0,
+ stack: (new Error()).stack,
+ name: fn.name || ''
+ };
+
+ context[field] = criteria;
+
+ // add the exit listener only once to avoid listener leak warnings
+ if (mustCallChecks.length === 0) test.onFinish(function() { runCallChecks(0); });
+
+ mustCallChecks.push(context);
+
+ return function() {
+ context.actual++;
+ return fn.apply(this, arguments);
+ };
+}
+
+exports.mustNotCall = function(msg) {
+ return function mustNotCall() {
+ assert.fail(msg || 'function should not have been called');
+ };
+};
+
+function filter(arr, fn) {
+ if (arr.filter) return arr.filter(fn);
+ var filtered = [];
+ for (var i = 0; i < arr.length; i++) {
+ if (fn(arr[i], i, arr)) filtered.push(arr[i]);
+ }
+ return filtered
+}
diff --git a/node_modules/events/tests/errors.js b/node_modules/events/tests/errors.js
new file mode 100644
index 0000000..a23df43
--- /dev/null
+++ b/node_modules/events/tests/errors.js
@@ -0,0 +1,13 @@
+'use strict';
+var assert = require('assert');
+var EventEmitter = require('../');
+
+var EE = new EventEmitter();
+
+assert.throws(function () {
+ EE.emit('error', 'Accepts a string');
+}, 'Error: Unhandled error. (Accepts a string)');
+
+assert.throws(function () {
+ EE.emit('error', { message: 'Error!' });
+}, 'Unhandled error. ([object Object])');
diff --git a/node_modules/events/tests/events-list.js b/node_modules/events/tests/events-list.js
new file mode 100644
index 0000000..08aa621
--- /dev/null
+++ b/node_modules/events/tests/events-list.js
@@ -0,0 +1,28 @@
+'use strict';
+
+var EventEmitter = require('../');
+var assert = require('assert');
+
+var EE = new EventEmitter();
+var m = function() {};
+EE.on('foo', function() {});
+assert.equal(1, EE.eventNames().length);
+assert.equal('foo', EE.eventNames()[0]);
+EE.on('bar', m);
+assert.equal(2, EE.eventNames().length);
+assert.equal('foo', EE.eventNames()[0]);
+assert.equal('bar', EE.eventNames()[1]);
+EE.removeListener('bar', m);
+assert.equal(1, EE.eventNames().length);
+assert.equal('foo', EE.eventNames()[0]);
+
+if (typeof Symbol !== 'undefined') {
+ var s = Symbol('s');
+ EE.on(s, m);
+ assert.equal(2, EE.eventNames().length);
+ assert.equal('foo', EE.eventNames()[0]);
+ assert.equal(s, EE.eventNames()[1]);
+ EE.removeListener(s, m);
+ assert.equal(1, EE.eventNames().length);
+ assert.equal('foo', EE.eventNames()[0]);
+}
diff --git a/node_modules/events/tests/events-once.js b/node_modules/events/tests/events-once.js
new file mode 100644
index 0000000..dae8649
--- /dev/null
+++ b/node_modules/events/tests/events-once.js
@@ -0,0 +1,234 @@
+'use strict';
+
+var common = require('./common');
+var EventEmitter = require('../').EventEmitter;
+var once = require('../').once;
+var has = require('has');
+var assert = require('assert');
+
+function Event(type) {
+ this.type = type;
+}
+
+function EventTargetMock() {
+ this.events = {};
+
+ this.addEventListener = common.mustCall(this.addEventListener);
+ this.removeEventListener = common.mustCall(this.removeEventListener);
+}
+
+EventTargetMock.prototype.addEventListener = function addEventListener(name, listener, options) {
+ if (!(name in this.events)) {
+ this.events[name] = { listeners: [], options: options || {} }
+ }
+ this.events[name].listeners.push(listener);
+};
+
+EventTargetMock.prototype.removeEventListener = function removeEventListener(name, callback) {
+ if (!(name in this.events)) {
+ return;
+ }
+ var event = this.events[name];
+ var stack = event.listeners;
+
+ for (var i = 0, l = stack.length; i < l; i++) {
+ if (stack[i] === callback) {
+ stack.splice(i, 1);
+ if (stack.length === 0) {
+ delete this.events[name];
+ }
+ return;
+ }
+ }
+};
+
+EventTargetMock.prototype.dispatchEvent = function dispatchEvent(arg) {
+ if (!(arg.type in this.events)) {
+ return true;
+ }
+
+ var event = this.events[arg.type];
+ var stack = event.listeners.slice();
+
+ for (var i = 0, l = stack.length; i < l; i++) {
+ stack[i].call(null, arg);
+ if (event.options.once) {
+ this.removeEventListener(arg.type, stack[i]);
+ }
+ }
+ return !arg.defaultPrevented;
+};
+
+function onceAnEvent() {
+ var ee = new EventEmitter();
+
+ process.nextTick(function () {
+ ee.emit('myevent', 42);
+ });
+
+ return once(ee, 'myevent').then(function (args) {
+ var value = args[0]
+ assert.strictEqual(value, 42);
+ assert.strictEqual(ee.listenerCount('error'), 0);
+ assert.strictEqual(ee.listenerCount('myevent'), 0);
+ });
+}
+
+function onceAnEventWithTwoArgs() {
+ var ee = new EventEmitter();
+
+ process.nextTick(function () {
+ ee.emit('myevent', 42, 24);
+ });
+
+ return once(ee, 'myevent').then(function (value) {
+ assert.strictEqual(value.length, 2);
+ assert.strictEqual(value[0], 42);
+ assert.strictEqual(value[1], 24);
+ });
+}
+
+function catchesErrors() {
+ var ee = new EventEmitter();
+
+ var expected = new Error('kaboom');
+ var err;
+ process.nextTick(function () {
+ ee.emit('error', expected);
+ });
+
+ return once(ee, 'myevent').then(function () {
+ throw new Error('should reject')
+ }, function (err) {
+ assert.strictEqual(err, expected);
+ assert.strictEqual(ee.listenerCount('error'), 0);
+ assert.strictEqual(ee.listenerCount('myevent'), 0);
+ });
+}
+
+function stopListeningAfterCatchingError() {
+ var ee = new EventEmitter();
+
+ var expected = new Error('kaboom');
+ var err;
+ process.nextTick(function () {
+ ee.emit('error', expected);
+ ee.emit('myevent', 42, 24);
+ });
+
+ // process.on('multipleResolves', common.mustNotCall());
+
+ return once(ee, 'myevent').then(common.mustNotCall, function (err) {
+ // process.removeAllListeners('multipleResolves');
+ assert.strictEqual(err, expected);
+ assert.strictEqual(ee.listenerCount('error'), 0);
+ assert.strictEqual(ee.listenerCount('myevent'), 0);
+ });
+}
+
+function onceError() {
+ var ee = new EventEmitter();
+
+ var expected = new Error('kaboom');
+ process.nextTick(function () {
+ ee.emit('error', expected);
+ });
+
+ var promise = once(ee, 'error');
+ assert.strictEqual(ee.listenerCount('error'), 1);
+ return promise.then(function (args) {
+ var err = args[0]
+ assert.strictEqual(err, expected);
+ assert.strictEqual(ee.listenerCount('error'), 0);
+ assert.strictEqual(ee.listenerCount('myevent'), 0);
+ });
+}
+
+function onceWithEventTarget() {
+ var et = new EventTargetMock();
+ var event = new Event('myevent');
+ process.nextTick(function () {
+ et.dispatchEvent(event);
+ });
+ return once(et, 'myevent').then(function (args) {
+ var value = args[0];
+ assert.strictEqual(value, event);
+ assert.strictEqual(has(et.events, 'myevent'), false);
+ });
+}
+
+function onceWithEventTargetError() {
+ var et = new EventTargetMock();
+ var error = new Event('error');
+ process.nextTick(function () {
+ et.dispatchEvent(error);
+ });
+ return once(et, 'error').then(function (args) {
+ var err = args[0];
+ assert.strictEqual(err, error);
+ assert.strictEqual(has(et.events, 'error'), false);
+ });
+}
+
+function prioritizesEventEmitter() {
+ var ee = new EventEmitter();
+ ee.addEventListener = assert.fail;
+ ee.removeAllListeners = assert.fail;
+ process.nextTick(function () {
+ ee.emit('foo');
+ });
+ return once(ee, 'foo');
+}
+
+var allTests = [
+ onceAnEvent(),
+ onceAnEventWithTwoArgs(),
+ catchesErrors(),
+ stopListeningAfterCatchingError(),
+ onceError(),
+ onceWithEventTarget(),
+ onceWithEventTargetError(),
+ prioritizesEventEmitter()
+];
+
+var hasBrowserEventTarget = false;
+try {
+ hasBrowserEventTarget = typeof (new window.EventTarget().addEventListener) === 'function' &&
+ new window.Event('xyz').type === 'xyz';
+} catch (err) {}
+
+if (hasBrowserEventTarget) {
+ var onceWithBrowserEventTarget = function onceWithBrowserEventTarget() {
+ var et = new window.EventTarget();
+ var event = new window.Event('myevent');
+ process.nextTick(function () {
+ et.dispatchEvent(event);
+ });
+ return once(et, 'myevent').then(function (args) {
+ var value = args[0];
+ assert.strictEqual(value, event);
+ assert.strictEqual(has(et.events, 'myevent'), false);
+ });
+ }
+
+ var onceWithBrowserEventTargetError = function onceWithBrowserEventTargetError() {
+ var et = new window.EventTarget();
+ var error = new window.Event('error');
+ process.nextTick(function () {
+ et.dispatchEvent(error);
+ });
+ return once(et, 'error').then(function (args) {
+ var err = args[0];
+ assert.strictEqual(err, error);
+ assert.strictEqual(has(et.events, 'error'), false);
+ });
+ }
+
+ common.test.comment('Testing with browser built-in EventTarget');
+ allTests.push([
+ onceWithBrowserEventTarget(),
+ onceWithBrowserEventTargetError()
+ ]);
+}
+
+module.exports = Promise.all(allTests);
diff --git a/node_modules/events/tests/index.js b/node_modules/events/tests/index.js
new file mode 100644
index 0000000..2d739e6
--- /dev/null
+++ b/node_modules/events/tests/index.js
@@ -0,0 +1,64 @@
+var test = require('tape');
+var functionsHaveNames = require('functions-have-names');
+var hasSymbols = require('has-symbols');
+
+require('./legacy-compat');
+var common = require('./common');
+
+// we do this to easily wrap each file in a mocha test
+// and also have browserify be able to statically analyze this file
+var orig_require = require;
+var require = function(file) {
+ test(file, function(t) {
+ // Store the tape object so tests can access it.
+ t.on('end', function () { delete common.test; });
+ common.test = t;
+
+ try {
+ var exp = orig_require(file);
+ if (exp && exp.then) {
+ exp.then(function () { t.end(); }, t.fail);
+ return;
+ }
+ } catch (err) {
+ t.fail(err);
+ }
+ t.end();
+ });
+};
+
+require('./add-listeners.js');
+require('./check-listener-leaks.js');
+require('./errors.js');
+require('./events-list.js');
+if (typeof Promise === 'function') {
+ require('./events-once.js');
+} else {
+ // Promise support is not available.
+ test('./events-once.js', { skip: true }, function () {});
+}
+require('./listener-count.js');
+require('./listeners-side-effects.js');
+require('./listeners.js');
+require('./max-listeners.js');
+if (functionsHaveNames()) {
+ require('./method-names.js');
+} else {
+ // Function.name is not supported in IE
+ test('./method-names.js', { skip: true }, function () {});
+}
+require('./modify-in-emit.js');
+require('./num-args.js');
+require('./once.js');
+require('./prepend.js');
+require('./set-max-listeners-side-effects.js');
+require('./special-event-names.js');
+require('./subclass.js');
+if (hasSymbols()) {
+ require('./symbols.js');
+} else {
+ // Symbol is not available.
+ test('./symbols.js', { skip: true }, function () {});
+}
+require('./remove-all-listeners.js');
+require('./remove-listeners.js');
diff --git a/node_modules/events/tests/legacy-compat.js b/node_modules/events/tests/legacy-compat.js
new file mode 100644
index 0000000..a402be6
--- /dev/null
+++ b/node_modules/events/tests/legacy-compat.js
@@ -0,0 +1,16 @@
+// sigh... life is hard
+if (!global.console) {
+ console = {}
+}
+
+var fns = ['log', 'error', 'trace'];
+for (var i=0 ; ifoo should not be emitted');
+}
+
+e.once('foo', remove);
+e.removeListener('foo', remove);
+e.emit('foo');
+
+e.once('e', common.mustCall(function() {
+ e.emit('e');
+}));
+
+e.once('e', common.mustCall());
+
+e.emit('e');
+
+// Verify that the listener must be a function
+assert.throws(function() {
+ var ee = new EventEmitter();
+
+ ee.once('foo', null);
+}, /^TypeError: The "listener" argument must be of type Function. Received type object$/);
+
+{
+ // once() has different code paths based on the number of arguments being
+ // emitted. Verify that all of the cases are covered.
+ var maxArgs = 4;
+
+ for (var i = 0; i <= maxArgs; ++i) {
+ var ee = new EventEmitter();
+ var args = ['foo'];
+
+ for (var j = 0; j < i; ++j)
+ args.push(j);
+
+ ee.once('foo', common.mustCall(function() {
+ var params = Array.prototype.slice.call(arguments);
+ var restArgs = args.slice(1);
+ assert.ok(Array.isArray(params));
+ assert.strictEqual(params.length, restArgs.length);
+ for (var index = 0; index < params.length; index++) {
+ var param = params[index];
+ assert.strictEqual(param, restArgs[index]);
+ }
+ }));
+
+ EventEmitter.prototype.emit.apply(ee, args);
+ }
+}
diff --git a/node_modules/events/tests/prepend.js b/node_modules/events/tests/prepend.js
new file mode 100644
index 0000000..79afde0
--- /dev/null
+++ b/node_modules/events/tests/prepend.js
@@ -0,0 +1,31 @@
+'use strict';
+
+var common = require('./common');
+var EventEmitter = require('../');
+var assert = require('assert');
+
+var myEE = new EventEmitter();
+var m = 0;
+// This one comes last.
+myEE.on('foo', common.mustCall(function () {
+ assert.strictEqual(m, 2);
+}));
+
+// This one comes second.
+myEE.prependListener('foo', common.mustCall(function () {
+ assert.strictEqual(m++, 1);
+}));
+
+// This one comes first.
+myEE.prependOnceListener('foo',
+ common.mustCall(function () {
+ assert.strictEqual(m++, 0);
+ }));
+
+myEE.emit('foo');
+
+// Verify that the listener must be a function
+assert.throws(function () {
+ var ee = new EventEmitter();
+ ee.prependOnceListener('foo', null);
+}, 'TypeError: The "listener" argument must be of type Function. Received type object');
diff --git a/node_modules/events/tests/remove-all-listeners.js b/node_modules/events/tests/remove-all-listeners.js
new file mode 100644
index 0000000..622941c
--- /dev/null
+++ b/node_modules/events/tests/remove-all-listeners.js
@@ -0,0 +1,133 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var common = require('./common');
+var assert = require('assert');
+var events = require('../');
+var test = require('tape');
+
+function expect(expected) {
+ var actual = [];
+ test.onFinish(function() {
+ var sortedActual = actual.sort();
+ var sortedExpected = expected.sort();
+ assert.strictEqual(sortedActual.length, sortedExpected.length);
+ for (var index = 0; index < sortedActual.length; index++) {
+ var value = sortedActual[index];
+ assert.strictEqual(value, sortedExpected[index]);
+ }
+ });
+ function listener(name) {
+ actual.push(name);
+ }
+ return common.mustCall(listener, expected.length);
+}
+
+{
+ var ee = new events.EventEmitter();
+ var noop = common.mustNotCall();
+ ee.on('foo', noop);
+ ee.on('bar', noop);
+ ee.on('baz', noop);
+ ee.on('baz', noop);
+ var fooListeners = ee.listeners('foo');
+ var barListeners = ee.listeners('bar');
+ var bazListeners = ee.listeners('baz');
+ ee.on('removeListener', expect(['bar', 'baz', 'baz']));
+ ee.removeAllListeners('bar');
+ ee.removeAllListeners('baz');
+
+ var listeners = ee.listeners('foo');
+ assert.ok(Array.isArray(listeners));
+ assert.strictEqual(listeners.length, 1);
+ assert.strictEqual(listeners[0], noop);
+
+ listeners = ee.listeners('bar');
+ assert.ok(Array.isArray(listeners));
+ assert.strictEqual(listeners.length, 0);
+ listeners = ee.listeners('baz');
+ assert.ok(Array.isArray(listeners));
+ assert.strictEqual(listeners.length, 0);
+ // After calling removeAllListeners(),
+ // the old listeners array should stay unchanged.
+ assert.strictEqual(fooListeners.length, 1);
+ assert.strictEqual(fooListeners[0], noop);
+ assert.strictEqual(barListeners.length, 1);
+ assert.strictEqual(barListeners[0], noop);
+ assert.strictEqual(bazListeners.length, 2);
+ assert.strictEqual(bazListeners[0], noop);
+ assert.strictEqual(bazListeners[1], noop);
+ // After calling removeAllListeners(),
+ // new listeners arrays is different from the old.
+ assert.notStrictEqual(ee.listeners('bar'), barListeners);
+ assert.notStrictEqual(ee.listeners('baz'), bazListeners);
+}
+
+{
+ var ee = new events.EventEmitter();
+ ee.on('foo', common.mustNotCall());
+ ee.on('bar', common.mustNotCall());
+ // Expect LIFO order
+ ee.on('removeListener', expect(['foo', 'bar', 'removeListener']));
+ ee.on('removeListener', expect(['foo', 'bar']));
+ ee.removeAllListeners();
+
+ var listeners = ee.listeners('foo');
+ assert.ok(Array.isArray(listeners));
+ assert.strictEqual(listeners.length, 0);
+ listeners = ee.listeners('bar');
+ assert.ok(Array.isArray(listeners));
+ assert.strictEqual(listeners.length, 0);
+}
+
+{
+ var ee = new events.EventEmitter();
+ ee.on('removeListener', common.mustNotCall());
+ // Check for regression where removeAllListeners() throws when
+ // there exists a 'removeListener' listener, but there exists
+ // no listeners for the provided event type.
+ assert.doesNotThrow(function () { ee.removeAllListeners(ee, 'foo') });
+}
+
+{
+ var ee = new events.EventEmitter();
+ var expectLength = 2;
+ ee.on('removeListener', function() {
+ assert.strictEqual(expectLength--, this.listeners('baz').length);
+ });
+ ee.on('baz', common.mustNotCall());
+ ee.on('baz', common.mustNotCall());
+ ee.on('baz', common.mustNotCall());
+ assert.strictEqual(ee.listeners('baz').length, expectLength + 1);
+ ee.removeAllListeners('baz');
+ assert.strictEqual(ee.listeners('baz').length, 0);
+}
+
+{
+ var ee = new events.EventEmitter();
+ assert.strictEqual(ee, ee.removeAllListeners());
+}
+
+{
+ var ee = new events.EventEmitter();
+ ee._events = undefined;
+ assert.strictEqual(ee, ee.removeAllListeners());
+}
diff --git a/node_modules/events/tests/remove-listeners.js b/node_modules/events/tests/remove-listeners.js
new file mode 100644
index 0000000..18e4d16
--- /dev/null
+++ b/node_modules/events/tests/remove-listeners.js
@@ -0,0 +1,212 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var common = require('./common');
+var assert = require('assert');
+var EventEmitter = require('../');
+
+var listener1 = function listener1() {};
+var listener2 = function listener2() {};
+
+{
+ var ee = new EventEmitter();
+ ee.on('hello', listener1);
+ ee.on('removeListener', common.mustCall(function(name, cb) {
+ assert.strictEqual(name, 'hello');
+ assert.strictEqual(cb, listener1);
+ }));
+ ee.removeListener('hello', listener1);
+ var listeners = ee.listeners('hello');
+ assert.ok(Array.isArray(listeners));
+ assert.strictEqual(listeners.length, 0);
+}
+
+{
+ var ee = new EventEmitter();
+ ee.on('hello', listener1);
+ ee.on('removeListener', common.mustNotCall());
+ ee.removeListener('hello', listener2);
+
+ var listeners = ee.listeners('hello');
+ assert.ok(Array.isArray(listeners));
+ assert.strictEqual(listeners.length, 1);
+ assert.strictEqual(listeners[0], listener1);
+}
+
+{
+ var ee = new EventEmitter();
+ ee.on('hello', listener1);
+ ee.on('hello', listener2);
+
+ var listeners;
+ ee.once('removeListener', common.mustCall(function(name, cb) {
+ assert.strictEqual(name, 'hello');
+ assert.strictEqual(cb, listener1);
+ listeners = ee.listeners('hello');
+ assert.ok(Array.isArray(listeners));
+ assert.strictEqual(listeners.length, 1);
+ assert.strictEqual(listeners[0], listener2);
+ }));
+ ee.removeListener('hello', listener1);
+ listeners = ee.listeners('hello');
+ assert.ok(Array.isArray(listeners));
+ assert.strictEqual(listeners.length, 1);
+ assert.strictEqual(listeners[0], listener2);
+ ee.once('removeListener', common.mustCall(function(name, cb) {
+ assert.strictEqual(name, 'hello');
+ assert.strictEqual(cb, listener2);
+ listeners = ee.listeners('hello');
+ assert.ok(Array.isArray(listeners));
+ assert.strictEqual(listeners.length, 0);
+ }));
+ ee.removeListener('hello', listener2);
+ listeners = ee.listeners('hello');
+ assert.ok(Array.isArray(listeners));
+ assert.strictEqual(listeners.length, 0);
+}
+
+{
+ var ee = new EventEmitter();
+
+ function remove1() {
+ assert.fail('remove1 should not have been called');
+ }
+
+ function remove2() {
+ assert.fail('remove2 should not have been called');
+ }
+
+ ee.on('removeListener', common.mustCall(function(name, cb) {
+ if (cb !== remove1) return;
+ this.removeListener('quux', remove2);
+ this.emit('quux');
+ }, 2));
+ ee.on('quux', remove1);
+ ee.on('quux', remove2);
+ ee.removeListener('quux', remove1);
+}
+
+{
+ var ee = new EventEmitter();
+ ee.on('hello', listener1);
+ ee.on('hello', listener2);
+
+ var listeners;
+ ee.once('removeListener', common.mustCall(function(name, cb) {
+ assert.strictEqual(name, 'hello');
+ assert.strictEqual(cb, listener1);
+ listeners = ee.listeners('hello');
+ assert.ok(Array.isArray(listeners));
+ assert.strictEqual(listeners.length, 1);
+ assert.strictEqual(listeners[0], listener2);
+ ee.once('removeListener', common.mustCall(function(name, cb) {
+ assert.strictEqual(name, 'hello');
+ assert.strictEqual(cb, listener2);
+ listeners = ee.listeners('hello');
+ assert.ok(Array.isArray(listeners));
+ assert.strictEqual(listeners.length, 0);
+ }));
+ ee.removeListener('hello', listener2);
+ listeners = ee.listeners('hello');
+ assert.ok(Array.isArray(listeners));
+ assert.strictEqual(listeners.length, 0);
+ }));
+ ee.removeListener('hello', listener1);
+ listeners = ee.listeners('hello');
+ assert.ok(Array.isArray(listeners));
+ assert.strictEqual(listeners.length, 0);
+}
+
+{
+ var ee = new EventEmitter();
+ var listener3 = common.mustCall(function() {
+ ee.removeListener('hello', listener4);
+ }, 2);
+ var listener4 = common.mustCall();
+
+ ee.on('hello', listener3);
+ ee.on('hello', listener4);
+
+ // listener4 will still be called although it is removed by listener 3.
+ ee.emit('hello');
+ // This is so because the interal listener array at time of emit
+ // was [listener3,listener4]
+
+ // Interal listener array [listener3]
+ ee.emit('hello');
+}
+
+{
+ var ee = new EventEmitter();
+
+ ee.once('hello', listener1);
+ ee.on('removeListener', common.mustCall(function(eventName, listener) {
+ assert.strictEqual(eventName, 'hello');
+ assert.strictEqual(listener, listener1);
+ }));
+ ee.emit('hello');
+}
+
+{
+ var ee = new EventEmitter();
+
+ assert.strictEqual(ee, ee.removeListener('foo', function() {}));
+}
+
+// Verify that the removed listener must be a function
+assert.throws(function() {
+ var ee = new EventEmitter();
+
+ ee.removeListener('foo', null);
+}, /^TypeError: The "listener" argument must be of type Function\. Received type object$/);
+
+{
+ var ee = new EventEmitter();
+ var listener = function() {};
+ ee._events = undefined;
+ var e = ee.removeListener('foo', listener);
+ assert.strictEqual(e, ee);
+}
+
+{
+ var ee = new EventEmitter();
+
+ ee.on('foo', listener1);
+ ee.on('foo', listener2);
+ var listeners = ee.listeners('foo');
+ assert.ok(Array.isArray(listeners));
+ assert.strictEqual(listeners.length, 2);
+ assert.strictEqual(listeners[0], listener1);
+ assert.strictEqual(listeners[1], listener2);
+
+ ee.removeListener('foo', listener1);
+ assert.strictEqual(ee._events.foo, listener2);
+
+ ee.on('foo', listener1);
+ listeners = ee.listeners('foo');
+ assert.ok(Array.isArray(listeners));
+ assert.strictEqual(listeners.length, 2);
+ assert.strictEqual(listeners[0], listener2);
+ assert.strictEqual(listeners[1], listener1);
+
+ ee.removeListener('foo', listener1);
+ assert.strictEqual(ee._events.foo, listener2);
+}
diff --git a/node_modules/events/tests/set-max-listeners-side-effects.js b/node_modules/events/tests/set-max-listeners-side-effects.js
new file mode 100644
index 0000000..13dbb67
--- /dev/null
+++ b/node_modules/events/tests/set-max-listeners-side-effects.js
@@ -0,0 +1,31 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require('./common');
+var assert = require('assert');
+var events = require('../');
+
+var e = new events.EventEmitter();
+
+if (Object.create) assert.ok(!(e._events instanceof Object));
+assert.strictEqual(Object.keys(e._events).length, 0);
+e.setMaxListeners(5);
+assert.strictEqual(Object.keys(e._events).length, 0);
diff --git a/node_modules/events/tests/special-event-names.js b/node_modules/events/tests/special-event-names.js
new file mode 100644
index 0000000..a2f0b74
--- /dev/null
+++ b/node_modules/events/tests/special-event-names.js
@@ -0,0 +1,45 @@
+'use strict';
+
+var common = require('./common');
+var EventEmitter = require('../');
+var assert = require('assert');
+
+var ee = new EventEmitter();
+var handler = function() {};
+
+assert.strictEqual(ee.eventNames().length, 0);
+
+assert.strictEqual(ee._events.hasOwnProperty, undefined);
+assert.strictEqual(ee._events.toString, undefined);
+
+ee.on('__defineGetter__', handler);
+ee.on('toString', handler);
+ee.on('__proto__', handler);
+
+assert.strictEqual(ee.eventNames()[0], '__defineGetter__');
+assert.strictEqual(ee.eventNames()[1], 'toString');
+
+assert.strictEqual(ee.listeners('__defineGetter__').length, 1);
+assert.strictEqual(ee.listeners('__defineGetter__')[0], handler);
+assert.strictEqual(ee.listeners('toString').length, 1);
+assert.strictEqual(ee.listeners('toString')[0], handler);
+
+// Only run __proto__ tests if that property can actually be set
+if ({ __proto__: 'ok' }.__proto__ === 'ok') {
+ assert.strictEqual(ee.eventNames().length, 3);
+ assert.strictEqual(ee.eventNames()[2], '__proto__');
+ assert.strictEqual(ee.listeners('__proto__').length, 1);
+ assert.strictEqual(ee.listeners('__proto__')[0], handler);
+
+ ee.on('__proto__', common.mustCall(function(val) {
+ assert.strictEqual(val, 1);
+ }));
+ ee.emit('__proto__', 1);
+
+ process.on('__proto__', common.mustCall(function(val) {
+ assert.strictEqual(val, 1);
+ }));
+ process.emit('__proto__', 1);
+} else {
+ console.log('# skipped __proto__')
+}
diff --git a/node_modules/events/tests/subclass.js b/node_modules/events/tests/subclass.js
new file mode 100644
index 0000000..bd033ff
--- /dev/null
+++ b/node_modules/events/tests/subclass.js
@@ -0,0 +1,66 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var common = require('./common');
+var test = require('tape');
+var assert = require('assert');
+var EventEmitter = require('../').EventEmitter;
+var util = require('util');
+
+util.inherits(MyEE, EventEmitter);
+
+function MyEE(cb) {
+ this.once(1, cb);
+ this.emit(1);
+ this.removeAllListeners();
+ EventEmitter.call(this);
+}
+
+var myee = new MyEE(common.mustCall());
+
+
+util.inherits(ErrorEE, EventEmitter);
+function ErrorEE() {
+ this.emit('error', new Error('blerg'));
+}
+
+assert.throws(function() {
+ new ErrorEE();
+}, /blerg/);
+
+test.onFinish(function() {
+ assert.ok(!(myee._events instanceof Object));
+ assert.strictEqual(Object.keys(myee._events).length, 0);
+});
+
+
+function MyEE2() {
+ EventEmitter.call(this);
+}
+
+MyEE2.prototype = new EventEmitter();
+
+var ee1 = new MyEE2();
+var ee2 = new MyEE2();
+
+ee1.on('x', function() {});
+
+assert.strictEqual(ee2.listenerCount('x'), 0);
diff --git a/node_modules/events/tests/symbols.js b/node_modules/events/tests/symbols.js
new file mode 100644
index 0000000..0721f0e
--- /dev/null
+++ b/node_modules/events/tests/symbols.js
@@ -0,0 +1,25 @@
+'use strict';
+
+var common = require('./common');
+var EventEmitter = require('../');
+var assert = require('assert');
+
+var ee = new EventEmitter();
+var foo = Symbol('foo');
+var listener = common.mustCall();
+
+ee.on(foo, listener);
+assert.strictEqual(ee.listeners(foo).length, 1);
+assert.strictEqual(ee.listeners(foo)[0], listener);
+
+ee.emit(foo);
+
+ee.removeAllListeners();
+assert.strictEqual(ee.listeners(foo).length, 0);
+
+ee.on(foo, listener);
+assert.strictEqual(ee.listeners(foo).length, 1);
+assert.strictEqual(ee.listeners(foo)[0], listener);
+
+ee.removeListener(foo, listener);
+assert.strictEqual(ee.listeners(foo).length, 0);
diff --git a/node_modules/file-uri-to-path/.npmignore b/node_modules/file-uri-to-path/.npmignore
new file mode 100644
index 0000000..07e6e47
--- /dev/null
+++ b/node_modules/file-uri-to-path/.npmignore
@@ -0,0 +1 @@
+/node_modules
diff --git a/node_modules/file-uri-to-path/.travis.yml b/node_modules/file-uri-to-path/.travis.yml
new file mode 100644
index 0000000..016bb6e
--- /dev/null
+++ b/node_modules/file-uri-to-path/.travis.yml
@@ -0,0 +1,30 @@
+sudo: false
+
+language: node_js
+
+node_js:
+ - "0.8"
+ - "0.10"
+ - "0.12"
+ - "1"
+ - "2"
+ - "3"
+ - "4"
+ - "5"
+ - "6"
+ - "7"
+ - "8"
+
+install:
+ - PATH="`npm bin`:`npm bin -g`:$PATH"
+ # Node 0.8 comes with a too obsolete npm
+ - if [[ "`node --version`" =~ ^v0\.8\. ]]; then npm install -g npm@1.4.28 ; fi
+ # Install dependencies and build
+ - npm install
+
+script:
+ # Output useful info for debugging
+ - node --version
+ - npm --version
+ # Run tests
+ - npm test
diff --git a/node_modules/file-uri-to-path/History.md b/node_modules/file-uri-to-path/History.md
new file mode 100644
index 0000000..c8682be
--- /dev/null
+++ b/node_modules/file-uri-to-path/History.md
@@ -0,0 +1,21 @@
+
+1.0.0 / 2017-07-06
+==================
+
+ * update "mocha" to v3
+ * fixed unicode URI decoding (#6)
+ * add typings for Typescript
+ * README: use SVG Travis-CI badge
+ * add LICENSE file (MIT)
+ * add .travis.yml file (testing Node.js 0.8 through 8 currently)
+ * add README.md file
+
+0.0.2 / 2014-01-27
+==================
+
+ * index: invert the path separators on Windows
+
+0.0.1 / 2014-01-27
+==================
+
+ * initial commit
diff --git a/node_modules/file-uri-to-path/LICENSE b/node_modules/file-uri-to-path/LICENSE
new file mode 100644
index 0000000..e1af783
--- /dev/null
+++ b/node_modules/file-uri-to-path/LICENSE
@@ -0,0 +1,20 @@
+Copyright (c) 2014 Nathan Rajlich
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/file-uri-to-path/README.md b/node_modules/file-uri-to-path/README.md
new file mode 100644
index 0000000..ab30be8
--- /dev/null
+++ b/node_modules/file-uri-to-path/README.md
@@ -0,0 +1,74 @@
+file-uri-to-path
+================
+### Convert a `file:` URI to a file path
+[](https://travis-ci.org/TooTallNate/file-uri-to-path)
+
+Accepts a `file:` URI and returns a regular file path suitable for use with the
+`fs` module functions.
+
+
+Installation
+------------
+
+Install with `npm`:
+
+``` bash
+$ npm install file-uri-to-path
+```
+
+
+Example
+-------
+
+``` js
+var uri2path = require('file-uri-to-path');
+
+uri2path('file://localhost/c|/WINDOWS/clock.avi');
+// "c:\\WINDOWS\\clock.avi"
+
+uri2path('file:///c|/WINDOWS/clock.avi');
+// "c:\\WINDOWS\\clock.avi"
+
+uri2path('file://localhost/c:/WINDOWS/clock.avi');
+// "c:\\WINDOWS\\clock.avi"
+
+uri2path('file://hostname/path/to/the%20file.txt');
+// "\\\\hostname\\path\\to\\the file.txt"
+
+uri2path('file:///c:/path/to/the%20file.txt');
+// "c:\\path\\to\\the file.txt"
+```
+
+
+API
+---
+
+### fileUriToPath(String uri) → String
+
+
+
+License
+-------
+
+(The MIT License)
+
+Copyright (c) 2014 Nathan Rajlich <nathan@tootallnate.net>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/file-uri-to-path/index.d.ts b/node_modules/file-uri-to-path/index.d.ts
new file mode 100644
index 0000000..99dc3f9
--- /dev/null
+++ b/node_modules/file-uri-to-path/index.d.ts
@@ -0,0 +1,2 @@
+declare function fileUriToPath(uri: string): string;
+export = fileUriToPath;
diff --git a/node_modules/file-uri-to-path/index.js b/node_modules/file-uri-to-path/index.js
new file mode 100644
index 0000000..48cb280
--- /dev/null
+++ b/node_modules/file-uri-to-path/index.js
@@ -0,0 +1,66 @@
+
+/**
+ * Module dependencies.
+ */
+
+var sep = require('path').sep || '/';
+
+/**
+ * Module exports.
+ */
+
+module.exports = fileUriToPath;
+
+/**
+ * File URI to Path function.
+ *
+ * @param {String} uri
+ * @return {String} path
+ * @api public
+ */
+
+function fileUriToPath (uri) {
+ if ('string' != typeof uri ||
+ uri.length <= 7 ||
+ 'file://' != uri.substring(0, 7)) {
+ throw new TypeError('must pass in a file:// URI to convert to a file path');
+ }
+
+ var rest = decodeURI(uri.substring(7));
+ var firstSlash = rest.indexOf('/');
+ var host = rest.substring(0, firstSlash);
+ var path = rest.substring(firstSlash + 1);
+
+ // 2. Scheme Definition
+ // As a special case, can be the string "localhost" or the empty
+ // string; this is interpreted as "the machine from which the URL is
+ // being interpreted".
+ if ('localhost' == host) host = '';
+
+ if (host) {
+ host = sep + sep + host;
+ }
+
+ // 3.2 Drives, drive letters, mount points, file system root
+ // Drive letters are mapped into the top of a file URI in various ways,
+ // depending on the implementation; some applications substitute
+ // vertical bar ("|") for the colon after the drive letter, yielding
+ // "file:///c|/tmp/test.txt". In some cases, the colon is left
+ // unchanged, as in "file:///c:/tmp/test.txt". In other cases, the
+ // colon is simply omitted, as in "file:///c/tmp/test.txt".
+ path = path.replace(/^(.+)\|/, '$1:');
+
+ // for Windows, we need to invert the path separators from what a URI uses
+ if (sep == '\\') {
+ path = path.replace(/\//g, '\\');
+ }
+
+ if (/^.+\:/.test(path)) {
+ // has Windows drive at beginning of path
+ } else {
+ // unix path…
+ path = sep + path;
+ }
+
+ return host + path;
+}
diff --git a/node_modules/file-uri-to-path/package.json b/node_modules/file-uri-to-path/package.json
new file mode 100644
index 0000000..b6a4a07
--- /dev/null
+++ b/node_modules/file-uri-to-path/package.json
@@ -0,0 +1,32 @@
+{
+ "name": "file-uri-to-path",
+ "version": "1.0.0",
+ "description": "Convert a file: URI to a file path",
+ "main": "index.js",
+ "types": "index.d.ts",
+ "directories": {
+ "test": "test"
+ },
+ "scripts": {
+ "test": "mocha --reporter spec"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/TooTallNate/file-uri-to-path.git"
+ },
+ "keywords": [
+ "file",
+ "uri",
+ "convert",
+ "path"
+ ],
+ "author": "Nathan Rajlich (http://n8.io/)",
+ "license": "MIT",
+ "bugs": {
+ "url": "https://github.com/TooTallNate/file-uri-to-path/issues"
+ },
+ "homepage": "https://github.com/TooTallNate/file-uri-to-path",
+ "devDependencies": {
+ "mocha": "3"
+ }
+}
diff --git a/node_modules/file-uri-to-path/test/test.js b/node_modules/file-uri-to-path/test/test.js
new file mode 100644
index 0000000..79305dc
--- /dev/null
+++ b/node_modules/file-uri-to-path/test/test.js
@@ -0,0 +1,24 @@
+
+var sep = require('path').sep || '/';
+var assert = require('assert');
+var uri2path = require('../');
+var tests = require('./tests.json');
+
+describe('file-uri-to-path', function () {
+
+ Object.keys(tests).forEach(function (uri) {
+
+ // the test cases were generated from Windows' PathCreateFromUrlA() function.
+ // On Unix, we have to replace the path separator with the Unix one instead of
+ // the Windows one.
+ var expected = tests[uri].replace(/\\/g, sep);
+
+ it('should convert ' + JSON.stringify(uri) + ' to ' + JSON.stringify(expected),
+ function () {
+ var actual = uri2path(uri);
+ assert.equal(actual, expected);
+ });
+
+ });
+
+});
diff --git a/node_modules/file-uri-to-path/test/tests.json b/node_modules/file-uri-to-path/test/tests.json
new file mode 100644
index 0000000..b935a63
--- /dev/null
+++ b/node_modules/file-uri-to-path/test/tests.json
@@ -0,0 +1,13 @@
+{
+ "file://host/path": "\\\\host\\path",
+ "file://localhost/etc/fstab": "\\etc\\fstab",
+ "file:///etc/fstab": "\\etc\\fstab",
+ "file:///c:/WINDOWS/clock.avi": "c:\\WINDOWS\\clock.avi",
+ "file://localhost/c|/WINDOWS/clock.avi": "c:\\WINDOWS\\clock.avi",
+ "file:///c|/WINDOWS/clock.avi": "c:\\WINDOWS\\clock.avi",
+ "file://localhost/c:/WINDOWS/clock.avi": "c:\\WINDOWS\\clock.avi",
+ "file://hostname/path/to/the%20file.txt": "\\\\hostname\\path\\to\\the file.txt",
+ "file:///c:/path/to/the%20file.txt": "c:\\path\\to\\the file.txt",
+ "file:///C:/Documents%20and%20Settings/davris/FileSchemeURIs.doc": "C:\\Documents and Settings\\davris\\FileSchemeURIs.doc",
+ "file:///C:/caf%C3%A9/%C3%A5r/d%C3%BCnn/%E7%89%9B%E9%93%83/Ph%E1%BB%9F/%F0%9F%98%B5.exe": "C:\\café\\år\\dünn\\牛铃\\Phở\\😵.exe"
+}
diff --git a/node_modules/inherits/LICENSE b/node_modules/inherits/LICENSE
new file mode 100644
index 0000000..dea3013
--- /dev/null
+++ b/node_modules/inherits/LICENSE
@@ -0,0 +1,16 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+
diff --git a/node_modules/inherits/README.md b/node_modules/inherits/README.md
new file mode 100644
index 0000000..b1c5665
--- /dev/null
+++ b/node_modules/inherits/README.md
@@ -0,0 +1,42 @@
+Browser-friendly inheritance fully compatible with standard node.js
+[inherits](http://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor).
+
+This package exports standard `inherits` from node.js `util` module in
+node environment, but also provides alternative browser-friendly
+implementation through [browser
+field](https://gist.github.com/shtylman/4339901). Alternative
+implementation is a literal copy of standard one located in standalone
+module to avoid requiring of `util`. It also has a shim for old
+browsers with no `Object.create` support.
+
+While keeping you sure you are using standard `inherits`
+implementation in node.js environment, it allows bundlers such as
+[browserify](https://github.com/substack/node-browserify) to not
+include full `util` package to your client code if all you need is
+just `inherits` function. It worth, because browser shim for `util`
+package is large and `inherits` is often the single function you need
+from it.
+
+It's recommended to use this package instead of
+`require('util').inherits` for any code that has chances to be used
+not only in node.js but in browser too.
+
+## usage
+
+```js
+var inherits = require('inherits');
+// then use exactly as the standard one
+```
+
+## note on version ~1.0
+
+Version ~1.0 had completely different motivation and is not compatible
+neither with 2.0 nor with standard node.js `inherits`.
+
+If you are using version ~1.0 and planning to switch to ~2.0, be
+careful:
+
+* new version uses `super_` instead of `super` for referencing
+ superclass
+* new version overwrites current prototype while old one preserves any
+ existing fields on it
diff --git a/node_modules/inherits/inherits.js b/node_modules/inherits/inherits.js
new file mode 100644
index 0000000..f71f2d9
--- /dev/null
+++ b/node_modules/inherits/inherits.js
@@ -0,0 +1,9 @@
+try {
+ var util = require('util');
+ /* istanbul ignore next */
+ if (typeof util.inherits !== 'function') throw '';
+ module.exports = util.inherits;
+} catch (e) {
+ /* istanbul ignore next */
+ module.exports = require('./inherits_browser.js');
+}
diff --git a/node_modules/inherits/inherits_browser.js b/node_modules/inherits/inherits_browser.js
new file mode 100644
index 0000000..86bbb3d
--- /dev/null
+++ b/node_modules/inherits/inherits_browser.js
@@ -0,0 +1,27 @@
+if (typeof Object.create === 'function') {
+ // implementation from standard node.js 'util' module
+ module.exports = function inherits(ctor, superCtor) {
+ if (superCtor) {
+ ctor.super_ = superCtor
+ ctor.prototype = Object.create(superCtor.prototype, {
+ constructor: {
+ value: ctor,
+ enumerable: false,
+ writable: true,
+ configurable: true
+ }
+ })
+ }
+ };
+} else {
+ // old school shim for old browsers
+ module.exports = function inherits(ctor, superCtor) {
+ if (superCtor) {
+ ctor.super_ = superCtor
+ var TempCtor = function () {}
+ TempCtor.prototype = superCtor.prototype
+ ctor.prototype = new TempCtor()
+ ctor.prototype.constructor = ctor
+ }
+ }
+}
diff --git a/node_modules/inherits/package.json b/node_modules/inherits/package.json
new file mode 100644
index 0000000..37b4366
--- /dev/null
+++ b/node_modules/inherits/package.json
@@ -0,0 +1,29 @@
+{
+ "name": "inherits",
+ "description": "Browser-friendly inheritance fully compatible with standard node.js inherits()",
+ "version": "2.0.4",
+ "keywords": [
+ "inheritance",
+ "class",
+ "klass",
+ "oop",
+ "object-oriented",
+ "inherits",
+ "browser",
+ "browserify"
+ ],
+ "main": "./inherits.js",
+ "browser": "./inherits_browser.js",
+ "repository": "git://github.com/isaacs/inherits",
+ "license": "ISC",
+ "scripts": {
+ "test": "tap"
+ },
+ "devDependencies": {
+ "tap": "^14.2.4"
+ },
+ "files": [
+ "inherits.js",
+ "inherits_browser.js"
+ ]
+}
diff --git a/node_modules/keccak/LICENSE b/node_modules/keccak/LICENSE
new file mode 100644
index 0000000..6804d6c
--- /dev/null
+++ b/node_modules/keccak/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 https://github.com/cryptocoinjs/keccak contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/node_modules/keccak/README.md b/node_modules/keccak/README.md
new file mode 100644
index 0000000..dbab97d
--- /dev/null
+++ b/node_modules/keccak/README.md
@@ -0,0 +1,70 @@
+# keccak
+
+Version | Mac/Linux | Windows
+------- | --------- | -------
+[](https://www.npmjs.org/package/keccak) | [](https://travis-ci.org/cryptocoinjs/keccak) | [](https://ci.appveyor.com/project/fanatid/keccak)
+
+[](https://github.com/feross/standard)
+
+This module provides native bindings to [Keccak sponge function family][1] from [Keccak Code Package][2]. In browser pure JavaScript implementation will be used.
+
+## Usage
+
+You can use this package as [node Hash][3].
+
+```js
+const createKeccakHash = require('keccak')
+
+console.log(createKeccakHash('keccak256').digest().toString('hex'))
+// => c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470
+
+console.log(createKeccakHash('keccak256').update('Hello world!').digest('hex'))
+// => ecd0e108a98e192af1d2c25055f4e3bed784b5c877204e73219a5203251feaab
+```
+
+Also object has two useful methods: `_resetState` and `_clone`
+
+```js
+const createKeccakHash = require('keccak')
+
+console.log(createKeccakHash('keccak256').update('Hello World!')._resetState().digest('hex'))
+// => c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470
+
+const hash1 = createKeccakHash('keccak256').update('Hello')
+const hash2 = hash1._clone()
+console.log(hash1.digest('hex'))
+// => 06b3dfaec148fb1bb2b066f10ec285e7c9bf402ab32aa78a5d38e34566810cd2
+console.log(hash1.update(' world!').digest('hex'))
+// => throw Error: Digest already called
+console.log(hash2.update(' world!').digest('hex'))
+// => ecd0e108a98e192af1d2c25055f4e3bed784b5c877204e73219a5203251feaab
+```
+
+### Why I should use this package?
+
+I thought it will be popular question, so I decide write explanation in readme.
+
+I know a few popular packages on [npm][4] related with [Keccak][1]:
+
+ - [sha3][5] ([phusion/node-sha3][6] on github) — not actual because support _only keccak_.
+ - [js-sha3][7] ([emn178/js-sha3][8] on github) — brilliant package which support keccak, sha3, shake. But not implement [node Hash][3] interface unfortunately!
+ - [browserify-sha3][9] ([wanderer/browserify-sha3][10] on github) — based on [js-sha3][7] (but not support shake!). Support [node Hash][3] interface, but without [streams][11].
+ - [keccakjs][12] ([axic/keccakjs][13] on github) — uses [sha3][5] and [browserify-sha3][9] as fallback. As result _keccak only_ with [node Hash][3] interface without [streams][11].
+
+## LICENSE
+
+This library is free and open-source software released under the MIT license.
+
+[1]: http://keccak.noekeon.org/
+[2]: https://github.com/gvanas/KeccakCodePackage
+[3]: https://nodejs.org/api/crypto.html#crypto_class_hash
+[4]: http://npmjs.com/
+[5]: https://www.npmjs.com/package/sha3
+[6]: https://github.com/phusion/node-sha3
+[7]: https://www.npmjs.com/package/js-sha3
+[8]: https://github.com/emn178/js-sha3
+[9]: https://www.npmjs.com/package/browserify-sha3
+[10]: https://github.com/wanderer/browserify-sha3
+[11]: http://nodejs.org/api/stream.html
+[12]: https://www.npmjs.com/package/keccakjs
+[13]: https://github.com/axic/keccakjs
diff --git a/node_modules/keccak/binding.gyp b/node_modules/keccak/binding.gyp
new file mode 100644
index 0000000..2971268
--- /dev/null
+++ b/node_modules/keccak/binding.gyp
@@ -0,0 +1,45 @@
+{
+ "variables": {
+ "arch": "> $(depfile)
+# Add extra rules as in (2).
+# We remove slashes and replace spaces with new lines;
+# remove blank lines;
+# delete the first line and append a colon to the remaining lines.
+sed -e 's|\\||' -e 'y| |\n|' $(depfile).raw |\
+ grep -v '^$$' |\
+ sed -e 1d -e 's|$$|:|' \
+ >> $(depfile)
+rm $(depfile).raw
+endef
+
+# Command definitions:
+# - cmd_foo is the actual command to run;
+# - quiet_cmd_foo is the brief-output summary of the command.
+
+quiet_cmd_cc = CC($(TOOLSET)) $@
+cmd_cc = $(CC.$(TOOLSET)) -o $@ $< $(GYP_CFLAGS) $(DEPFLAGS) $(CFLAGS.$(TOOLSET)) -c
+
+quiet_cmd_cxx = CXX($(TOOLSET)) $@
+cmd_cxx = $(CXX.$(TOOLSET)) -o $@ $< $(GYP_CXXFLAGS) $(DEPFLAGS) $(CXXFLAGS.$(TOOLSET)) -c
+
+quiet_cmd_touch = TOUCH $@
+cmd_touch = touch $@
+
+quiet_cmd_copy = COPY $@
+# send stderr to /dev/null to ignore messages when linking directories.
+cmd_copy = ln -f "$<" "$@" 2>/dev/null || (rm -rf "$@" && cp -af "$<" "$@")
+
+quiet_cmd_alink = AR($(TOOLSET)) $@
+cmd_alink = rm -f $@ && $(AR.$(TOOLSET)) crs $@ $(filter %.o,$^)
+
+quiet_cmd_alink_thin = AR($(TOOLSET)) $@
+cmd_alink_thin = rm -f $@ && $(AR.$(TOOLSET)) crsT $@ $(filter %.o,$^)
+
+# Due to circular dependencies between libraries :(, we wrap the
+# special "figure out circular dependencies" flags around the entire
+# input list during linking.
+quiet_cmd_link = LINK($(TOOLSET)) $@
+cmd_link = $(LINK.$(TOOLSET)) -o $@ $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,--start-group $(LD_INPUTS) $(LIBS) -Wl,--end-group
+
+# We support two kinds of shared objects (.so):
+# 1) shared_library, which is just bundling together many dependent libraries
+# into a link line.
+# 2) loadable_module, which is generating a module intended for dlopen().
+#
+# They differ only slightly:
+# In the former case, we want to package all dependent code into the .so.
+# In the latter case, we want to package just the API exposed by the
+# outermost module.
+# This means shared_library uses --whole-archive, while loadable_module doesn't.
+# (Note that --whole-archive is incompatible with the --start-group used in
+# normal linking.)
+
+# Other shared-object link notes:
+# - Set SONAME to the library filename so our binaries don't reference
+# the local, absolute paths used on the link command-line.
+quiet_cmd_solink = SOLINK($(TOOLSET)) $@
+cmd_solink = $(LINK.$(TOOLSET)) -o $@ -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,-soname=$(@F) -Wl,--whole-archive $(LD_INPUTS) -Wl,--no-whole-archive $(LIBS)
+
+quiet_cmd_solink_module = SOLINK_MODULE($(TOOLSET)) $@
+cmd_solink_module = $(LINK.$(TOOLSET)) -o $@ -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,-soname=$(@F) -Wl,--start-group $(filter-out FORCE_DO_CMD, $^) -Wl,--end-group $(LIBS)
+
+
+# Define an escape_quotes function to escape single quotes.
+# This allows us to handle quotes properly as long as we always use
+# use single quotes and escape_quotes.
+escape_quotes = $(subst ','\'',$(1))
+# This comment is here just to include a ' to unconfuse syntax highlighting.
+# Define an escape_vars function to escape '$' variable syntax.
+# This allows us to read/write command lines with shell variables (e.g.
+# $LD_LIBRARY_PATH), without triggering make substitution.
+escape_vars = $(subst $$,$$$$,$(1))
+# Helper that expands to a shell command to echo a string exactly as it is in
+# make. This uses printf instead of echo because printf's behaviour with respect
+# to escape sequences is more portable than echo's across different shells
+# (e.g., dash, bash).
+exact_echo = printf '%s\n' '$(call escape_quotes,$(1))'
+
+# Helper to compare the command we're about to run against the command
+# we logged the last time we ran the command. Produces an empty
+# string (false) when the commands match.
+# Tricky point: Make has no string-equality test function.
+# The kernel uses the following, but it seems like it would have false
+# positives, where one string reordered its arguments.
+# arg_check = $(strip $(filter-out $(cmd_$(1)), $(cmd_$@)) \
+# $(filter-out $(cmd_$@), $(cmd_$(1))))
+# We instead substitute each for the empty string into the other, and
+# say they're equal if both substitutions produce the empty string.
+# .d files contain ? instead of spaces, take that into account.
+command_changed = $(or $(subst $(cmd_$(1)),,$(cmd_$(call replace_spaces,$@))),\
+ $(subst $(cmd_$(call replace_spaces,$@)),,$(cmd_$(1))))
+
+# Helper that is non-empty when a prerequisite changes.
+# Normally make does this implicitly, but we force rules to always run
+# so we can check their command lines.
+# $? -- new prerequisites
+# $| -- order-only dependencies
+prereq_changed = $(filter-out FORCE_DO_CMD,$(filter-out $|,$?))
+
+# Helper that executes all postbuilds until one fails.
+define do_postbuilds
+ @E=0;\
+ for p in $(POSTBUILDS); do\
+ eval $$p;\
+ E=$$?;\
+ if [ $$E -ne 0 ]; then\
+ break;\
+ fi;\
+ done;\
+ if [ $$E -ne 0 ]; then\
+ rm -rf "$@";\
+ exit $$E;\
+ fi
+endef
+
+# do_cmd: run a command via the above cmd_foo names, if necessary.
+# Should always run for a given target to handle command-line changes.
+# Second argument, if non-zero, makes it do asm/C/C++ dependency munging.
+# Third argument, if non-zero, makes it do POSTBUILDS processing.
+# Note: We intentionally do NOT call dirx for depfile, since it contains ? for
+# spaces already and dirx strips the ? characters.
+define do_cmd
+$(if $(or $(command_changed),$(prereq_changed)),
+ @$(call exact_echo, $($(quiet)cmd_$(1)))
+ @mkdir -p "$(call dirx,$@)" "$(dir $(depfile))"
+ $(if $(findstring flock,$(word 1,$(cmd_$1))),
+ @$(cmd_$(1))
+ @echo " $(quiet_cmd_$(1)): Finished",
+ @$(cmd_$(1))
+ )
+ @$(call exact_echo,$(call escape_vars,cmd_$(call replace_spaces,$@) := $(cmd_$(1)))) > $(depfile)
+ @$(if $(2),$(fixup_dep))
+ $(if $(and $(3), $(POSTBUILDS)),
+ $(call do_postbuilds)
+ )
+)
+endef
+
+# Declare the "all" target first so it is the default,
+# even though we don't have the deps yet.
+.PHONY: all
+all:
+
+# make looks for ways to re-generate included makefiles, but in our case, we
+# don't have a direct way. Explicitly telling make that it has nothing to do
+# for them makes it go faster.
+%.d: ;
+
+# Use FORCE_DO_CMD to force a target to run. Should be coupled with
+# do_cmd.
+.PHONY: FORCE_DO_CMD
+FORCE_DO_CMD:
+
+TOOLSET := target
+# Suffix rules, putting all outputs into $(obj).
+$(obj).$(TOOLSET)/%.o: $(srcdir)/%.c FORCE_DO_CMD
+ @$(call do_cmd,cc,1)
+$(obj).$(TOOLSET)/%.o: $(srcdir)/%.cc FORCE_DO_CMD
+ @$(call do_cmd,cxx,1)
+$(obj).$(TOOLSET)/%.o: $(srcdir)/%.cpp FORCE_DO_CMD
+ @$(call do_cmd,cxx,1)
+$(obj).$(TOOLSET)/%.o: $(srcdir)/%.cxx FORCE_DO_CMD
+ @$(call do_cmd,cxx,1)
+$(obj).$(TOOLSET)/%.o: $(srcdir)/%.s FORCE_DO_CMD
+ @$(call do_cmd,cc,1)
+$(obj).$(TOOLSET)/%.o: $(srcdir)/%.S FORCE_DO_CMD
+ @$(call do_cmd,cc,1)
+
+# Try building from generated source, too.
+$(obj).$(TOOLSET)/%.o: $(obj).$(TOOLSET)/%.c FORCE_DO_CMD
+ @$(call do_cmd,cc,1)
+$(obj).$(TOOLSET)/%.o: $(obj).$(TOOLSET)/%.cc FORCE_DO_CMD
+ @$(call do_cmd,cxx,1)
+$(obj).$(TOOLSET)/%.o: $(obj).$(TOOLSET)/%.cpp FORCE_DO_CMD
+ @$(call do_cmd,cxx,1)
+$(obj).$(TOOLSET)/%.o: $(obj).$(TOOLSET)/%.cxx FORCE_DO_CMD
+ @$(call do_cmd,cxx,1)
+$(obj).$(TOOLSET)/%.o: $(obj).$(TOOLSET)/%.s FORCE_DO_CMD
+ @$(call do_cmd,cc,1)
+$(obj).$(TOOLSET)/%.o: $(obj).$(TOOLSET)/%.S FORCE_DO_CMD
+ @$(call do_cmd,cc,1)
+
+$(obj).$(TOOLSET)/%.o: $(obj)/%.c FORCE_DO_CMD
+ @$(call do_cmd,cc,1)
+$(obj).$(TOOLSET)/%.o: $(obj)/%.cc FORCE_DO_CMD
+ @$(call do_cmd,cxx,1)
+$(obj).$(TOOLSET)/%.o: $(obj)/%.cpp FORCE_DO_CMD
+ @$(call do_cmd,cxx,1)
+$(obj).$(TOOLSET)/%.o: $(obj)/%.cxx FORCE_DO_CMD
+ @$(call do_cmd,cxx,1)
+$(obj).$(TOOLSET)/%.o: $(obj)/%.s FORCE_DO_CMD
+ @$(call do_cmd,cc,1)
+$(obj).$(TOOLSET)/%.o: $(obj)/%.S FORCE_DO_CMD
+ @$(call do_cmd,cc,1)
+
+
+ifeq ($(strip $(foreach prefix,$(NO_LOAD),\
+ $(findstring $(join ^,$(prefix)),\
+ $(join ^,keccak.target.mk)))),)
+ include keccak.target.mk
+endif
+
+quiet_cmd_regen_makefile = ACTION Regenerating $@
+cmd_regen_makefile = cd $(srcdir); /home/ubuntu/.nvm/versions/node/v15.8.0/lib/node_modules/npm/node_modules/node-gyp/gyp/gyp_main.py -fmake --ignore-environment "-Dlibrary=shared_library" "-Dvisibility=default" "-Dnode_root_dir=/home/ubuntu/.cache/node-gyp/15.8.0" "-Dnode_gyp_dir=/home/ubuntu/.nvm/versions/node/v15.8.0/lib/node_modules/npm/node_modules/node-gyp" "-Dnode_lib_file=/home/ubuntu/.cache/node-gyp/15.8.0/<(target_arch)/node.lib" "-Dmodule_root_dir=/home/ubuntu/mpp-server/node_modules/keccak" "-Dnode_engine=v8" "--depth=." "-Goutput_dir=." "--generator-output=build" -I/home/ubuntu/mpp-server/node_modules/keccak/build/config.gypi -I/home/ubuntu/.nvm/versions/node/v15.8.0/lib/node_modules/npm/node_modules/node-gyp/addon.gypi -I/home/ubuntu/.cache/node-gyp/15.8.0/include/node/common.gypi "--toplevel-dir=." binding.gyp
+Makefile: $(srcdir)/../../../.cache/node-gyp/15.8.0/include/node/common.gypi $(srcdir)/../../../.nvm/versions/node/v15.8.0/lib/node_modules/npm/node_modules/node-gyp/addon.gypi $(srcdir)/build/config.gypi $(srcdir)/binding.gyp
+ $(call do_cmd,regen_makefile)
+
+# "all" is a concatenation of the "all" targets from all the included
+# sub-makefiles. This is just here to clarify.
+all:
+
+# Add in dependency-tracking rules. $(all_deps) is the list of every single
+# target in our tree. Only consider the ones with .d (dependency) info:
+d_files := $(wildcard $(foreach f,$(all_deps),$(depsdir)/$(f).d))
+ifneq ($(d_files),)
+ include $(d_files)
+endif
diff --git a/node_modules/keccak/build/Release/.deps/Release/keccak.node.d b/node_modules/keccak/build/Release/.deps/Release/keccak.node.d
new file mode 100644
index 0000000..d8c10e1
--- /dev/null
+++ b/node_modules/keccak/build/Release/.deps/Release/keccak.node.d
@@ -0,0 +1 @@
+cmd_Release/keccak.node := ln -f "Release/obj.target/keccak.node" "Release/keccak.node" 2>/dev/null || (rm -rf "Release/keccak.node" && cp -af "Release/obj.target/keccak.node" "Release/keccak.node")
diff --git a/node_modules/keccak/build/Release/.deps/Release/obj.target/keccak.node.d b/node_modules/keccak/build/Release/.deps/Release/obj.target/keccak.node.d
new file mode 100644
index 0000000..b053bb5
--- /dev/null
+++ b/node_modules/keccak/build/Release/.deps/Release/obj.target/keccak.node.d
@@ -0,0 +1 @@
+cmd_Release/obj.target/keccak.node := g++ -o Release/obj.target/keccak.node -shared -pthread -rdynamic -Wl,-soname=keccak.node -Wl,--start-group Release/obj.target/keccak/src/addon.o Release/obj.target/keccak/src/libkeccak-64/KeccakSpongeWidth1600.o Release/obj.target/keccak/src/libkeccak-64/KeccakP-1600-opt64.o -Wl,--end-group
diff --git a/node_modules/keccak/build/Release/.deps/Release/obj.target/keccak/src/addon.o.d b/node_modules/keccak/build/Release/.deps/Release/obj.target/keccak/src/addon.o.d
new file mode 100644
index 0000000..24a1f1c
--- /dev/null
+++ b/node_modules/keccak/build/Release/.deps/Release/obj.target/keccak/src/addon.o.d
@@ -0,0 +1,72 @@
+cmd_Release/obj.target/keccak/src/addon.o := g++ -o Release/obj.target/keccak/src/addon.o ../src/addon.cc '-DNODE_GYP_MODULE_NAME=keccak' '-DUSING_UV_SHARED=1' '-DUSING_V8_SHARED=1' '-DV8_DEPRECATION_WARNINGS=1' '-DV8_DEPRECATION_WARNINGS' '-DV8_IMMINENT_DEPRECATION_WARNINGS' '-D_LARGEFILE_SOURCE' '-D_FILE_OFFSET_BITS=64' '-D__STDC_FORMAT_MACROS' '-DOPENSSL_NO_PINSHARED' '-DOPENSSL_THREADS' '-DLIBKECCAK=64' '-DBUILDING_NODE_EXTENSION' -I/home/ubuntu/.cache/node-gyp/15.8.0/include/node -I/home/ubuntu/.cache/node-gyp/15.8.0/src -I/home/ubuntu/.cache/node-gyp/15.8.0/deps/openssl/config -I/home/ubuntu/.cache/node-gyp/15.8.0/deps/openssl/openssl/include -I/home/ubuntu/.cache/node-gyp/15.8.0/deps/uv/include -I/home/ubuntu/.cache/node-gyp/15.8.0/deps/zlib -I/home/ubuntu/.cache/node-gyp/15.8.0/deps/v8/include -I../../nan -fPIC -pthread -Wall -Wextra -Wno-unused-parameter -Wall -Wno-maybe-uninitialized -Wno-uninitialized -Wno-unused-function -Wextra -O3 -fno-omit-frame-pointer -fno-rtti -fno-exceptions -std=gnu++1y -MMD -MF ./Release/.deps/Release/obj.target/keccak/src/addon.o.d.raw -c
+Release/obj.target/keccak/src/addon.o: ../src/addon.cc \
+ /home/ubuntu/.cache/node-gyp/15.8.0/include/node/node.h \
+ /home/ubuntu/.cache/node-gyp/15.8.0/include/node/v8.h \
+ /home/ubuntu/.cache/node-gyp/15.8.0/include/node/cppgc/common.h \
+ /home/ubuntu/.cache/node-gyp/15.8.0/include/node/v8config.h \
+ /home/ubuntu/.cache/node-gyp/15.8.0/include/node/v8-internal.h \
+ /home/ubuntu/.cache/node-gyp/15.8.0/include/node/v8-version.h \
+ /home/ubuntu/.cache/node-gyp/15.8.0/include/node/v8config.h \
+ /home/ubuntu/.cache/node-gyp/15.8.0/include/node/v8-platform.h \
+ /home/ubuntu/.cache/node-gyp/15.8.0/include/node/node_version.h \
+ ../../nan/nan.h \
+ /home/ubuntu/.cache/node-gyp/15.8.0/include/node/node_version.h \
+ /home/ubuntu/.cache/node-gyp/15.8.0/include/node/uv.h \
+ /home/ubuntu/.cache/node-gyp/15.8.0/include/node/uv/errno.h \
+ /home/ubuntu/.cache/node-gyp/15.8.0/include/node/uv/version.h \
+ /home/ubuntu/.cache/node-gyp/15.8.0/include/node/uv/unix.h \
+ /home/ubuntu/.cache/node-gyp/15.8.0/include/node/uv/threadpool.h \
+ /home/ubuntu/.cache/node-gyp/15.8.0/include/node/uv/linux.h \
+ /home/ubuntu/.cache/node-gyp/15.8.0/include/node/node_buffer.h \
+ /home/ubuntu/.cache/node-gyp/15.8.0/include/node/node.h \
+ /home/ubuntu/.cache/node-gyp/15.8.0/include/node/node_object_wrap.h \
+ ../../nan/nan_callbacks.h ../../nan/nan_callbacks_12_inl.h \
+ ../../nan/nan_maybe_43_inl.h ../../nan/nan_converters.h \
+ ../../nan/nan_converters_43_inl.h ../../nan/nan_new.h \
+ ../../nan/nan_implementation_12_inl.h ../../nan/nan_persistent_12_inl.h \
+ ../../nan/nan_weak.h ../../nan/nan_object_wrap.h ../../nan/nan_private.h \
+ ../../nan/nan_typedarray_contents.h ../../nan/nan_json.h \
+ ../src/libkeccak-64/KeccakSpongeWidth1600.h \
+ ../src/libkeccak-64/KeccakSponge-common.h ../src/libkeccak-64/align.h \
+ ../src/libkeccak-64/KeccakP-1600-SnP.h ../src/libkeccak-64/brg_endian.h \
+ ../src/libkeccak-64/KeccakP-1600-opt64-config.h
+../src/addon.cc:
+/home/ubuntu/.cache/node-gyp/15.8.0/include/node/node.h:
+/home/ubuntu/.cache/node-gyp/15.8.0/include/node/v8.h:
+/home/ubuntu/.cache/node-gyp/15.8.0/include/node/cppgc/common.h:
+/home/ubuntu/.cache/node-gyp/15.8.0/include/node/v8config.h:
+/home/ubuntu/.cache/node-gyp/15.8.0/include/node/v8-internal.h:
+/home/ubuntu/.cache/node-gyp/15.8.0/include/node/v8-version.h:
+/home/ubuntu/.cache/node-gyp/15.8.0/include/node/v8config.h:
+/home/ubuntu/.cache/node-gyp/15.8.0/include/node/v8-platform.h:
+/home/ubuntu/.cache/node-gyp/15.8.0/include/node/node_version.h:
+../../nan/nan.h:
+/home/ubuntu/.cache/node-gyp/15.8.0/include/node/node_version.h:
+/home/ubuntu/.cache/node-gyp/15.8.0/include/node/uv.h:
+/home/ubuntu/.cache/node-gyp/15.8.0/include/node/uv/errno.h:
+/home/ubuntu/.cache/node-gyp/15.8.0/include/node/uv/version.h:
+/home/ubuntu/.cache/node-gyp/15.8.0/include/node/uv/unix.h:
+/home/ubuntu/.cache/node-gyp/15.8.0/include/node/uv/threadpool.h:
+/home/ubuntu/.cache/node-gyp/15.8.0/include/node/uv/linux.h:
+/home/ubuntu/.cache/node-gyp/15.8.0/include/node/node_buffer.h:
+/home/ubuntu/.cache/node-gyp/15.8.0/include/node/node.h:
+/home/ubuntu/.cache/node-gyp/15.8.0/include/node/node_object_wrap.h:
+../../nan/nan_callbacks.h:
+../../nan/nan_callbacks_12_inl.h:
+../../nan/nan_maybe_43_inl.h:
+../../nan/nan_converters.h:
+../../nan/nan_converters_43_inl.h:
+../../nan/nan_new.h:
+../../nan/nan_implementation_12_inl.h:
+../../nan/nan_persistent_12_inl.h:
+../../nan/nan_weak.h:
+../../nan/nan_object_wrap.h:
+../../nan/nan_private.h:
+../../nan/nan_typedarray_contents.h:
+../../nan/nan_json.h:
+../src/libkeccak-64/KeccakSpongeWidth1600.h:
+../src/libkeccak-64/KeccakSponge-common.h:
+../src/libkeccak-64/align.h:
+../src/libkeccak-64/KeccakP-1600-SnP.h:
+../src/libkeccak-64/brg_endian.h:
+../src/libkeccak-64/KeccakP-1600-opt64-config.h:
diff --git a/node_modules/keccak/build/Release/.deps/Release/obj.target/keccak/src/libkeccak-64/KeccakP-1600-opt64.o.d b/node_modules/keccak/build/Release/.deps/Release/obj.target/keccak/src/libkeccak-64/KeccakP-1600-opt64.o.d
new file mode 100644
index 0000000..d4c7a5d
--- /dev/null
+++ b/node_modules/keccak/build/Release/.deps/Release/obj.target/keccak/src/libkeccak-64/KeccakP-1600-opt64.o.d
@@ -0,0 +1,14 @@
+cmd_Release/obj.target/keccak/src/libkeccak-64/KeccakP-1600-opt64.o := cc -o Release/obj.target/keccak/src/libkeccak-64/KeccakP-1600-opt64.o ../src/libkeccak-64/KeccakP-1600-opt64.c '-DNODE_GYP_MODULE_NAME=keccak' '-DUSING_UV_SHARED=1' '-DUSING_V8_SHARED=1' '-DV8_DEPRECATION_WARNINGS=1' '-DV8_DEPRECATION_WARNINGS' '-DV8_IMMINENT_DEPRECATION_WARNINGS' '-D_LARGEFILE_SOURCE' '-D_FILE_OFFSET_BITS=64' '-D__STDC_FORMAT_MACROS' '-DOPENSSL_NO_PINSHARED' '-DOPENSSL_THREADS' '-DLIBKECCAK=64' '-DBUILDING_NODE_EXTENSION' -I/home/ubuntu/.cache/node-gyp/15.8.0/include/node -I/home/ubuntu/.cache/node-gyp/15.8.0/src -I/home/ubuntu/.cache/node-gyp/15.8.0/deps/openssl/config -I/home/ubuntu/.cache/node-gyp/15.8.0/deps/openssl/openssl/include -I/home/ubuntu/.cache/node-gyp/15.8.0/deps/uv/include -I/home/ubuntu/.cache/node-gyp/15.8.0/deps/zlib -I/home/ubuntu/.cache/node-gyp/15.8.0/deps/v8/include -I../../nan -fPIC -pthread -Wall -Wextra -Wno-unused-parameter -Wall -Wno-maybe-uninitialized -Wno-uninitialized -Wno-unused-function -Wextra -O3 -fno-omit-frame-pointer -MMD -MF ./Release/.deps/Release/obj.target/keccak/src/libkeccak-64/KeccakP-1600-opt64.o.d.raw -c
+Release/obj.target/keccak/src/libkeccak-64/KeccakP-1600-opt64.o: \
+ ../src/libkeccak-64/KeccakP-1600-opt64.c \
+ ../src/libkeccak-64/brg_endian.h \
+ ../src/libkeccak-64/KeccakP-1600-opt64-config.h \
+ ../src/libkeccak-64/KeccakP-1600-64.macros \
+ ../src/libkeccak-64/KeccakP-1600-unrolling.macros \
+ ../src/libkeccak-64/SnP-Relaned.h
+../src/libkeccak-64/KeccakP-1600-opt64.c:
+../src/libkeccak-64/brg_endian.h:
+../src/libkeccak-64/KeccakP-1600-opt64-config.h:
+../src/libkeccak-64/KeccakP-1600-64.macros:
+../src/libkeccak-64/KeccakP-1600-unrolling.macros:
+../src/libkeccak-64/SnP-Relaned.h:
diff --git a/node_modules/keccak/build/Release/.deps/Release/obj.target/keccak/src/libkeccak-64/KeccakSpongeWidth1600.o.d b/node_modules/keccak/build/Release/.deps/Release/obj.target/keccak/src/libkeccak-64/KeccakSpongeWidth1600.o.d
new file mode 100644
index 0000000..073d692
--- /dev/null
+++ b/node_modules/keccak/build/Release/.deps/Release/obj.target/keccak/src/libkeccak-64/KeccakSpongeWidth1600.o.d
@@ -0,0 +1,16 @@
+cmd_Release/obj.target/keccak/src/libkeccak-64/KeccakSpongeWidth1600.o := cc -o Release/obj.target/keccak/src/libkeccak-64/KeccakSpongeWidth1600.o ../src/libkeccak-64/KeccakSpongeWidth1600.c '-DNODE_GYP_MODULE_NAME=keccak' '-DUSING_UV_SHARED=1' '-DUSING_V8_SHARED=1' '-DV8_DEPRECATION_WARNINGS=1' '-DV8_DEPRECATION_WARNINGS' '-DV8_IMMINENT_DEPRECATION_WARNINGS' '-D_LARGEFILE_SOURCE' '-D_FILE_OFFSET_BITS=64' '-D__STDC_FORMAT_MACROS' '-DOPENSSL_NO_PINSHARED' '-DOPENSSL_THREADS' '-DLIBKECCAK=64' '-DBUILDING_NODE_EXTENSION' -I/home/ubuntu/.cache/node-gyp/15.8.0/include/node -I/home/ubuntu/.cache/node-gyp/15.8.0/src -I/home/ubuntu/.cache/node-gyp/15.8.0/deps/openssl/config -I/home/ubuntu/.cache/node-gyp/15.8.0/deps/openssl/openssl/include -I/home/ubuntu/.cache/node-gyp/15.8.0/deps/uv/include -I/home/ubuntu/.cache/node-gyp/15.8.0/deps/zlib -I/home/ubuntu/.cache/node-gyp/15.8.0/deps/v8/include -I../../nan -fPIC -pthread -Wall -Wextra -Wno-unused-parameter -Wall -Wno-maybe-uninitialized -Wno-uninitialized -Wno-unused-function -Wextra -O3 -fno-omit-frame-pointer -MMD -MF ./Release/.deps/Release/obj.target/keccak/src/libkeccak-64/KeccakSpongeWidth1600.o.d.raw -c
+Release/obj.target/keccak/src/libkeccak-64/KeccakSpongeWidth1600.o: \
+ ../src/libkeccak-64/KeccakSpongeWidth1600.c \
+ ../src/libkeccak-64/KeccakSpongeWidth1600.h \
+ ../src/libkeccak-64/KeccakSponge-common.h ../src/libkeccak-64/align.h \
+ ../src/libkeccak-64/KeccakP-1600-SnP.h ../src/libkeccak-64/brg_endian.h \
+ ../src/libkeccak-64/KeccakP-1600-opt64-config.h \
+ ../src/libkeccak-64/KeccakSponge.inc
+../src/libkeccak-64/KeccakSpongeWidth1600.c:
+../src/libkeccak-64/KeccakSpongeWidth1600.h:
+../src/libkeccak-64/KeccakSponge-common.h:
+../src/libkeccak-64/align.h:
+../src/libkeccak-64/KeccakP-1600-SnP.h:
+../src/libkeccak-64/brg_endian.h:
+../src/libkeccak-64/KeccakP-1600-opt64-config.h:
+../src/libkeccak-64/KeccakSponge.inc:
diff --git a/node_modules/keccak/build/Release/keccak.node b/node_modules/keccak/build/Release/keccak.node
new file mode 100755
index 0000000..e493c1e
Binary files /dev/null and b/node_modules/keccak/build/Release/keccak.node differ
diff --git a/node_modules/keccak/build/Release/obj.target/keccak.node b/node_modules/keccak/build/Release/obj.target/keccak.node
new file mode 100755
index 0000000..e493c1e
Binary files /dev/null and b/node_modules/keccak/build/Release/obj.target/keccak.node differ
diff --git a/node_modules/keccak/build/Release/obj.target/keccak/src/addon.o b/node_modules/keccak/build/Release/obj.target/keccak/src/addon.o
new file mode 100644
index 0000000..703bd00
Binary files /dev/null and b/node_modules/keccak/build/Release/obj.target/keccak/src/addon.o differ
diff --git a/node_modules/keccak/build/Release/obj.target/keccak/src/libkeccak-64/KeccakP-1600-opt64.o b/node_modules/keccak/build/Release/obj.target/keccak/src/libkeccak-64/KeccakP-1600-opt64.o
new file mode 100644
index 0000000..148acd2
Binary files /dev/null and b/node_modules/keccak/build/Release/obj.target/keccak/src/libkeccak-64/KeccakP-1600-opt64.o differ
diff --git a/node_modules/keccak/build/Release/obj.target/keccak/src/libkeccak-64/KeccakSpongeWidth1600.o b/node_modules/keccak/build/Release/obj.target/keccak/src/libkeccak-64/KeccakSpongeWidth1600.o
new file mode 100644
index 0000000..917a581
Binary files /dev/null and b/node_modules/keccak/build/Release/obj.target/keccak/src/libkeccak-64/KeccakSpongeWidth1600.o differ
diff --git a/node_modules/keccak/build/binding.Makefile b/node_modules/keccak/build/binding.Makefile
new file mode 100644
index 0000000..751ce4c
--- /dev/null
+++ b/node_modules/keccak/build/binding.Makefile
@@ -0,0 +1,6 @@
+# This file is generated by gyp; do not edit.
+
+export builddir_name ?= ./build/.
+.PHONY: all
+all:
+ $(MAKE) keccak
diff --git a/node_modules/keccak/build/config.gypi b/node_modules/keccak/build/config.gypi
new file mode 100644
index 0000000..b6f9d79
--- /dev/null
+++ b/node_modules/keccak/build/config.gypi
@@ -0,0 +1,92 @@
+# Do not edit. File was generated by node-gyp's "configure" step
+{
+ "target_defaults": {
+ "cflags": [],
+ "default_configuration": "Release",
+ "defines": [],
+ "include_dirs": [],
+ "libraries": [],
+ "msvs_configuration_platform": "ARM64",
+ "xcode_configuration_platform": "arm64"
+ },
+ "variables": {
+ "asan": 0,
+ "coverage": "false",
+ "dcheck_always_on": 0,
+ "debug_nghttp2": "false",
+ "debug_node": "false",
+ "enable_lto": "false",
+ "enable_pgo_generate": "false",
+ "enable_pgo_use": "false",
+ "error_on_warn": "false",
+ "force_dynamic_crt": 0,
+ "gas_version": "2.30",
+ "host_arch": "arm64",
+ "icu_data_in": "../../deps/icu-tmp/icudt68l.dat",
+ "icu_endianness": "l",
+ "icu_gyp_path": "tools/icu/icu-generic.gyp",
+ "icu_path": "deps/icu-small",
+ "icu_small": "false",
+ "icu_ver_major": "68",
+ "is_debug": 0,
+ "llvm_version": "0.0",
+ "napi_build_version": "7",
+ "node_byteorder": "little",
+ "node_debug_lib": "false",
+ "node_enable_d8": "false",
+ "node_install_npm": "true",
+ "node_module_version": 88,
+ "node_no_browser_globals": "false",
+ "node_prefix": "/",
+ "node_release_urlbase": "https://nodejs.org/download/release/",
+ "node_section_ordering_info": "",
+ "node_shared": "false",
+ "node_shared_brotli": "false",
+ "node_shared_cares": "false",
+ "node_shared_http_parser": "false",
+ "node_shared_libuv": "false",
+ "node_shared_nghttp2": "false",
+ "node_shared_openssl": "false",
+ "node_shared_zlib": "false",
+ "node_tag": "",
+ "node_target_type": "executable",
+ "node_use_bundled_v8": "true",
+ "node_use_dtrace": "false",
+ "node_use_etw": "false",
+ "node_use_node_code_cache": "true",
+ "node_use_node_snapshot": "true",
+ "node_use_openssl": "true",
+ "node_use_v8_platform": "true",
+ "node_with_ltcg": "false",
+ "node_without_node_options": "false",
+ "openssl_fips": "",
+ "openssl_is_fips": "false",
+ "ossfuzz": "false",
+ "shlib_suffix": "so.88",
+ "target_arch": "arm64",
+ "v8_enable_31bit_smis_on_64bit_arch": 0,
+ "v8_enable_gdbjit": 0,
+ "v8_enable_i18n_support": 1,
+ "v8_enable_inspector": 1,
+ "v8_enable_lite_mode": 0,
+ "v8_enable_object_print": 1,
+ "v8_enable_pointer_compression": 0,
+ "v8_no_strict_aliasing": 1,
+ "v8_optimized_debug": 1,
+ "v8_promise_internal_field_count": 1,
+ "v8_random_seed": 0,
+ "v8_trace_maps": 0,
+ "v8_use_siphash": 1,
+ "want_separate_host_toolset": 0,
+ "nodedir": "/home/ubuntu/.cache/node-gyp/15.8.0",
+ "standalone_static_library": 1,
+ "user_agent": "npm/7.5.3 node/v15.8.0 linux arm64",
+ "userconfig": "/home/ubuntu/.npmrc",
+ "metrics_registry": "https://registry.npmjs.org/",
+ "prefix": "/home/ubuntu/.nvm/versions/node/v15.8.0",
+ "cache": "/home/ubuntu/.npm",
+ "node_gyp": "/home/ubuntu/.nvm/versions/node/v15.8.0/lib/node_modules/npm/node_modules/node-gyp/bin/node-gyp.js",
+ "init_module": "/home/ubuntu/.npm-init.js",
+ "globalconfig": "/home/ubuntu/.nvm/versions/node/v15.8.0/etc/npmrc"
+ }
+}
diff --git a/node_modules/keccak/build/keccak.target.mk b/node_modules/keccak/build/keccak.target.mk
new file mode 100644
index 0000000..8d3004f
--- /dev/null
+++ b/node_modules/keccak/build/keccak.target.mk
@@ -0,0 +1,178 @@
+# This file is generated by gyp; do not edit.
+
+TOOLSET := target
+TARGET := keccak
+DEFS_Debug := \
+ '-DNODE_GYP_MODULE_NAME=keccak' \
+ '-DUSING_UV_SHARED=1' \
+ '-DUSING_V8_SHARED=1' \
+ '-DV8_DEPRECATION_WARNINGS=1' \
+ '-DV8_DEPRECATION_WARNINGS' \
+ '-DV8_IMMINENT_DEPRECATION_WARNINGS' \
+ '-D_LARGEFILE_SOURCE' \
+ '-D_FILE_OFFSET_BITS=64' \
+ '-D__STDC_FORMAT_MACROS' \
+ '-DOPENSSL_NO_PINSHARED' \
+ '-DOPENSSL_THREADS' \
+ '-DLIBKECCAK=64' \
+ '-DBUILDING_NODE_EXTENSION' \
+ '-DDEBUG' \
+ '-D_DEBUG' \
+ '-DV8_ENABLE_CHECKS'
+
+# Flags passed to all source files.
+CFLAGS_Debug := \
+ -fPIC \
+ -pthread \
+ -Wall \
+ -Wextra \
+ -Wno-unused-parameter \
+ -Wall \
+ -Wno-maybe-uninitialized \
+ -Wno-uninitialized \
+ -Wno-unused-function \
+ -Wextra \
+ -g \
+ -O0
+
+# Flags passed to only C files.
+CFLAGS_C_Debug :=
+
+# Flags passed to only C++ files.
+CFLAGS_CC_Debug := \
+ -fno-rtti \
+ -fno-exceptions \
+ -std=gnu++1y
+
+INCS_Debug := \
+ -I/home/ubuntu/.cache/node-gyp/15.8.0/include/node \
+ -I/home/ubuntu/.cache/node-gyp/15.8.0/src \
+ -I/home/ubuntu/.cache/node-gyp/15.8.0/deps/openssl/config \
+ -I/home/ubuntu/.cache/node-gyp/15.8.0/deps/openssl/openssl/include \
+ -I/home/ubuntu/.cache/node-gyp/15.8.0/deps/uv/include \
+ -I/home/ubuntu/.cache/node-gyp/15.8.0/deps/zlib \
+ -I/home/ubuntu/.cache/node-gyp/15.8.0/deps/v8/include \
+ -I$(srcdir)/../nan
+
+DEFS_Release := \
+ '-DNODE_GYP_MODULE_NAME=keccak' \
+ '-DUSING_UV_SHARED=1' \
+ '-DUSING_V8_SHARED=1' \
+ '-DV8_DEPRECATION_WARNINGS=1' \
+ '-DV8_DEPRECATION_WARNINGS' \
+ '-DV8_IMMINENT_DEPRECATION_WARNINGS' \
+ '-D_LARGEFILE_SOURCE' \
+ '-D_FILE_OFFSET_BITS=64' \
+ '-D__STDC_FORMAT_MACROS' \
+ '-DOPENSSL_NO_PINSHARED' \
+ '-DOPENSSL_THREADS' \
+ '-DLIBKECCAK=64' \
+ '-DBUILDING_NODE_EXTENSION'
+
+# Flags passed to all source files.
+CFLAGS_Release := \
+ -fPIC \
+ -pthread \
+ -Wall \
+ -Wextra \
+ -Wno-unused-parameter \
+ -Wall \
+ -Wno-maybe-uninitialized \
+ -Wno-uninitialized \
+ -Wno-unused-function \
+ -Wextra \
+ -O3 \
+ -fno-omit-frame-pointer
+
+# Flags passed to only C files.
+CFLAGS_C_Release :=
+
+# Flags passed to only C++ files.
+CFLAGS_CC_Release := \
+ -fno-rtti \
+ -fno-exceptions \
+ -std=gnu++1y
+
+INCS_Release := \
+ -I/home/ubuntu/.cache/node-gyp/15.8.0/include/node \
+ -I/home/ubuntu/.cache/node-gyp/15.8.0/src \
+ -I/home/ubuntu/.cache/node-gyp/15.8.0/deps/openssl/config \
+ -I/home/ubuntu/.cache/node-gyp/15.8.0/deps/openssl/openssl/include \
+ -I/home/ubuntu/.cache/node-gyp/15.8.0/deps/uv/include \
+ -I/home/ubuntu/.cache/node-gyp/15.8.0/deps/zlib \
+ -I/home/ubuntu/.cache/node-gyp/15.8.0/deps/v8/include \
+ -I$(srcdir)/../nan
+
+OBJS := \
+ $(obj).target/$(TARGET)/src/addon.o \
+ $(obj).target/$(TARGET)/src/libkeccak-64/KeccakSpongeWidth1600.o \
+ $(obj).target/$(TARGET)/src/libkeccak-64/KeccakP-1600-opt64.o
+
+# Add to the list of files we specially track dependencies for.
+all_deps += $(OBJS)
+
+# CFLAGS et al overrides must be target-local.
+# See "Target-specific Variable Values" in the GNU Make manual.
+$(OBJS): TOOLSET := $(TOOLSET)
+$(OBJS): GYP_CFLAGS := $(DEFS_$(BUILDTYPE)) $(INCS_$(BUILDTYPE)) $(CFLAGS_$(BUILDTYPE)) $(CFLAGS_C_$(BUILDTYPE))
+$(OBJS): GYP_CXXFLAGS := $(DEFS_$(BUILDTYPE)) $(INCS_$(BUILDTYPE)) $(CFLAGS_$(BUILDTYPE)) $(CFLAGS_CC_$(BUILDTYPE))
+
+# Suffix rules, putting all outputs into $(obj).
+
+$(obj).$(TOOLSET)/$(TARGET)/%.o: $(srcdir)/%.cc FORCE_DO_CMD
+ @$(call do_cmd,cxx,1)
+
+$(obj).$(TOOLSET)/$(TARGET)/%.o: $(srcdir)/%.c FORCE_DO_CMD
+ @$(call do_cmd,cc,1)
+
+# Try building from generated source, too.
+
+$(obj).$(TOOLSET)/$(TARGET)/%.o: $(obj).$(TOOLSET)/%.cc FORCE_DO_CMD
+ @$(call do_cmd,cxx,1)
+
+$(obj).$(TOOLSET)/$(TARGET)/%.o: $(obj).$(TOOLSET)/%.c FORCE_DO_CMD
+ @$(call do_cmd,cc,1)
+
+$(obj).$(TOOLSET)/$(TARGET)/%.o: $(obj)/%.cc FORCE_DO_CMD
+ @$(call do_cmd,cxx,1)
+
+$(obj).$(TOOLSET)/$(TARGET)/%.o: $(obj)/%.c FORCE_DO_CMD
+ @$(call do_cmd,cc,1)
+
+# End of this set of suffix rules
+### Rules for final target.
+LDFLAGS_Debug := \
+ -pthread \
+ -rdynamic
+
+LDFLAGS_Release := \
+ -pthread \
+ -rdynamic
+
+LIBS :=
+
+$(obj).target/keccak.node: GYP_LDFLAGS := $(LDFLAGS_$(BUILDTYPE))
+$(obj).target/keccak.node: LIBS := $(LIBS)
+$(obj).target/keccak.node: TOOLSET := $(TOOLSET)
+$(obj).target/keccak.node: $(OBJS) FORCE_DO_CMD
+ $(call do_cmd,solink_module)
+
+all_deps += $(obj).target/keccak.node
+# Add target alias
+.PHONY: keccak
+keccak: $(builddir)/keccak.node
+
+# Copy this to the executable output path.
+$(builddir)/keccak.node: TOOLSET := $(TOOLSET)
+$(builddir)/keccak.node: $(obj).target/keccak.node FORCE_DO_CMD
+ $(call do_cmd,copy)
+
+all_deps += $(builddir)/keccak.node
+# Short alias for building this executable.
+.PHONY: keccak.node
+keccak.node: $(obj).target/keccak.node $(builddir)/keccak.node
+
+# Add executable to "all" target.
+.PHONY: all
+all: $(builddir)/keccak.node
+
diff --git a/node_modules/keccak/index.js b/node_modules/keccak/index.js
new file mode 100644
index 0000000..7446e03
--- /dev/null
+++ b/node_modules/keccak/index.js
@@ -0,0 +1,10 @@
+'use strict'
+try {
+ module.exports = require('./bindings')
+} catch (err) {
+ if (process.env.DEBUG) {
+ console.error('Keccak bindings are not compiled. Pure JS implementation will be used.')
+ }
+
+ module.exports = require('./js')
+}
diff --git a/node_modules/keccak/js.js b/node_modules/keccak/js.js
new file mode 100644
index 0000000..a5ac409
--- /dev/null
+++ b/node_modules/keccak/js.js
@@ -0,0 +1,2 @@
+'use strict'
+module.exports = require('./lib/api')(require('./lib/keccak'))
diff --git a/node_modules/keccak/lib/api/index.js b/node_modules/keccak/lib/api/index.js
new file mode 100644
index 0000000..b014e91
--- /dev/null
+++ b/node_modules/keccak/lib/api/index.js
@@ -0,0 +1,28 @@
+'use strict'
+const createKeccak = require('./keccak')
+const createShake = require('./shake')
+
+module.exports = function (KeccakState) {
+ const Keccak = createKeccak(KeccakState)
+ const Shake = createShake(KeccakState)
+
+ return function (algorithm, options) {
+ const hash = typeof algorithm === 'string' ? algorithm.toLowerCase() : algorithm
+ switch (hash) {
+ case 'keccak224': return new Keccak(1152, 448, null, 224, options)
+ case 'keccak256': return new Keccak(1088, 512, null, 256, options)
+ case 'keccak384': return new Keccak(832, 768, null, 384, options)
+ case 'keccak512': return new Keccak(576, 1024, null, 512, options)
+
+ case 'sha3-224': return new Keccak(1152, 448, 0x06, 224, options)
+ case 'sha3-256': return new Keccak(1088, 512, 0x06, 256, options)
+ case 'sha3-384': return new Keccak(832, 768, 0x06, 384, options)
+ case 'sha3-512': return new Keccak(576, 1024, 0x06, 512, options)
+
+ case 'shake128': return new Shake(1344, 256, 0x1f, options)
+ case 'shake256': return new Shake(1088, 512, 0x1f, options)
+
+ default: throw new Error('Invald algorithm: ' + algorithm)
+ }
+ }
+}
diff --git a/node_modules/keccak/lib/api/keccak.js b/node_modules/keccak/lib/api/keccak.js
new file mode 100644
index 0000000..26053c5
--- /dev/null
+++ b/node_modules/keccak/lib/api/keccak.js
@@ -0,0 +1,84 @@
+'use strict'
+const Buffer = require('safe-buffer').Buffer
+const Transform = require('stream').Transform
+const inherits = require('inherits')
+
+module.exports = function (KeccakState) {
+ function Keccak (rate, capacity, delimitedSuffix, hashBitLength, options) {
+ Transform.call(this, options)
+
+ this._rate = rate
+ this._capacity = capacity
+ this._delimitedSuffix = delimitedSuffix
+ this._hashBitLength = hashBitLength
+ this._options = options
+
+ this._state = new KeccakState()
+ this._state.initialize(rate, capacity)
+ this._finalized = false
+ }
+
+ inherits(Keccak, Transform)
+
+ Keccak.prototype._transform = function (chunk, encoding, callback) {
+ let error = null
+ try {
+ this.update(chunk, encoding)
+ } catch (err) {
+ error = err
+ }
+
+ callback(error)
+ }
+
+ Keccak.prototype._flush = function (callback) {
+ let error = null
+ try {
+ this.push(this.digest())
+ } catch (err) {
+ error = err
+ }
+
+ callback(error)
+ }
+
+ Keccak.prototype.update = function (data, encoding) {
+ if (!Buffer.isBuffer(data) && typeof data !== 'string') throw new TypeError('Data must be a string or a buffer')
+ if (this._finalized) throw new Error('Digest already called')
+ if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding)
+
+ this._state.absorb(data)
+
+ return this
+ }
+
+ Keccak.prototype.digest = function (encoding) {
+ if (this._finalized) throw new Error('Digest already called')
+ this._finalized = true
+
+ if (this._delimitedSuffix) this._state.absorbLastFewBits(this._delimitedSuffix)
+ let digest = this._state.squeeze(this._hashBitLength / 8)
+ if (encoding !== undefined) digest = digest.toString(encoding)
+
+ this._resetState()
+
+ return digest
+ }
+
+ // remove result from memory
+ Keccak.prototype._resetState = function () {
+ this._state.initialize(this._rate, this._capacity)
+ return this
+ }
+
+ // because sometimes we need hash right now and little later
+ Keccak.prototype._clone = function () {
+ const clone = new Keccak(this._rate, this._capacity, this._delimitedSuffix, this._hashBitLength, this._options)
+ this._state.copy(clone._state)
+ clone._finalized = this._finalized
+
+ return clone
+ }
+
+ return Keccak
+}
diff --git a/node_modules/keccak/lib/api/shake.js b/node_modules/keccak/lib/api/shake.js
new file mode 100644
index 0000000..c8d6a96
--- /dev/null
+++ b/node_modules/keccak/lib/api/shake.js
@@ -0,0 +1,75 @@
+'use strict'
+const Buffer = require('safe-buffer').Buffer
+const Transform = require('stream').Transform
+const inherits = require('inherits')
+
+module.exports = function (KeccakState) {
+ function Shake (rate, capacity, delimitedSuffix, options) {
+ Transform.call(this, options)
+
+ this._rate = rate
+ this._capacity = capacity
+ this._delimitedSuffix = delimitedSuffix
+ this._options = options
+
+ this._state = new KeccakState()
+ this._state.initialize(rate, capacity)
+ this._finalized = false
+ }
+
+ inherits(Shake, Transform)
+
+ Shake.prototype._transform = function (chunk, encoding, callback) {
+ let error = null
+ try {
+ this.update(chunk, encoding)
+ } catch (err) {
+ error = err
+ }
+
+ callback(error)
+ }
+
+ Shake.prototype._flush = function () {}
+
+ Shake.prototype._read = function (size) {
+ this.push(this.squeeze(size))
+ }
+
+ Shake.prototype.update = function (data, encoding) {
+ if (!Buffer.isBuffer(data) && typeof data !== 'string') throw new TypeError('Data must be a string or a buffer')
+ if (this._finalized) throw new Error('Squeeze already called')
+ if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding)
+
+ this._state.absorb(data)
+
+ return this
+ }
+
+ Shake.prototype.squeeze = function (dataByteLength, encoding) {
+ if (!this._finalized) {
+ this._finalized = true
+ this._state.absorbLastFewBits(this._delimitedSuffix)
+ }
+
+ let data = this._state.squeeze(dataByteLength)
+ if (encoding !== undefined) data = data.toString(encoding)
+
+ return data
+ }
+
+ Shake.prototype._resetState = function () {
+ this._state.initialize(this._rate, this._capacity)
+ return this
+ }
+
+ Shake.prototype._clone = function () {
+ const clone = new Shake(this._rate, this._capacity, this._delimitedSuffix, this._options)
+ this._state.copy(clone._state)
+ clone._finalized = this._finalized
+
+ return clone
+ }
+
+ return Shake
+}
diff --git a/node_modules/keccak/lib/keccak-state-reference.js b/node_modules/keccak/lib/keccak-state-reference.js
new file mode 100644
index 0000000..d6918e7
--- /dev/null
+++ b/node_modules/keccak/lib/keccak-state-reference.js
@@ -0,0 +1,144 @@
+'use strict'
+const P1600_RHO_OFFSETS = [0, 1, 62, 28, 27, 36, 44, 6, 55, 20, 3, 10, 43, 25, 39, 41, 45, 15, 21, 8, 18, 2, 61, 56, 14]
+const P1600_ROUND_CONSTANTS = [
+ 0x00000001, 0x00000000,
+ 0x00008082, 0x00000000,
+ 0x0000808a, 0x80000000,
+ 0x80008000, 0x80000000,
+ 0x0000808b, 0x00000000,
+ 0x80000001, 0x00000000,
+ 0x80008081, 0x80000000,
+ 0x00008009, 0x80000000,
+ 0x0000008a, 0x00000000,
+ 0x00000088, 0x00000000,
+ 0x80008009, 0x00000000,
+ 0x8000000a, 0x00000000,
+ 0x8000808b, 0x00000000,
+ 0x0000008b, 0x80000000,
+ 0x00008089, 0x80000000,
+ 0x00008003, 0x80000000,
+ 0x00008002, 0x80000000,
+ 0x00000080, 0x80000000,
+ 0x0000800a, 0x00000000,
+ 0x8000000a, 0x80000000,
+ 0x80008081, 0x80000000,
+ 0x00008080, 0x80000000,
+ 0x80000001, 0x00000000,
+ 0x80008008, 0x80000000
+]
+
+function p1600 (state) {
+ for (let round = 0; round < 24; ++round) {
+ theta(state)
+ rho(state)
+ pi(state)
+ chi(state)
+ iota(state, round)
+ }
+}
+
+// steps
+function theta (s) {
+ const clo = [0, 0, 0, 0, 0]
+ const chi = [0, 0, 0, 0, 0]
+
+ for (let x = 0; x < 5; ++x) {
+ for (let y = 0; y < 5; ++y) {
+ clo[x] ^= s[ilo(x, y)]
+ chi[x] ^= s[ihi(x, y)]
+ }
+ }
+
+ for (let x = 0; x < 5; ++x) {
+ const next = (x + 1) % 5
+ const prev = (x + 4) % 5
+ const dlo = rol64lo(clo[next], chi[next], 1) ^ clo[prev]
+ const dhi = rol64hi(clo[next], chi[next], 1) ^ chi[prev]
+
+ for (let y = 0; y < 5; ++y) {
+ s[ilo(x, y)] ^= dlo
+ s[ihi(x, y)] ^= dhi
+ }
+ }
+}
+
+function rho (s) {
+ for (let x = 0; x < 5; ++x) {
+ for (let y = 0; y < 5; ++y) {
+ const lo = rol64lo(s[ilo(x, y)], s[ihi(x, y)], P1600_RHO_OFFSETS[index(x, y)])
+ const hi = rol64hi(s[ilo(x, y)], s[ihi(x, y)], P1600_RHO_OFFSETS[index(x, y)])
+ s[ilo(x, y)] = lo
+ s[ihi(x, y)] = hi
+ }
+ }
+}
+
+function pi (s) {
+ const ts = s.slice()
+
+ for (let x = 0; x < 5; ++x) {
+ for (let y = 0; y < 5; ++y) {
+ const nx = (0 * x + 1 * y) % 5
+ const ny = (2 * x + 3 * y) % 5
+ s[ilo(nx, ny)] = ts[ilo(x, y)]
+ s[ihi(nx, ny)] = ts[ihi(x, y)]
+ }
+ }
+}
+
+function chi (s) {
+ const clo = [0, 0, 0, 0, 0]
+ const chi = [0, 0, 0, 0, 0]
+
+ for (let y = 0; y < 5; ++y) {
+ for (let x = 0; x < 5; ++x) {
+ clo[x] = s[ilo(x, y)] ^ (~s[ilo((x + 1) % 5, y)] & s[ilo((x + 2) % 5, y)])
+ chi[x] = s[ihi(x, y)] ^ (~s[ihi((x + 1) % 5, y)] & s[ihi((x + 2) % 5, y)])
+ }
+
+ for (let x = 0; x < 5; ++x) {
+ s[ilo(x, y)] = clo[x]
+ s[ihi(x, y)] = chi[x]
+ }
+ }
+}
+
+function iota (s, i) {
+ s[ilo(0, 0)] ^= P1600_ROUND_CONSTANTS[i * 2]
+ s[ihi(0, 0)] ^= P1600_ROUND_CONSTANTS[i * 2 + 1]
+}
+
+// shortcuts
+function index (x, y) { return x + 5 * y }
+function ilo (x, y) { return index(x, y) * 2 }
+function ihi (x, y) { return index(x, y) * 2 + 1 }
+
+function rol64lo (lo, hi, shift) {
+ if (shift >= 32) {
+ const t = lo
+ lo = hi
+ hi = t
+ shift -= 32
+ }
+
+ return shift === 0 ? lo : (lo << shift) | (hi >>> (32 - shift))
+}
+
+function rol64hi (lo, hi, shift) {
+ if (shift >= 32) {
+ const t = lo
+ lo = hi
+ hi = t
+ shift -= 32
+ }
+
+ return shift === 0 ? hi : (hi << shift) | (lo >>> (32 - shift))
+}
+
+module.exports = {
+ p1600: p1600,
+
+ // for tests
+ _rol64lo: rol64lo,
+ _rol64hi: rol64hi
+}
diff --git a/node_modules/keccak/lib/keccak-state-unroll.js b/node_modules/keccak/lib/keccak-state-unroll.js
new file mode 100644
index 0000000..790bdf4
--- /dev/null
+++ b/node_modules/keccak/lib/keccak-state-unroll.js
@@ -0,0 +1,187 @@
+'use strict'
+const P1600_ROUND_CONSTANTS = [1, 0, 32898, 0, 32906, 2147483648, 2147516416, 2147483648, 32907, 0, 2147483649, 0, 2147516545, 2147483648, 32777, 2147483648, 138, 0, 136, 0, 2147516425, 0, 2147483658, 0, 2147516555, 0, 139, 2147483648, 32905, 2147483648, 32771, 2147483648, 32770, 2147483648, 128, 2147483648, 32778, 0, 2147483658, 2147483648, 2147516545, 2147483648, 32896, 2147483648, 2147483649, 0, 2147516424, 2147483648]
+
+exports.p1600 = function (s) {
+ for (let round = 0; round < 24; ++round) {
+ // theta
+ const lo0 = s[0] ^ s[10] ^ s[20] ^ s[30] ^ s[40]
+ const hi0 = s[1] ^ s[11] ^ s[21] ^ s[31] ^ s[41]
+ const lo1 = s[2] ^ s[12] ^ s[22] ^ s[32] ^ s[42]
+ const hi1 = s[3] ^ s[13] ^ s[23] ^ s[33] ^ s[43]
+ const lo2 = s[4] ^ s[14] ^ s[24] ^ s[34] ^ s[44]
+ const hi2 = s[5] ^ s[15] ^ s[25] ^ s[35] ^ s[45]
+ const lo3 = s[6] ^ s[16] ^ s[26] ^ s[36] ^ s[46]
+ const hi3 = s[7] ^ s[17] ^ s[27] ^ s[37] ^ s[47]
+ const lo4 = s[8] ^ s[18] ^ s[28] ^ s[38] ^ s[48]
+ const hi4 = s[9] ^ s[19] ^ s[29] ^ s[39] ^ s[49]
+
+ let lo = lo4 ^ (lo1 << 1 | hi1 >>> 31)
+ let hi = hi4 ^ (hi1 << 1 | lo1 >>> 31)
+ const t1slo0 = s[0] ^ lo
+ const t1shi0 = s[1] ^ hi
+ const t1slo5 = s[10] ^ lo
+ const t1shi5 = s[11] ^ hi
+ const t1slo10 = s[20] ^ lo
+ const t1shi10 = s[21] ^ hi
+ const t1slo15 = s[30] ^ lo
+ const t1shi15 = s[31] ^ hi
+ const t1slo20 = s[40] ^ lo
+ const t1shi20 = s[41] ^ hi
+ lo = lo0 ^ (lo2 << 1 | hi2 >>> 31)
+ hi = hi0 ^ (hi2 << 1 | lo2 >>> 31)
+ const t1slo1 = s[2] ^ lo
+ const t1shi1 = s[3] ^ hi
+ const t1slo6 = s[12] ^ lo
+ const t1shi6 = s[13] ^ hi
+ const t1slo11 = s[22] ^ lo
+ const t1shi11 = s[23] ^ hi
+ const t1slo16 = s[32] ^ lo
+ const t1shi16 = s[33] ^ hi
+ const t1slo21 = s[42] ^ lo
+ const t1shi21 = s[43] ^ hi
+ lo = lo1 ^ (lo3 << 1 | hi3 >>> 31)
+ hi = hi1 ^ (hi3 << 1 | lo3 >>> 31)
+ const t1slo2 = s[4] ^ lo
+ const t1shi2 = s[5] ^ hi
+ const t1slo7 = s[14] ^ lo
+ const t1shi7 = s[15] ^ hi
+ const t1slo12 = s[24] ^ lo
+ const t1shi12 = s[25] ^ hi
+ const t1slo17 = s[34] ^ lo
+ const t1shi17 = s[35] ^ hi
+ const t1slo22 = s[44] ^ lo
+ const t1shi22 = s[45] ^ hi
+ lo = lo2 ^ (lo4 << 1 | hi4 >>> 31)
+ hi = hi2 ^ (hi4 << 1 | lo4 >>> 31)
+ const t1slo3 = s[6] ^ lo
+ const t1shi3 = s[7] ^ hi
+ const t1slo8 = s[16] ^ lo
+ const t1shi8 = s[17] ^ hi
+ const t1slo13 = s[26] ^ lo
+ const t1shi13 = s[27] ^ hi
+ const t1slo18 = s[36] ^ lo
+ const t1shi18 = s[37] ^ hi
+ const t1slo23 = s[46] ^ lo
+ const t1shi23 = s[47] ^ hi
+ lo = lo3 ^ (lo0 << 1 | hi0 >>> 31)
+ hi = hi3 ^ (hi0 << 1 | lo0 >>> 31)
+ const t1slo4 = s[8] ^ lo
+ const t1shi4 = s[9] ^ hi
+ const t1slo9 = s[18] ^ lo
+ const t1shi9 = s[19] ^ hi
+ const t1slo14 = s[28] ^ lo
+ const t1shi14 = s[29] ^ hi
+ const t1slo19 = s[38] ^ lo
+ const t1shi19 = s[39] ^ hi
+ const t1slo24 = s[48] ^ lo
+ const t1shi24 = s[49] ^ hi
+
+ // rho & pi
+ const t2slo0 = t1slo0
+ const t2shi0 = t1shi0
+ const t2slo16 = (t1shi5 << 4 | t1slo5 >>> 28)
+ const t2shi16 = (t1slo5 << 4 | t1shi5 >>> 28)
+ const t2slo7 = (t1slo10 << 3 | t1shi10 >>> 29)
+ const t2shi7 = (t1shi10 << 3 | t1slo10 >>> 29)
+ const t2slo23 = (t1shi15 << 9 | t1slo15 >>> 23)
+ const t2shi23 = (t1slo15 << 9 | t1shi15 >>> 23)
+ const t2slo14 = (t1slo20 << 18 | t1shi20 >>> 14)
+ const t2shi14 = (t1shi20 << 18 | t1slo20 >>> 14)
+ const t2slo10 = (t1slo1 << 1 | t1shi1 >>> 31)
+ const t2shi10 = (t1shi1 << 1 | t1slo1 >>> 31)
+ const t2slo1 = (t1shi6 << 12 | t1slo6 >>> 20)
+ const t2shi1 = (t1slo6 << 12 | t1shi6 >>> 20)
+ const t2slo17 = (t1slo11 << 10 | t1shi11 >>> 22)
+ const t2shi17 = (t1shi11 << 10 | t1slo11 >>> 22)
+ const t2slo8 = (t1shi16 << 13 | t1slo16 >>> 19)
+ const t2shi8 = (t1slo16 << 13 | t1shi16 >>> 19)
+ const t2slo24 = (t1slo21 << 2 | t1shi21 >>> 30)
+ const t2shi24 = (t1shi21 << 2 | t1slo21 >>> 30)
+ const t2slo20 = (t1shi2 << 30 | t1slo2 >>> 2)
+ const t2shi20 = (t1slo2 << 30 | t1shi2 >>> 2)
+ const t2slo11 = (t1slo7 << 6 | t1shi7 >>> 26)
+ const t2shi11 = (t1shi7 << 6 | t1slo7 >>> 26)
+ const t2slo2 = (t1shi12 << 11 | t1slo12 >>> 21)
+ const t2shi2 = (t1slo12 << 11 | t1shi12 >>> 21)
+ const t2slo18 = (t1slo17 << 15 | t1shi17 >>> 17)
+ const t2shi18 = (t1shi17 << 15 | t1slo17 >>> 17)
+ const t2slo9 = (t1shi22 << 29 | t1slo22 >>> 3)
+ const t2shi9 = (t1slo22 << 29 | t1shi22 >>> 3)
+ const t2slo5 = (t1slo3 << 28 | t1shi3 >>> 4)
+ const t2shi5 = (t1shi3 << 28 | t1slo3 >>> 4)
+ const t2slo21 = (t1shi8 << 23 | t1slo8 >>> 9)
+ const t2shi21 = (t1slo8 << 23 | t1shi8 >>> 9)
+ const t2slo12 = (t1slo13 << 25 | t1shi13 >>> 7)
+ const t2shi12 = (t1shi13 << 25 | t1slo13 >>> 7)
+ const t2slo3 = (t1slo18 << 21 | t1shi18 >>> 11)
+ const t2shi3 = (t1shi18 << 21 | t1slo18 >>> 11)
+ const t2slo19 = (t1shi23 << 24 | t1slo23 >>> 8)
+ const t2shi19 = (t1slo23 << 24 | t1shi23 >>> 8)
+ const t2slo15 = (t1slo4 << 27 | t1shi4 >>> 5)
+ const t2shi15 = (t1shi4 << 27 | t1slo4 >>> 5)
+ const t2slo6 = (t1slo9 << 20 | t1shi9 >>> 12)
+ const t2shi6 = (t1shi9 << 20 | t1slo9 >>> 12)
+ const t2slo22 = (t1shi14 << 7 | t1slo14 >>> 25)
+ const t2shi22 = (t1slo14 << 7 | t1shi14 >>> 25)
+ const t2slo13 = (t1slo19 << 8 | t1shi19 >>> 24)
+ const t2shi13 = (t1shi19 << 8 | t1slo19 >>> 24)
+ const t2slo4 = (t1slo24 << 14 | t1shi24 >>> 18)
+ const t2shi4 = (t1shi24 << 14 | t1slo24 >>> 18)
+
+ // chi
+ s[0] = t2slo0 ^ (~t2slo1 & t2slo2)
+ s[1] = t2shi0 ^ (~t2shi1 & t2shi2)
+ s[10] = t2slo5 ^ (~t2slo6 & t2slo7)
+ s[11] = t2shi5 ^ (~t2shi6 & t2shi7)
+ s[20] = t2slo10 ^ (~t2slo11 & t2slo12)
+ s[21] = t2shi10 ^ (~t2shi11 & t2shi12)
+ s[30] = t2slo15 ^ (~t2slo16 & t2slo17)
+ s[31] = t2shi15 ^ (~t2shi16 & t2shi17)
+ s[40] = t2slo20 ^ (~t2slo21 & t2slo22)
+ s[41] = t2shi20 ^ (~t2shi21 & t2shi22)
+ s[2] = t2slo1 ^ (~t2slo2 & t2slo3)
+ s[3] = t2shi1 ^ (~t2shi2 & t2shi3)
+ s[12] = t2slo6 ^ (~t2slo7 & t2slo8)
+ s[13] = t2shi6 ^ (~t2shi7 & t2shi8)
+ s[22] = t2slo11 ^ (~t2slo12 & t2slo13)
+ s[23] = t2shi11 ^ (~t2shi12 & t2shi13)
+ s[32] = t2slo16 ^ (~t2slo17 & t2slo18)
+ s[33] = t2shi16 ^ (~t2shi17 & t2shi18)
+ s[42] = t2slo21 ^ (~t2slo22 & t2slo23)
+ s[43] = t2shi21 ^ (~t2shi22 & t2shi23)
+ s[4] = t2slo2 ^ (~t2slo3 & t2slo4)
+ s[5] = t2shi2 ^ (~t2shi3 & t2shi4)
+ s[14] = t2slo7 ^ (~t2slo8 & t2slo9)
+ s[15] = t2shi7 ^ (~t2shi8 & t2shi9)
+ s[24] = t2slo12 ^ (~t2slo13 & t2slo14)
+ s[25] = t2shi12 ^ (~t2shi13 & t2shi14)
+ s[34] = t2slo17 ^ (~t2slo18 & t2slo19)
+ s[35] = t2shi17 ^ (~t2shi18 & t2shi19)
+ s[44] = t2slo22 ^ (~t2slo23 & t2slo24)
+ s[45] = t2shi22 ^ (~t2shi23 & t2shi24)
+ s[6] = t2slo3 ^ (~t2slo4 & t2slo0)
+ s[7] = t2shi3 ^ (~t2shi4 & t2shi0)
+ s[16] = t2slo8 ^ (~t2slo9 & t2slo5)
+ s[17] = t2shi8 ^ (~t2shi9 & t2shi5)
+ s[26] = t2slo13 ^ (~t2slo14 & t2slo10)
+ s[27] = t2shi13 ^ (~t2shi14 & t2shi10)
+ s[36] = t2slo18 ^ (~t2slo19 & t2slo15)
+ s[37] = t2shi18 ^ (~t2shi19 & t2shi15)
+ s[46] = t2slo23 ^ (~t2slo24 & t2slo20)
+ s[47] = t2shi23 ^ (~t2shi24 & t2shi20)
+ s[8] = t2slo4 ^ (~t2slo0 & t2slo1)
+ s[9] = t2shi4 ^ (~t2shi0 & t2shi1)
+ s[18] = t2slo9 ^ (~t2slo5 & t2slo6)
+ s[19] = t2shi9 ^ (~t2shi5 & t2shi6)
+ s[28] = t2slo14 ^ (~t2slo10 & t2slo11)
+ s[29] = t2shi14 ^ (~t2shi10 & t2shi11)
+ s[38] = t2slo19 ^ (~t2slo15 & t2slo16)
+ s[39] = t2shi19 ^ (~t2shi15 & t2shi16)
+ s[48] = t2slo24 ^ (~t2slo20 & t2slo21)
+ s[49] = t2shi24 ^ (~t2shi20 & t2shi21)
+
+ // iota
+ s[0] ^= P1600_ROUND_CONSTANTS[round * 2]
+ s[1] ^= P1600_ROUND_CONSTANTS[round * 2 + 1]
+ }
+}
diff --git a/node_modules/keccak/lib/keccak.js b/node_modules/keccak/lib/keccak.js
new file mode 100644
index 0000000..64ecd94
--- /dev/null
+++ b/node_modules/keccak/lib/keccak.js
@@ -0,0 +1,70 @@
+'use strict'
+const Buffer = require('safe-buffer').Buffer
+const keccakState = require('./keccak-state-unroll')
+
+function Keccak () {
+ // much faster than `new Array(50)`
+ this.state = [
+ 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
+ ]
+
+ this.blockSize = null
+ this.count = 0
+ this.squeezing = false
+}
+
+Keccak.prototype.initialize = function (rate, capacity) {
+ for (let i = 0; i < 50; ++i) this.state[i] = 0
+ this.blockSize = rate / 8
+ this.count = 0
+ this.squeezing = false
+}
+
+Keccak.prototype.absorb = function (data) {
+ for (let i = 0; i < data.length; ++i) {
+ this.state[~~(this.count / 4)] ^= data[i] << (8 * (this.count % 4))
+ this.count += 1
+ if (this.count === this.blockSize) {
+ keccakState.p1600(this.state)
+ this.count = 0
+ }
+ }
+}
+
+Keccak.prototype.absorbLastFewBits = function (bits) {
+ this.state[~~(this.count / 4)] ^= bits << (8 * (this.count % 4))
+ if ((bits & 0x80) !== 0 && this.count === (this.blockSize - 1)) keccakState.p1600(this.state)
+ this.state[~~((this.blockSize - 1) / 4)] ^= 0x80 << (8 * ((this.blockSize - 1) % 4))
+ keccakState.p1600(this.state)
+ this.count = 0
+ this.squeezing = true
+}
+
+Keccak.prototype.squeeze = function (length) {
+ if (!this.squeezing) this.absorbLastFewBits(0x01)
+
+ const output = Buffer.alloc(length)
+ for (var i = 0; i < length; ++i) {
+ output[i] = (this.state[~~(this.count / 4)] >>> (8 * (this.count % 4))) & 0xff
+ this.count += 1
+ if (this.count === this.blockSize) {
+ keccakState.p1600(this.state)
+ this.count = 0
+ }
+ }
+
+ return output
+}
+
+Keccak.prototype.copy = function (dest) {
+ for (let i = 0; i < 50; ++i) dest.state[i] = this.state[i]
+ dest.blockSize = this.blockSize
+ dest.count = this.count
+ dest.squeezing = this.squeezing
+}
+
+module.exports = Keccak
diff --git a/node_modules/keccak/package.json b/node_modules/keccak/package.json
new file mode 100644
index 0000000..56b1ea3
--- /dev/null
+++ b/node_modules/keccak/package.json
@@ -0,0 +1,60 @@
+{
+ "name": "keccak",
+ "version": "2.1.0",
+ "description": "Keccak sponge function family",
+ "keywords": [
+ "sha3",
+ "sha-3",
+ "keccak",
+ "shake"
+ ],
+ "bugs": {
+ "url": "https://github.com/cryptocoinjs/keccak/issues"
+ },
+ "license": "MIT",
+ "contributors": [
+ "Kirill Fomichev (https://github.com/fanatid)"
+ ],
+ "files": [
+ "lib",
+ "src",
+ "binding.gyp",
+ "bindings.js",
+ "index.js",
+ "js.js"
+ ],
+ "main": "./index.js",
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/cryptocoinjs/keccak.git"
+ },
+ "scripts": {
+ "coverage": "nyc tape test/index.js",
+ "coverage-lcov": "npm run coverage && nyc report -r lcov",
+ "install": "npm run rebuild || echo \"Keccak bindings compilation fail. Pure JS implementation will be used.\"",
+ "lint": "standard",
+ "rebuild": "node-gyp rebuild",
+ "test": "npm run lint && npm run unit",
+ "unit": "tape test/index.js"
+ },
+ "dependencies": {
+ "bindings": "^1.5.0",
+ "inherits": "^2.0.4",
+ "nan": "^2.14.0",
+ "safe-buffer": "^5.2.0"
+ },
+ "devDependencies": {
+ "browserify": "^16.5.0",
+ "nyc": "^14.1.1",
+ "proxyquire": "^2.1.3",
+ "standard": "^14.3.1",
+ "tape": "^4.11.0"
+ },
+ "engines": {
+ "node": ">=5.12.0"
+ },
+ "gypfile": true,
+ "browser": {
+ "./index.js": "./js.js"
+ }
+}
diff --git a/node_modules/keccak/src/README.md b/node_modules/keccak/src/README.md
new file mode 100644
index 0000000..3ffe0e5
--- /dev/null
+++ b/node_modules/keccak/src/README.md
@@ -0,0 +1,28 @@
+# Importing Keccak C code
+
+The XKCP project contains various implementations of Keccak-related algorithms. These are the steps to select a specific implementation and import the code into our project.
+
+First, generate the source bundles in XKCP:
+
+```
+git clone https://github.com/XKCP/XKCP.git
+cd XKCP
+git checkout 58b20ec
+
+# Edit "Makefile.build". After all the tags, add the following two tags:
+
+#include
+
+extern "C" {
+#if LIBKECCAK == 32
+ #include "libkeccak-32/KeccakSpongeWidth1600.h"
+#elif LIBKECCAK == 64
+ #include "libkeccak-64/KeccakSpongeWidth1600.h"
+#else
+ #error "LIBKECCAK not defined correctly"
+#endif
+}
+
+class KeccakWrapper : public Nan::ObjectWrap {
+ public:
+ static v8::Local Init () {
+ Nan::EscapableHandleScope scope;
+
+ v8::Local tpl = Nan::New(New);
+ tpl->SetClassName(Nan::New("KeccakWrapper").ToLocalChecked());
+ tpl->InstanceTemplate()->SetInternalFieldCount(1);
+
+ Nan::SetPrototypeMethod(tpl, "initialize", Initialize);
+ Nan::SetPrototypeMethod(tpl, "absorb", Absorb);
+ Nan::SetPrototypeMethod(tpl, "absorbLastFewBits", AbsorbLastFewBits);
+ Nan::SetPrototypeMethod(tpl, "squeeze", Squeeze);
+ Nan::SetPrototypeMethod(tpl, "copy", Copy);
+
+ return scope.Escape(Nan::GetFunction(tpl).ToLocalChecked());
+ }
+
+ private:
+ KeccakWidth1600_SpongeInstance sponge;
+
+ static NAN_METHOD(New) {
+ KeccakWrapper* obj = new KeccakWrapper();
+ obj->Wrap(info.This());
+ info.GetReturnValue().Set(info.This());
+ }
+
+ static NAN_METHOD(Initialize) {
+ KeccakWrapper* obj = Nan::ObjectWrap::Unwrap(info.Holder());
+#if (NODE_MODULE_VERSION >= NODE_7_0_MODULE_VERSION)
+ unsigned int rate = info[0]->IntegerValue(info.GetIsolate()->GetCurrentContext()).ToChecked();
+ unsigned int capacity = info[1]->IntegerValue(info.GetIsolate()->GetCurrentContext()).ToChecked();
+#else
+ unsigned int rate = info[0]->IntegerValue();
+ unsigned int capacity = info[1]->IntegerValue();
+#endif
+
+ // ignore return code, rate & capacity always will right because internal object
+ KeccakWidth1600_SpongeInitialize(&obj->sponge, rate, capacity);
+ }
+
+ static NAN_METHOD(Absorb) {
+ KeccakWrapper* obj = Nan::ObjectWrap::Unwrap(info.Holder());
+ v8::Local buffer = info[0].As();
+ const unsigned char* data = (const unsigned char*) node::Buffer::Data(buffer);
+ size_t length = node::Buffer::Length(buffer);
+
+ // ignore return code, bcause internal object
+ KeccakWidth1600_SpongeAbsorb(&obj->sponge, data, length);
+ }
+
+ static NAN_METHOD(AbsorbLastFewBits) {
+ KeccakWrapper* obj = Nan::ObjectWrap::Unwrap(info.Holder());
+#if (NODE_MODULE_VERSION >= NODE_7_0_MODULE_VERSION)
+ unsigned char bits = info[0]->IntegerValue(info.GetIsolate()->GetCurrentContext()).ToChecked();
+#else
+ unsigned char bits = info[0]->IntegerValue();
+#endif
+
+ // ignore return code, bcause internal object
+ KeccakWidth1600_SpongeAbsorbLastFewBits(&obj->sponge, bits);
+ }
+
+ static NAN_METHOD(Squeeze) {
+ KeccakWrapper* obj = Nan::ObjectWrap::Unwrap(info.Holder());
+#if (NODE_MODULE_VERSION >= NODE_7_0_MODULE_VERSION)
+ size_t length = info[0]->IntegerValue(info.GetIsolate()->GetCurrentContext()).ToChecked();
+#else
+ size_t length = info[0]->IntegerValue();
+#endif
+
+ v8::Local buffer = Nan::NewBuffer(length).ToLocalChecked();
+ unsigned char* data = (unsigned char*) node::Buffer::Data(buffer);
+
+ KeccakWidth1600_SpongeSqueeze(&obj->sponge, data, length);
+ info.GetReturnValue().Set(buffer);
+ }
+
+ static NAN_METHOD(Copy) {
+ KeccakWrapper* from = Nan::ObjectWrap::Unwrap(info.Holder());
+#if (NODE_MODULE_VERSION >= NODE_7_0_MODULE_VERSION)
+ KeccakWrapper* to = Nan::ObjectWrap::Unwrap(info[0]->ToObject(info.GetIsolate()->GetCurrentContext()).ToLocalChecked());
+#else
+ KeccakWrapper* to = Nan::ObjectWrap::Unwrap(info[0]->ToObject());
+#endif
+
+ memcpy(&to->sponge, &from->sponge, sizeof(KeccakWidth1600_SpongeInstance));
+ }
+};
+
+void Init(Nan::ADDON_REGISTER_FUNCTION_ARGS_TYPE exports, Nan::ADDON_REGISTER_FUNCTION_ARGS_TYPE module) {
+ // I wish to use pure functions, but we need wrapper around state (KeccakWidth1600_SpongeInstance)
+ Nan::Set(module, Nan::New("exports").ToLocalChecked(), KeccakWrapper::Init());
+}
+
+NODE_MODULE(keccak, Init)
diff --git a/node_modules/keccak/src/libkeccak-32/KeccakP-1600-SnP.h b/node_modules/keccak/src/libkeccak-32/KeccakP-1600-SnP.h
new file mode 100644
index 0000000..9cb124f
--- /dev/null
+++ b/node_modules/keccak/src/libkeccak-32/KeccakP-1600-SnP.h
@@ -0,0 +1,38 @@
+/*
+Implementation by Ronny Van Keer, hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to our website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+
+---
+
+Please refer to SnP-documentation.h for more details.
+*/
+
+#ifndef _KeccakP_1600_SnP_h_
+#define _KeccakP_1600_SnP_h_
+
+/** For the documentation, see SnP-documentation.h.
+ */
+
+#define KeccakP1600_implementation "in-place 32-bit optimized implementation"
+#define KeccakP1600_stateSizeInBytes 200
+#define KeccakP1600_stateAlignment 8
+
+#define KeccakP1600_StaticInitialize()
+void KeccakP1600_Initialize(void *state);
+void KeccakP1600_AddByte(void *state, unsigned char data, unsigned int offset);
+void KeccakP1600_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length);
+void KeccakP1600_OverwriteBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length);
+void KeccakP1600_OverwriteWithZeroes(void *state, unsigned int byteCount);
+void KeccakP1600_Permute_Nrounds(void *state, unsigned int nrounds);
+void KeccakP1600_Permute_12rounds(void *state);
+void KeccakP1600_Permute_24rounds(void *state);
+void KeccakP1600_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length);
+void KeccakP1600_ExtractAndAddBytes(const void *state, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length);
+
+#endif
diff --git a/node_modules/keccak/src/libkeccak-32/KeccakP-1600-inplace32BI.c b/node_modules/keccak/src/libkeccak-32/KeccakP-1600-inplace32BI.c
new file mode 100644
index 0000000..d11acde
--- /dev/null
+++ b/node_modules/keccak/src/libkeccak-32/KeccakP-1600-inplace32BI.c
@@ -0,0 +1,1162 @@
+/*
+Implementation by Ronny Van Keer, hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to our website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+
+---
+
+This file implements Keccak-p[1600] in a SnP-compatible way.
+Please refer to SnP-documentation.h for more details.
+
+This implementation comes with KeccakP-1600-SnP.h in the same folder.
+Please refer to LowLevel.build for the exact list of other files it must be combined with.
+*/
+
+#include
+#include "brg_endian.h"
+#include "KeccakP-1600-SnP.h"
+#include "SnP-Relaned.h"
+
+typedef unsigned char UINT8;
+typedef unsigned int UINT32;
+/* WARNING: on 8-bit and 16-bit platforms, this should be replaced by: */
+/* typedef unsigned long UINT32; */
+
+#define ROL32(a, offset) ((((UINT32)a) << (offset)) ^ (((UINT32)a) >> (32-(offset))))
+
+/* Credit to Henry S. Warren, Hacker's Delight, Addison-Wesley, 2002 */
+#define prepareToBitInterleaving(low, high, temp, temp0, temp1) \
+ temp0 = (low); \
+ temp = (temp0 ^ (temp0 >> 1)) & 0x22222222UL; temp0 = temp0 ^ temp ^ (temp << 1); \
+ temp = (temp0 ^ (temp0 >> 2)) & 0x0C0C0C0CUL; temp0 = temp0 ^ temp ^ (temp << 2); \
+ temp = (temp0 ^ (temp0 >> 4)) & 0x00F000F0UL; temp0 = temp0 ^ temp ^ (temp << 4); \
+ temp = (temp0 ^ (temp0 >> 8)) & 0x0000FF00UL; temp0 = temp0 ^ temp ^ (temp << 8); \
+ temp1 = (high); \
+ temp = (temp1 ^ (temp1 >> 1)) & 0x22222222UL; temp1 = temp1 ^ temp ^ (temp << 1); \
+ temp = (temp1 ^ (temp1 >> 2)) & 0x0C0C0C0CUL; temp1 = temp1 ^ temp ^ (temp << 2); \
+ temp = (temp1 ^ (temp1 >> 4)) & 0x00F000F0UL; temp1 = temp1 ^ temp ^ (temp << 4); \
+ temp = (temp1 ^ (temp1 >> 8)) & 0x0000FF00UL; temp1 = temp1 ^ temp ^ (temp << 8);
+
+#define toBitInterleavingAndXOR(low, high, even, odd, temp, temp0, temp1) \
+ prepareToBitInterleaving(low, high, temp, temp0, temp1) \
+ even ^= (temp0 & 0x0000FFFF) | (temp1 << 16); \
+ odd ^= (temp0 >> 16) | (temp1 & 0xFFFF0000);
+
+#define toBitInterleavingAndAND(low, high, even, odd, temp, temp0, temp1) \
+ prepareToBitInterleaving(low, high, temp, temp0, temp1) \
+ even &= (temp0 & 0x0000FFFF) | (temp1 << 16); \
+ odd &= (temp0 >> 16) | (temp1 & 0xFFFF0000);
+
+#define toBitInterleavingAndSet(low, high, even, odd, temp, temp0, temp1) \
+ prepareToBitInterleaving(low, high, temp, temp0, temp1) \
+ even = (temp0 & 0x0000FFFF) | (temp1 << 16); \
+ odd = (temp0 >> 16) | (temp1 & 0xFFFF0000);
+
+/* Credit to Henry S. Warren, Hacker's Delight, Addison-Wesley, 2002 */
+#define prepareFromBitInterleaving(even, odd, temp, temp0, temp1) \
+ temp0 = (even); \
+ temp1 = (odd); \
+ temp = (temp0 & 0x0000FFFF) | (temp1 << 16); \
+ temp1 = (temp0 >> 16) | (temp1 & 0xFFFF0000); \
+ temp0 = temp; \
+ temp = (temp0 ^ (temp0 >> 8)) & 0x0000FF00UL; temp0 = temp0 ^ temp ^ (temp << 8); \
+ temp = (temp0 ^ (temp0 >> 4)) & 0x00F000F0UL; temp0 = temp0 ^ temp ^ (temp << 4); \
+ temp = (temp0 ^ (temp0 >> 2)) & 0x0C0C0C0CUL; temp0 = temp0 ^ temp ^ (temp << 2); \
+ temp = (temp0 ^ (temp0 >> 1)) & 0x22222222UL; temp0 = temp0 ^ temp ^ (temp << 1); \
+ temp = (temp1 ^ (temp1 >> 8)) & 0x0000FF00UL; temp1 = temp1 ^ temp ^ (temp << 8); \
+ temp = (temp1 ^ (temp1 >> 4)) & 0x00F000F0UL; temp1 = temp1 ^ temp ^ (temp << 4); \
+ temp = (temp1 ^ (temp1 >> 2)) & 0x0C0C0C0CUL; temp1 = temp1 ^ temp ^ (temp << 2); \
+ temp = (temp1 ^ (temp1 >> 1)) & 0x22222222UL; temp1 = temp1 ^ temp ^ (temp << 1);
+
+#define fromBitInterleaving(even, odd, low, high, temp, temp0, temp1) \
+ prepareFromBitInterleaving(even, odd, temp, temp0, temp1) \
+ low = temp0; \
+ high = temp1;
+
+#define fromBitInterleavingAndXOR(even, odd, lowIn, highIn, lowOut, highOut, temp, temp0, temp1) \
+ prepareFromBitInterleaving(even, odd, temp, temp0, temp1) \
+ lowOut = lowIn ^ temp0; \
+ highOut = highIn ^ temp1;
+
+void KeccakP1600_SetBytesInLaneToZero(void *state, unsigned int lanePosition, unsigned int offset, unsigned int length)
+{
+ UINT8 laneAsBytes[8];
+ UINT32 low, high;
+ UINT32 temp, temp0, temp1;
+ UINT32 *stateAsHalfLanes = (UINT32*)state;
+
+ memset(laneAsBytes, 0xFF, offset);
+ memset(laneAsBytes+offset, 0x00, length);
+ memset(laneAsBytes+offset+length, 0xFF, 8-offset-length);
+#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
+ low = *((UINT32*)(laneAsBytes+0));
+ high = *((UINT32*)(laneAsBytes+4));
+#else
+ low = laneAsBytes[0]
+ | ((UINT32)(laneAsBytes[1]) << 8)
+ | ((UINT32)(laneAsBytes[2]) << 16)
+ | ((UINT32)(laneAsBytes[3]) << 24);
+ high = laneAsBytes[4]
+ | ((UINT32)(laneAsBytes[5]) << 8)
+ | ((UINT32)(laneAsBytes[6]) << 16)
+ | ((UINT32)(laneAsBytes[7]) << 24);
+#endif
+ toBitInterleavingAndAND(low, high, stateAsHalfLanes[lanePosition*2+0], stateAsHalfLanes[lanePosition*2+1], temp, temp0, temp1);
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP1600_Initialize(void *state)
+{
+ memset(state, 0, 200);
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP1600_AddByte(void *state, unsigned char byte, unsigned int offset)
+{
+ unsigned int lanePosition = offset/8;
+ unsigned int offsetInLane = offset%8;
+ UINT32 low, high;
+ UINT32 temp, temp0, temp1;
+ UINT32 *stateAsHalfLanes = (UINT32*)state;
+
+ if (offsetInLane < 4) {
+ low = (UINT32)byte << (offsetInLane*8);
+ high = 0;
+ }
+ else {
+ low = 0;
+ high = (UINT32)byte << ((offsetInLane-4)*8);
+ }
+ toBitInterleavingAndXOR(low, high, stateAsHalfLanes[lanePosition*2+0], stateAsHalfLanes[lanePosition*2+1], temp, temp0, temp1);
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP1600_AddBytesInLane(void *state, unsigned int lanePosition, const unsigned char *data, unsigned int offset, unsigned int length)
+{
+ UINT8 laneAsBytes[8];
+ UINT32 low, high;
+ UINT32 temp, temp0, temp1;
+ UINT32 *stateAsHalfLanes = (UINT32*)state;
+
+ memset(laneAsBytes, 0, 8);
+ memcpy(laneAsBytes+offset, data, length);
+#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
+ low = *((UINT32*)(laneAsBytes+0));
+ high = *((UINT32*)(laneAsBytes+4));
+#else
+ low = laneAsBytes[0]
+ | ((UINT32)(laneAsBytes[1]) << 8)
+ | ((UINT32)(laneAsBytes[2]) << 16)
+ | ((UINT32)(laneAsBytes[3]) << 24);
+ high = laneAsBytes[4]
+ | ((UINT32)(laneAsBytes[5]) << 8)
+ | ((UINT32)(laneAsBytes[6]) << 16)
+ | ((UINT32)(laneAsBytes[7]) << 24);
+#endif
+ toBitInterleavingAndXOR(low, high, stateAsHalfLanes[lanePosition*2+0], stateAsHalfLanes[lanePosition*2+1], temp, temp0, temp1);
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP1600_AddLanes(void *state, const unsigned char *data, unsigned int laneCount)
+{
+#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
+ const UINT32 * pI = (const UINT32 *)data;
+ UINT32 * pS = (UINT32*)state;
+ UINT32 t, x0, x1;
+ int i;
+ for (i = laneCount-1; i >= 0; --i) {
+#ifdef NO_MISALIGNED_ACCESSES
+ UINT32 low;
+ UINT32 high;
+ memcpy(&low, pI++, 4);
+ memcpy(&high, pI++, 4);
+ toBitInterleavingAndXOR(low, high, *(pS++), *(pS++), t, x0, x1);
+#else
+ toBitInterleavingAndXOR(*(pI++), *(pI++), *(pS++), *(pS++), t, x0, x1)
+#endif
+ }
+#else
+ unsigned int lanePosition;
+ for(lanePosition=0; lanePosition= 0; --i) {
+#ifdef NO_MISALIGNED_ACCESSES
+ UINT32 low;
+ UINT32 high;
+ memcpy(&low, pI++, 4);
+ memcpy(&high, pI++, 4);
+ toBitInterleavingAndSet(low, high, *(pS++), *(pS++), t, x0, x1);
+#else
+ toBitInterleavingAndSet(*(pI++), *(pI++), *(pS++), *(pS++), t, x0, x1)
+#endif
+ }
+#else
+ unsigned int lanePosition;
+ for(lanePosition=0; lanePosition> 8) & 0xFF;
+ laneAsBytes[2] = (low >> 16) & 0xFF;
+ laneAsBytes[3] = (low >> 24) & 0xFF;
+ laneAsBytes[4] = high & 0xFF;
+ laneAsBytes[5] = (high >> 8) & 0xFF;
+ laneAsBytes[6] = (high >> 16) & 0xFF;
+ laneAsBytes[7] = (high >> 24) & 0xFF;
+#endif
+ memcpy(data, laneAsBytes+offset, length);
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP1600_ExtractLanes(const void *state, unsigned char *data, unsigned int laneCount)
+{
+#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
+ UINT32 * pI = (UINT32 *)data;
+ const UINT32 * pS = ( const UINT32 *)state;
+ UINT32 t, x0, x1;
+ int i;
+ for (i = laneCount-1; i >= 0; --i) {
+#ifdef NO_MISALIGNED_ACCESSES
+ UINT32 low;
+ UINT32 high;
+ fromBitInterleaving(*(pS++), *(pS++), low, high, t, x0, x1);
+ memcpy(pI++, &low, 4);
+ memcpy(pI++, &high, 4);
+#else
+ fromBitInterleaving(*(pS++), *(pS++), *(pI++), *(pI++), t, x0, x1)
+#endif
+ }
+#else
+ unsigned int lanePosition;
+ for(lanePosition=0; lanePosition> 8) & 0xFF;
+ laneAsBytes[2] = (low >> 16) & 0xFF;
+ laneAsBytes[3] = (low >> 24) & 0xFF;
+ laneAsBytes[4] = high & 0xFF;
+ laneAsBytes[5] = (high >> 8) & 0xFF;
+ laneAsBytes[6] = (high >> 16) & 0xFF;
+ laneAsBytes[7] = (high >> 24) & 0xFF;
+ memcpy(data+lanePosition*8, laneAsBytes, 8);
+ }
+#endif
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP1600_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length)
+{
+ SnP_ExtractBytes(state, data, offset, length, KeccakP1600_ExtractLanes, KeccakP1600_ExtractBytesInLane, 8);
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP1600_ExtractAndAddBytesInLane(const void *state, unsigned int lanePosition, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
+{
+ UINT32 *stateAsHalfLanes = (UINT32*)state;
+ UINT32 low, high, temp, temp0, temp1;
+ UINT8 laneAsBytes[8];
+ unsigned int i;
+
+ fromBitInterleaving(stateAsHalfLanes[lanePosition*2], stateAsHalfLanes[lanePosition*2+1], low, high, temp, temp0, temp1);
+#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
+ *((UINT32*)(laneAsBytes+0)) = low;
+ *((UINT32*)(laneAsBytes+4)) = high;
+#else
+ laneAsBytes[0] = low & 0xFF;
+ laneAsBytes[1] = (low >> 8) & 0xFF;
+ laneAsBytes[2] = (low >> 16) & 0xFF;
+ laneAsBytes[3] = (low >> 24) & 0xFF;
+ laneAsBytes[4] = high & 0xFF;
+ laneAsBytes[5] = (high >> 8) & 0xFF;
+ laneAsBytes[6] = (high >> 16) & 0xFF;
+ laneAsBytes[7] = (high >> 24) & 0xFF;
+#endif
+ for(i=0; i= 0; --i) {
+#ifdef NO_MISALIGNED_ACCESSES
+ UINT32 low;
+ UINT32 high;
+ fromBitInterleaving(*(pS++), *(pS++), low, high, t, x0, x1);
+ *(pO++) = *(pI++) ^ low;
+ *(pO++) = *(pI++) ^ high;
+#else
+ fromBitInterleavingAndXOR(*(pS++), *(pS++), *(pI++), *(pI++), *(pO++), *(pO++), t, x0, x1)
+#endif
+ }
+#else
+ unsigned int lanePosition;
+ for(lanePosition=0; lanePosition> 8) & 0xFF;
+ laneAsBytes[2] = (low >> 16) & 0xFF;
+ laneAsBytes[3] = (low >> 24) & 0xFF;
+ laneAsBytes[4] = high & 0xFF;
+ laneAsBytes[5] = (high >> 8) & 0xFF;
+ laneAsBytes[6] = (high >> 16) & 0xFF;
+ laneAsBytes[7] = (high >> 24) & 0xFF;
+ ((UINT32*)(output+lanePosition*8))[0] = ((UINT32*)(input+lanePosition*8))[0] ^ (*(const UINT32*)(laneAsBytes+0));
+ ((UINT32*)(output+lanePosition*8))[1] = ((UINT32*)(input+lanePosition*8))[0] ^ (*(const UINT32*)(laneAsBytes+4));
+ }
+#endif
+}
+/* ---------------------------------------------------------------- */
+
+void KeccakP1600_ExtractAndAddBytes(const void *state, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
+{
+ SnP_ExtractAndAddBytes(state, input, output, offset, length, KeccakP1600_ExtractAndAddLanes, KeccakP1600_ExtractAndAddBytesInLane, 8);
+}
+
+/* ---------------------------------------------------------------- */
+
+static const UINT32 KeccakF1600RoundConstants_int2[2*24+1] =
+{
+ 0x00000001UL, 0x00000000UL,
+ 0x00000000UL, 0x00000089UL,
+ 0x00000000UL, 0x8000008bUL,
+ 0x00000000UL, 0x80008080UL,
+ 0x00000001UL, 0x0000008bUL,
+ 0x00000001UL, 0x00008000UL,
+ 0x00000001UL, 0x80008088UL,
+ 0x00000001UL, 0x80000082UL,
+ 0x00000000UL, 0x0000000bUL,
+ 0x00000000UL, 0x0000000aUL,
+ 0x00000001UL, 0x00008082UL,
+ 0x00000000UL, 0x00008003UL,
+ 0x00000001UL, 0x0000808bUL,
+ 0x00000001UL, 0x8000000bUL,
+ 0x00000001UL, 0x8000008aUL,
+ 0x00000001UL, 0x80000081UL,
+ 0x00000000UL, 0x80000081UL,
+ 0x00000000UL, 0x80000008UL,
+ 0x00000000UL, 0x00000083UL,
+ 0x00000000UL, 0x80008003UL,
+ 0x00000001UL, 0x80008088UL,
+ 0x00000000UL, 0x80000088UL,
+ 0x00000001UL, 0x00008000UL,
+ 0x00000000UL, 0x80008082UL,
+ 0x000000FFUL
+};
+
+#define KeccakRound0() \
+ Cx = Abu0^Agu0^Aku0^Amu0^Asu0; \
+ Du1 = Abe1^Age1^Ake1^Ame1^Ase1; \
+ Da0 = Cx^ROL32(Du1, 1); \
+ Cz = Abu1^Agu1^Aku1^Amu1^Asu1; \
+ Du0 = Abe0^Age0^Ake0^Ame0^Ase0; \
+ Da1 = Cz^Du0; \
+ Cw = Abi0^Agi0^Aki0^Ami0^Asi0; \
+ Do0 = Cw^ROL32(Cz, 1); \
+ Cy = Abi1^Agi1^Aki1^Ami1^Asi1; \
+ Do1 = Cy^Cx; \
+ Cx = Aba0^Aga0^Aka0^Ama0^Asa0; \
+ De0 = Cx^ROL32(Cy, 1); \
+ Cz = Aba1^Aga1^Aka1^Ama1^Asa1; \
+ De1 = Cz^Cw; \
+ Cy = Abo1^Ago1^Ako1^Amo1^Aso1; \
+ Di0 = Du0^ROL32(Cy, 1); \
+ Cw = Abo0^Ago0^Ako0^Amo0^Aso0; \
+ Di1 = Du1^Cw; \
+ Du0 = Cw^ROL32(Cz, 1); \
+ Du1 = Cy^Cx; \
+\
+ Ba = (Aba0^Da0); \
+ Be = ROL32((Age0^De0), 22); \
+ Bi = ROL32((Aki1^Di1), 22); \
+ Bo = ROL32((Amo1^Do1), 11); \
+ Bu = ROL32((Asu0^Du0), 7); \
+ Aba0 = Ba ^((~Be)& Bi ); \
+ Aba0 ^= *(pRoundConstants++); \
+ Age0 = Be ^((~Bi)& Bo ); \
+ Aki1 = Bi ^((~Bo)& Bu ); \
+ Amo1 = Bo ^((~Bu)& Ba ); \
+ Asu0 = Bu ^((~Ba)& Be ); \
+ Ba = (Aba1^Da1); \
+ Be = ROL32((Age1^De1), 22); \
+ Bi = ROL32((Aki0^Di0), 21); \
+ Bo = ROL32((Amo0^Do0), 10); \
+ Bu = ROL32((Asu1^Du1), 7); \
+ Aba1 = Ba ^((~Be)& Bi ); \
+ Aba1 ^= *(pRoundConstants++); \
+ Age1 = Be ^((~Bi)& Bo ); \
+ Aki0 = Bi ^((~Bo)& Bu ); \
+ Amo0 = Bo ^((~Bu)& Ba ); \
+ Asu1 = Bu ^((~Ba)& Be ); \
+ Bi = ROL32((Aka1^Da1), 2); \
+ Bo = ROL32((Ame1^De1), 23); \
+ Bu = ROL32((Asi1^Di1), 31); \
+ Ba = ROL32((Abo0^Do0), 14); \
+ Be = ROL32((Agu0^Du0), 10); \
+ Aka1 = Ba ^((~Be)& Bi ); \
+ Ame1 = Be ^((~Bi)& Bo ); \
+ Asi1 = Bi ^((~Bo)& Bu ); \
+ Abo0 = Bo ^((~Bu)& Ba ); \
+ Agu0 = Bu ^((~Ba)& Be ); \
+ Bi = ROL32((Aka0^Da0), 1); \
+ Bo = ROL32((Ame0^De0), 22); \
+ Bu = ROL32((Asi0^Di0), 30); \
+ Ba = ROL32((Abo1^Do1), 14); \
+ Be = ROL32((Agu1^Du1), 10); \
+ Aka0 = Ba ^((~Be)& Bi ); \
+ Ame0 = Be ^((~Bi)& Bo ); \
+ Asi0 = Bi ^((~Bo)& Bu ); \
+ Abo1 = Bo ^((~Bu)& Ba ); \
+ Agu1 = Bu ^((~Ba)& Be ); \
+ Bu = ROL32((Asa0^Da0), 9); \
+ Ba = ROL32((Abe1^De1), 1); \
+ Be = ROL32((Agi0^Di0), 3); \
+ Bi = ROL32((Ako1^Do1), 13); \
+ Bo = ROL32((Amu0^Du0), 4); \
+ Asa0 = Ba ^((~Be)& Bi ); \
+ Abe1 = Be ^((~Bi)& Bo ); \
+ Agi0 = Bi ^((~Bo)& Bu ); \
+ Ako1 = Bo ^((~Bu)& Ba ); \
+ Amu0 = Bu ^((~Ba)& Be ); \
+ Bu = ROL32((Asa1^Da1), 9); \
+ Ba = (Abe0^De0); \
+ Be = ROL32((Agi1^Di1), 3); \
+ Bi = ROL32((Ako0^Do0), 12); \
+ Bo = ROL32((Amu1^Du1), 4); \
+ Asa1 = Ba ^((~Be)& Bi ); \
+ Abe0 = Be ^((~Bi)& Bo ); \
+ Agi1 = Bi ^((~Bo)& Bu ); \
+ Ako0 = Bo ^((~Bu)& Ba ); \
+ Amu1 = Bu ^((~Ba)& Be ); \
+ Be = ROL32((Aga0^Da0), 18); \
+ Bi = ROL32((Ake0^De0), 5); \
+ Bo = ROL32((Ami1^Di1), 8); \
+ Bu = ROL32((Aso0^Do0), 28); \
+ Ba = ROL32((Abu1^Du1), 14); \
+ Aga0 = Ba ^((~Be)& Bi ); \
+ Ake0 = Be ^((~Bi)& Bo ); \
+ Ami1 = Bi ^((~Bo)& Bu ); \
+ Aso0 = Bo ^((~Bu)& Ba ); \
+ Abu1 = Bu ^((~Ba)& Be ); \
+ Be = ROL32((Aga1^Da1), 18); \
+ Bi = ROL32((Ake1^De1), 5); \
+ Bo = ROL32((Ami0^Di0), 7); \
+ Bu = ROL32((Aso1^Do1), 28); \
+ Ba = ROL32((Abu0^Du0), 13); \
+ Aga1 = Ba ^((~Be)& Bi ); \
+ Ake1 = Be ^((~Bi)& Bo ); \
+ Ami0 = Bi ^((~Bo)& Bu ); \
+ Aso1 = Bo ^((~Bu)& Ba ); \
+ Abu0 = Bu ^((~Ba)& Be ); \
+ Bo = ROL32((Ama1^Da1), 21); \
+ Bu = ROL32((Ase0^De0), 1); \
+ Ba = ROL32((Abi0^Di0), 31); \
+ Be = ROL32((Ago1^Do1), 28); \
+ Bi = ROL32((Aku1^Du1), 20); \
+ Ama1 = Ba ^((~Be)& Bi ); \
+ Ase0 = Be ^((~Bi)& Bo ); \
+ Abi0 = Bi ^((~Bo)& Bu ); \
+ Ago1 = Bo ^((~Bu)& Ba ); \
+ Aku1 = Bu ^((~Ba)& Be ); \
+ Bo = ROL32((Ama0^Da0), 20); \
+ Bu = ROL32((Ase1^De1), 1); \
+ Ba = ROL32((Abi1^Di1), 31); \
+ Be = ROL32((Ago0^Do0), 27); \
+ Bi = ROL32((Aku0^Du0), 19); \
+ Ama0 = Ba ^((~Be)& Bi ); \
+ Ase1 = Be ^((~Bi)& Bo ); \
+ Abi1 = Bi ^((~Bo)& Bu ); \
+ Ago0 = Bo ^((~Bu)& Ba ); \
+ Aku0 = Bu ^((~Ba)& Be )
+
+#define KeccakRound1() \
+ Cx = Asu0^Agu0^Amu0^Abu1^Aku1; \
+ Du1 = Age1^Ame0^Abe0^Ake1^Ase1; \
+ Da0 = Cx^ROL32(Du1, 1); \
+ Cz = Asu1^Agu1^Amu1^Abu0^Aku0; \
+ Du0 = Age0^Ame1^Abe1^Ake0^Ase0; \
+ Da1 = Cz^Du0; \
+ Cw = Aki1^Asi1^Agi0^Ami1^Abi0; \
+ Do0 = Cw^ROL32(Cz, 1); \
+ Cy = Aki0^Asi0^Agi1^Ami0^Abi1; \
+ Do1 = Cy^Cx; \
+ Cx = Aba0^Aka1^Asa0^Aga0^Ama1; \
+ De0 = Cx^ROL32(Cy, 1); \
+ Cz = Aba1^Aka0^Asa1^Aga1^Ama0; \
+ De1 = Cz^Cw; \
+ Cy = Amo0^Abo1^Ako0^Aso1^Ago0; \
+ Di0 = Du0^ROL32(Cy, 1); \
+ Cw = Amo1^Abo0^Ako1^Aso0^Ago1; \
+ Di1 = Du1^Cw; \
+ Du0 = Cw^ROL32(Cz, 1); \
+ Du1 = Cy^Cx; \
+\
+ Ba = (Aba0^Da0); \
+ Be = ROL32((Ame1^De0), 22); \
+ Bi = ROL32((Agi1^Di1), 22); \
+ Bo = ROL32((Aso1^Do1), 11); \
+ Bu = ROL32((Aku1^Du0), 7); \
+ Aba0 = Ba ^((~Be)& Bi ); \
+ Aba0 ^= *(pRoundConstants++); \
+ Ame1 = Be ^((~Bi)& Bo ); \
+ Agi1 = Bi ^((~Bo)& Bu ); \
+ Aso1 = Bo ^((~Bu)& Ba ); \
+ Aku1 = Bu ^((~Ba)& Be ); \
+ Ba = (Aba1^Da1); \
+ Be = ROL32((Ame0^De1), 22); \
+ Bi = ROL32((Agi0^Di0), 21); \
+ Bo = ROL32((Aso0^Do0), 10); \
+ Bu = ROL32((Aku0^Du1), 7); \
+ Aba1 = Ba ^((~Be)& Bi ); \
+ Aba1 ^= *(pRoundConstants++); \
+ Ame0 = Be ^((~Bi)& Bo ); \
+ Agi0 = Bi ^((~Bo)& Bu ); \
+ Aso0 = Bo ^((~Bu)& Ba ); \
+ Aku0 = Bu ^((~Ba)& Be ); \
+ Bi = ROL32((Asa1^Da1), 2); \
+ Bo = ROL32((Ake1^De1), 23); \
+ Bu = ROL32((Abi1^Di1), 31); \
+ Ba = ROL32((Amo1^Do0), 14); \
+ Be = ROL32((Agu0^Du0), 10); \
+ Asa1 = Ba ^((~Be)& Bi ); \
+ Ake1 = Be ^((~Bi)& Bo ); \
+ Abi1 = Bi ^((~Bo)& Bu ); \
+ Amo1 = Bo ^((~Bu)& Ba ); \
+ Agu0 = Bu ^((~Ba)& Be ); \
+ Bi = ROL32((Asa0^Da0), 1); \
+ Bo = ROL32((Ake0^De0), 22); \
+ Bu = ROL32((Abi0^Di0), 30); \
+ Ba = ROL32((Amo0^Do1), 14); \
+ Be = ROL32((Agu1^Du1), 10); \
+ Asa0 = Ba ^((~Be)& Bi ); \
+ Ake0 = Be ^((~Bi)& Bo ); \
+ Abi0 = Bi ^((~Bo)& Bu ); \
+ Amo0 = Bo ^((~Bu)& Ba ); \
+ Agu1 = Bu ^((~Ba)& Be ); \
+ Bu = ROL32((Ama1^Da0), 9); \
+ Ba = ROL32((Age1^De1), 1); \
+ Be = ROL32((Asi1^Di0), 3); \
+ Bi = ROL32((Ako0^Do1), 13); \
+ Bo = ROL32((Abu1^Du0), 4); \
+ Ama1 = Ba ^((~Be)& Bi ); \
+ Age1 = Be ^((~Bi)& Bo ); \
+ Asi1 = Bi ^((~Bo)& Bu ); \
+ Ako0 = Bo ^((~Bu)& Ba ); \
+ Abu1 = Bu ^((~Ba)& Be ); \
+ Bu = ROL32((Ama0^Da1), 9); \
+ Ba = (Age0^De0); \
+ Be = ROL32((Asi0^Di1), 3); \
+ Bi = ROL32((Ako1^Do0), 12); \
+ Bo = ROL32((Abu0^Du1), 4); \
+ Ama0 = Ba ^((~Be)& Bi ); \
+ Age0 = Be ^((~Bi)& Bo ); \
+ Asi0 = Bi ^((~Bo)& Bu ); \
+ Ako1 = Bo ^((~Bu)& Ba ); \
+ Abu0 = Bu ^((~Ba)& Be ); \
+ Be = ROL32((Aka1^Da0), 18); \
+ Bi = ROL32((Abe1^De0), 5); \
+ Bo = ROL32((Ami0^Di1), 8); \
+ Bu = ROL32((Ago1^Do0), 28); \
+ Ba = ROL32((Asu1^Du1), 14); \
+ Aka1 = Ba ^((~Be)& Bi ); \
+ Abe1 = Be ^((~Bi)& Bo ); \
+ Ami0 = Bi ^((~Bo)& Bu ); \
+ Ago1 = Bo ^((~Bu)& Ba ); \
+ Asu1 = Bu ^((~Ba)& Be ); \
+ Be = ROL32((Aka0^Da1), 18); \
+ Bi = ROL32((Abe0^De1), 5); \
+ Bo = ROL32((Ami1^Di0), 7); \
+ Bu = ROL32((Ago0^Do1), 28); \
+ Ba = ROL32((Asu0^Du0), 13); \
+ Aka0 = Ba ^((~Be)& Bi ); \
+ Abe0 = Be ^((~Bi)& Bo ); \
+ Ami1 = Bi ^((~Bo)& Bu ); \
+ Ago0 = Bo ^((~Bu)& Ba ); \
+ Asu0 = Bu ^((~Ba)& Be ); \
+ Bo = ROL32((Aga1^Da1), 21); \
+ Bu = ROL32((Ase0^De0), 1); \
+ Ba = ROL32((Aki1^Di0), 31); \
+ Be = ROL32((Abo1^Do1), 28); \
+ Bi = ROL32((Amu1^Du1), 20); \
+ Aga1 = Ba ^((~Be)& Bi ); \
+ Ase0 = Be ^((~Bi)& Bo ); \
+ Aki1 = Bi ^((~Bo)& Bu ); \
+ Abo1 = Bo ^((~Bu)& Ba ); \
+ Amu1 = Bu ^((~Ba)& Be ); \
+ Bo = ROL32((Aga0^Da0), 20); \
+ Bu = ROL32((Ase1^De1), 1); \
+ Ba = ROL32((Aki0^Di1), 31); \
+ Be = ROL32((Abo0^Do0), 27); \
+ Bi = ROL32((Amu0^Du0), 19); \
+ Aga0 = Ba ^((~Be)& Bi ); \
+ Ase1 = Be ^((~Bi)& Bo ); \
+ Aki0 = Bi ^((~Bo)& Bu ); \
+ Abo0 = Bo ^((~Bu)& Ba ); \
+ Amu0 = Bu ^((~Ba)& Be );
+
+#define KeccakRound2() \
+ Cx = Aku1^Agu0^Abu1^Asu1^Amu1; \
+ Du1 = Ame0^Ake0^Age0^Abe0^Ase1; \
+ Da0 = Cx^ROL32(Du1, 1); \
+ Cz = Aku0^Agu1^Abu0^Asu0^Amu0; \
+ Du0 = Ame1^Ake1^Age1^Abe1^Ase0; \
+ Da1 = Cz^Du0; \
+ Cw = Agi1^Abi1^Asi1^Ami0^Aki1; \
+ Do0 = Cw^ROL32(Cz, 1); \
+ Cy = Agi0^Abi0^Asi0^Ami1^Aki0; \
+ Do1 = Cy^Cx; \
+ Cx = Aba0^Asa1^Ama1^Aka1^Aga1; \
+ De0 = Cx^ROL32(Cy, 1); \
+ Cz = Aba1^Asa0^Ama0^Aka0^Aga0; \
+ De1 = Cz^Cw; \
+ Cy = Aso0^Amo0^Ako1^Ago0^Abo0; \
+ Di0 = Du0^ROL32(Cy, 1); \
+ Cw = Aso1^Amo1^Ako0^Ago1^Abo1; \
+ Di1 = Du1^Cw; \
+ Du0 = Cw^ROL32(Cz, 1); \
+ Du1 = Cy^Cx; \
+\
+ Ba = (Aba0^Da0); \
+ Be = ROL32((Ake1^De0), 22); \
+ Bi = ROL32((Asi0^Di1), 22); \
+ Bo = ROL32((Ago0^Do1), 11); \
+ Bu = ROL32((Amu1^Du0), 7); \
+ Aba0 = Ba ^((~Be)& Bi ); \
+ Aba0 ^= *(pRoundConstants++); \
+ Ake1 = Be ^((~Bi)& Bo ); \
+ Asi0 = Bi ^((~Bo)& Bu ); \
+ Ago0 = Bo ^((~Bu)& Ba ); \
+ Amu1 = Bu ^((~Ba)& Be ); \
+ Ba = (Aba1^Da1); \
+ Be = ROL32((Ake0^De1), 22); \
+ Bi = ROL32((Asi1^Di0), 21); \
+ Bo = ROL32((Ago1^Do0), 10); \
+ Bu = ROL32((Amu0^Du1), 7); \
+ Aba1 = Ba ^((~Be)& Bi ); \
+ Aba1 ^= *(pRoundConstants++); \
+ Ake0 = Be ^((~Bi)& Bo ); \
+ Asi1 = Bi ^((~Bo)& Bu ); \
+ Ago1 = Bo ^((~Bu)& Ba ); \
+ Amu0 = Bu ^((~Ba)& Be ); \
+ Bi = ROL32((Ama0^Da1), 2); \
+ Bo = ROL32((Abe0^De1), 23); \
+ Bu = ROL32((Aki0^Di1), 31); \
+ Ba = ROL32((Aso1^Do0), 14); \
+ Be = ROL32((Agu0^Du0), 10); \
+ Ama0 = Ba ^((~Be)& Bi ); \
+ Abe0 = Be ^((~Bi)& Bo ); \
+ Aki0 = Bi ^((~Bo)& Bu ); \
+ Aso1 = Bo ^((~Bu)& Ba ); \
+ Agu0 = Bu ^((~Ba)& Be ); \
+ Bi = ROL32((Ama1^Da0), 1); \
+ Bo = ROL32((Abe1^De0), 22); \
+ Bu = ROL32((Aki1^Di0), 30); \
+ Ba = ROL32((Aso0^Do1), 14); \
+ Be = ROL32((Agu1^Du1), 10); \
+ Ama1 = Ba ^((~Be)& Bi ); \
+ Abe1 = Be ^((~Bi)& Bo ); \
+ Aki1 = Bi ^((~Bo)& Bu ); \
+ Aso0 = Bo ^((~Bu)& Ba ); \
+ Agu1 = Bu ^((~Ba)& Be ); \
+ Bu = ROL32((Aga1^Da0), 9); \
+ Ba = ROL32((Ame0^De1), 1); \
+ Be = ROL32((Abi1^Di0), 3); \
+ Bi = ROL32((Ako1^Do1), 13); \
+ Bo = ROL32((Asu1^Du0), 4); \
+ Aga1 = Ba ^((~Be)& Bi ); \
+ Ame0 = Be ^((~Bi)& Bo ); \
+ Abi1 = Bi ^((~Bo)& Bu ); \
+ Ako1 = Bo ^((~Bu)& Ba ); \
+ Asu1 = Bu ^((~Ba)& Be ); \
+ Bu = ROL32((Aga0^Da1), 9); \
+ Ba = (Ame1^De0); \
+ Be = ROL32((Abi0^Di1), 3); \
+ Bi = ROL32((Ako0^Do0), 12); \
+ Bo = ROL32((Asu0^Du1), 4); \
+ Aga0 = Ba ^((~Be)& Bi ); \
+ Ame1 = Be ^((~Bi)& Bo ); \
+ Abi0 = Bi ^((~Bo)& Bu ); \
+ Ako0 = Bo ^((~Bu)& Ba ); \
+ Asu0 = Bu ^((~Ba)& Be ); \
+ Be = ROL32((Asa1^Da0), 18); \
+ Bi = ROL32((Age1^De0), 5); \
+ Bo = ROL32((Ami1^Di1), 8); \
+ Bu = ROL32((Abo1^Do0), 28); \
+ Ba = ROL32((Aku0^Du1), 14); \
+ Asa1 = Ba ^((~Be)& Bi ); \
+ Age1 = Be ^((~Bi)& Bo ); \
+ Ami1 = Bi ^((~Bo)& Bu ); \
+ Abo1 = Bo ^((~Bu)& Ba ); \
+ Aku0 = Bu ^((~Ba)& Be ); \
+ Be = ROL32((Asa0^Da1), 18); \
+ Bi = ROL32((Age0^De1), 5); \
+ Bo = ROL32((Ami0^Di0), 7); \
+ Bu = ROL32((Abo0^Do1), 28); \
+ Ba = ROL32((Aku1^Du0), 13); \
+ Asa0 = Ba ^((~Be)& Bi ); \
+ Age0 = Be ^((~Bi)& Bo ); \
+ Ami0 = Bi ^((~Bo)& Bu ); \
+ Abo0 = Bo ^((~Bu)& Ba ); \
+ Aku1 = Bu ^((~Ba)& Be ); \
+ Bo = ROL32((Aka0^Da1), 21); \
+ Bu = ROL32((Ase0^De0), 1); \
+ Ba = ROL32((Agi1^Di0), 31); \
+ Be = ROL32((Amo0^Do1), 28); \
+ Bi = ROL32((Abu0^Du1), 20); \
+ Aka0 = Ba ^((~Be)& Bi ); \
+ Ase0 = Be ^((~Bi)& Bo ); \
+ Agi1 = Bi ^((~Bo)& Bu ); \
+ Amo0 = Bo ^((~Bu)& Ba ); \
+ Abu0 = Bu ^((~Ba)& Be ); \
+ Bo = ROL32((Aka1^Da0), 20); \
+ Bu = ROL32((Ase1^De1), 1); \
+ Ba = ROL32((Agi0^Di1), 31); \
+ Be = ROL32((Amo1^Do0), 27); \
+ Bi = ROL32((Abu1^Du0), 19); \
+ Aka1 = Ba ^((~Be)& Bi ); \
+ Ase1 = Be ^((~Bi)& Bo ); \
+ Agi0 = Bi ^((~Bo)& Bu ); \
+ Amo1 = Bo ^((~Bu)& Ba ); \
+ Abu1 = Bu ^((~Ba)& Be );
+
+#define KeccakRound3() \
+ Cx = Amu1^Agu0^Asu1^Aku0^Abu0; \
+ Du1 = Ake0^Abe1^Ame1^Age0^Ase1; \
+ Da0 = Cx^ROL32(Du1, 1); \
+ Cz = Amu0^Agu1^Asu0^Aku1^Abu1; \
+ Du0 = Ake1^Abe0^Ame0^Age1^Ase0; \
+ Da1 = Cz^Du0; \
+ Cw = Asi0^Aki0^Abi1^Ami1^Agi1; \
+ Do0 = Cw^ROL32(Cz, 1); \
+ Cy = Asi1^Aki1^Abi0^Ami0^Agi0; \
+ Do1 = Cy^Cx; \
+ Cx = Aba0^Ama0^Aga1^Asa1^Aka0; \
+ De0 = Cx^ROL32(Cy, 1); \
+ Cz = Aba1^Ama1^Aga0^Asa0^Aka1; \
+ De1 = Cz^Cw; \
+ Cy = Ago1^Aso0^Ako0^Abo0^Amo1; \
+ Di0 = Du0^ROL32(Cy, 1); \
+ Cw = Ago0^Aso1^Ako1^Abo1^Amo0; \
+ Di1 = Du1^Cw; \
+ Du0 = Cw^ROL32(Cz, 1); \
+ Du1 = Cy^Cx; \
+\
+ Ba = (Aba0^Da0); \
+ Be = ROL32((Abe0^De0), 22); \
+ Bi = ROL32((Abi0^Di1), 22); \
+ Bo = ROL32((Abo0^Do1), 11); \
+ Bu = ROL32((Abu0^Du0), 7); \
+ Aba0 = Ba ^((~Be)& Bi ); \
+ Aba0 ^= *(pRoundConstants++); \
+ Abe0 = Be ^((~Bi)& Bo ); \
+ Abi0 = Bi ^((~Bo)& Bu ); \
+ Abo0 = Bo ^((~Bu)& Ba ); \
+ Abu0 = Bu ^((~Ba)& Be ); \
+ Ba = (Aba1^Da1); \
+ Be = ROL32((Abe1^De1), 22); \
+ Bi = ROL32((Abi1^Di0), 21); \
+ Bo = ROL32((Abo1^Do0), 10); \
+ Bu = ROL32((Abu1^Du1), 7); \
+ Aba1 = Ba ^((~Be)& Bi ); \
+ Aba1 ^= *(pRoundConstants++); \
+ Abe1 = Be ^((~Bi)& Bo ); \
+ Abi1 = Bi ^((~Bo)& Bu ); \
+ Abo1 = Bo ^((~Bu)& Ba ); \
+ Abu1 = Bu ^((~Ba)& Be ); \
+ Bi = ROL32((Aga0^Da1), 2); \
+ Bo = ROL32((Age0^De1), 23); \
+ Bu = ROL32((Agi0^Di1), 31); \
+ Ba = ROL32((Ago0^Do0), 14); \
+ Be = ROL32((Agu0^Du0), 10); \
+ Aga0 = Ba ^((~Be)& Bi ); \
+ Age0 = Be ^((~Bi)& Bo ); \
+ Agi0 = Bi ^((~Bo)& Bu ); \
+ Ago0 = Bo ^((~Bu)& Ba ); \
+ Agu0 = Bu ^((~Ba)& Be ); \
+ Bi = ROL32((Aga1^Da0), 1); \
+ Bo = ROL32((Age1^De0), 22); \
+ Bu = ROL32((Agi1^Di0), 30); \
+ Ba = ROL32((Ago1^Do1), 14); \
+ Be = ROL32((Agu1^Du1), 10); \
+ Aga1 = Ba ^((~Be)& Bi ); \
+ Age1 = Be ^((~Bi)& Bo ); \
+ Agi1 = Bi ^((~Bo)& Bu ); \
+ Ago1 = Bo ^((~Bu)& Ba ); \
+ Agu1 = Bu ^((~Ba)& Be ); \
+ Bu = ROL32((Aka0^Da0), 9); \
+ Ba = ROL32((Ake0^De1), 1); \
+ Be = ROL32((Aki0^Di0), 3); \
+ Bi = ROL32((Ako0^Do1), 13); \
+ Bo = ROL32((Aku0^Du0), 4); \
+ Aka0 = Ba ^((~Be)& Bi ); \
+ Ake0 = Be ^((~Bi)& Bo ); \
+ Aki0 = Bi ^((~Bo)& Bu ); \
+ Ako0 = Bo ^((~Bu)& Ba ); \
+ Aku0 = Bu ^((~Ba)& Be ); \
+ Bu = ROL32((Aka1^Da1), 9); \
+ Ba = (Ake1^De0); \
+ Be = ROL32((Aki1^Di1), 3); \
+ Bi = ROL32((Ako1^Do0), 12); \
+ Bo = ROL32((Aku1^Du1), 4); \
+ Aka1 = Ba ^((~Be)& Bi ); \
+ Ake1 = Be ^((~Bi)& Bo ); \
+ Aki1 = Bi ^((~Bo)& Bu ); \
+ Ako1 = Bo ^((~Bu)& Ba ); \
+ Aku1 = Bu ^((~Ba)& Be ); \
+ Be = ROL32((Ama0^Da0), 18); \
+ Bi = ROL32((Ame0^De0), 5); \
+ Bo = ROL32((Ami0^Di1), 8); \
+ Bu = ROL32((Amo0^Do0), 28); \
+ Ba = ROL32((Amu0^Du1), 14); \
+ Ama0 = Ba ^((~Be)& Bi ); \
+ Ame0 = Be ^((~Bi)& Bo ); \
+ Ami0 = Bi ^((~Bo)& Bu ); \
+ Amo0 = Bo ^((~Bu)& Ba ); \
+ Amu0 = Bu ^((~Ba)& Be ); \
+ Be = ROL32((Ama1^Da1), 18); \
+ Bi = ROL32((Ame1^De1), 5); \
+ Bo = ROL32((Ami1^Di0), 7); \
+ Bu = ROL32((Amo1^Do1), 28); \
+ Ba = ROL32((Amu1^Du0), 13); \
+ Ama1 = Ba ^((~Be)& Bi ); \
+ Ame1 = Be ^((~Bi)& Bo ); \
+ Ami1 = Bi ^((~Bo)& Bu ); \
+ Amo1 = Bo ^((~Bu)& Ba ); \
+ Amu1 = Bu ^((~Ba)& Be ); \
+ Bo = ROL32((Asa0^Da1), 21); \
+ Bu = ROL32((Ase0^De0), 1); \
+ Ba = ROL32((Asi0^Di0), 31); \
+ Be = ROL32((Aso0^Do1), 28); \
+ Bi = ROL32((Asu0^Du1), 20); \
+ Asa0 = Ba ^((~Be)& Bi ); \
+ Ase0 = Be ^((~Bi)& Bo ); \
+ Asi0 = Bi ^((~Bo)& Bu ); \
+ Aso0 = Bo ^((~Bu)& Ba ); \
+ Asu0 = Bu ^((~Ba)& Be ); \
+ Bo = ROL32((Asa1^Da0), 20); \
+ Bu = ROL32((Ase1^De1), 1); \
+ Ba = ROL32((Asi1^Di1), 31); \
+ Be = ROL32((Aso1^Do0), 27); \
+ Bi = ROL32((Asu1^Du0), 19); \
+ Asa1 = Ba ^((~Be)& Bi ); \
+ Ase1 = Be ^((~Bi)& Bo ); \
+ Asi1 = Bi ^((~Bo)& Bu ); \
+ Aso1 = Bo ^((~Bu)& Ba ); \
+ Asu1 = Bu ^((~Ba)& Be );
+
+void KeccakP1600_Permute_Nrounds(void *state, unsigned int nRounds)
+{
+ UINT32 Da0, De0, Di0, Do0, Du0;
+ UINT32 Da1, De1, Di1, Do1, Du1;
+ UINT32 Ba, Be, Bi, Bo, Bu;
+ UINT32 Cx, Cy, Cz, Cw;
+ const UINT32 *pRoundConstants = KeccakF1600RoundConstants_int2+(24-nRounds)*2;
+ UINT32 *stateAsHalfLanes = (UINT32*)state;
+ #define Aba0 stateAsHalfLanes[ 0]
+ #define Aba1 stateAsHalfLanes[ 1]
+ #define Abe0 stateAsHalfLanes[ 2]
+ #define Abe1 stateAsHalfLanes[ 3]
+ #define Abi0 stateAsHalfLanes[ 4]
+ #define Abi1 stateAsHalfLanes[ 5]
+ #define Abo0 stateAsHalfLanes[ 6]
+ #define Abo1 stateAsHalfLanes[ 7]
+ #define Abu0 stateAsHalfLanes[ 8]
+ #define Abu1 stateAsHalfLanes[ 9]
+ #define Aga0 stateAsHalfLanes[10]
+ #define Aga1 stateAsHalfLanes[11]
+ #define Age0 stateAsHalfLanes[12]
+ #define Age1 stateAsHalfLanes[13]
+ #define Agi0 stateAsHalfLanes[14]
+ #define Agi1 stateAsHalfLanes[15]
+ #define Ago0 stateAsHalfLanes[16]
+ #define Ago1 stateAsHalfLanes[17]
+ #define Agu0 stateAsHalfLanes[18]
+ #define Agu1 stateAsHalfLanes[19]
+ #define Aka0 stateAsHalfLanes[20]
+ #define Aka1 stateAsHalfLanes[21]
+ #define Ake0 stateAsHalfLanes[22]
+ #define Ake1 stateAsHalfLanes[23]
+ #define Aki0 stateAsHalfLanes[24]
+ #define Aki1 stateAsHalfLanes[25]
+ #define Ako0 stateAsHalfLanes[26]
+ #define Ako1 stateAsHalfLanes[27]
+ #define Aku0 stateAsHalfLanes[28]
+ #define Aku1 stateAsHalfLanes[29]
+ #define Ama0 stateAsHalfLanes[30]
+ #define Ama1 stateAsHalfLanes[31]
+ #define Ame0 stateAsHalfLanes[32]
+ #define Ame1 stateAsHalfLanes[33]
+ #define Ami0 stateAsHalfLanes[34]
+ #define Ami1 stateAsHalfLanes[35]
+ #define Amo0 stateAsHalfLanes[36]
+ #define Amo1 stateAsHalfLanes[37]
+ #define Amu0 stateAsHalfLanes[38]
+ #define Amu1 stateAsHalfLanes[39]
+ #define Asa0 stateAsHalfLanes[40]
+ #define Asa1 stateAsHalfLanes[41]
+ #define Ase0 stateAsHalfLanes[42]
+ #define Ase1 stateAsHalfLanes[43]
+ #define Asi0 stateAsHalfLanes[44]
+ #define Asi1 stateAsHalfLanes[45]
+ #define Aso0 stateAsHalfLanes[46]
+ #define Aso1 stateAsHalfLanes[47]
+ #define Asu0 stateAsHalfLanes[48]
+ #define Asu1 stateAsHalfLanes[49]
+
+ nRounds &= 3;
+ switch ( nRounds )
+ {
+ #define I0 Ba
+ #define I1 Be
+ #define T0 Bi
+ #define T1 Bo
+ #define SwapPI13( in0,in1,in2,in3,eo0,eo1,eo2,eo3 ) \
+ I0 = (in0)[0]; I1 = (in0)[1]; \
+ T0 = (in1)[0]; T1 = (in1)[1]; \
+ (in0)[eo0] = T0; (in0)[eo0^1] = T1; \
+ T0 = (in2)[0]; T1 = (in2)[1]; \
+ (in1)[eo1] = T0; (in1)[eo1^1] = T1; \
+ T0 = (in3)[0]; T1 = (in3)[1]; \
+ (in2)[eo2] = T0; (in2)[eo2^1] = T1; \
+ (in3)[eo3] = I0; (in3)[eo3^1] = I1
+ #define SwapPI2( in0,in1,in2,in3 ) \
+ I0 = (in0)[0]; I1 = (in0)[1]; \
+ T0 = (in1)[0]; T1 = (in1)[1]; \
+ (in0)[1] = T0; (in0)[0] = T1; \
+ (in1)[1] = I0; (in1)[0] = I1; \
+ I0 = (in2)[0]; I1 = (in2)[1]; \
+ T0 = (in3)[0]; T1 = (in3)[1]; \
+ (in2)[1] = T0; (in2)[0] = T1; \
+ (in3)[1] = I0; (in3)[0] = I1
+ #define SwapEO( even,odd ) T0 = even; even = odd; odd = T0
+
+ case 1:
+ SwapPI13( &Aga0, &Aka0, &Asa0, &Ama0, 1, 0, 1, 0 );
+ SwapPI13( &Abe0, &Age0, &Ame0, &Ake0, 0, 1, 0, 1 );
+ SwapPI13( &Abi0, &Aki0, &Agi0, &Asi0, 1, 0, 1, 0 );
+ SwapEO( Ami0, Ami1 );
+ SwapPI13( &Abo0, &Amo0, &Aso0, &Ago0, 1, 0, 1, 0 );
+ SwapEO( Ako0, Ako1 );
+ SwapPI13( &Abu0, &Asu0, &Aku0, &Amu0, 0, 1, 0, 1 );
+ break;
+
+ case 2:
+ SwapPI2( &Aga0, &Asa0, &Aka0, &Ama0 );
+ SwapPI2( &Abe0, &Ame0, &Age0, &Ake0 );
+ SwapPI2( &Abi0, &Agi0, &Aki0, &Asi0 );
+ SwapPI2( &Abo0, &Aso0, &Ago0, &Amo0 );
+ SwapPI2( &Abu0, &Aku0, &Amu0, &Asu0 );
+ break;
+
+ case 3:
+ SwapPI13( &Aga0, &Ama0, &Asa0, &Aka0, 0, 1, 0, 1 );
+ SwapPI13( &Abe0, &Ake0, &Ame0, &Age0, 1, 0, 1, 0 );
+ SwapPI13( &Abi0, &Asi0, &Agi0, &Aki0, 0, 1, 0, 1 );
+ SwapEO( Ami0, Ami1 );
+ SwapPI13( &Abo0, &Ago0, &Aso0, &Amo0, 0, 1, 0, 1 );
+ SwapEO( Ako0, Ako1 );
+ SwapPI13( &Abu0, &Amu0, &Aku0, &Asu0, 1, 0, 1, 0 );
+ break;
+ #undef I0
+ #undef I1
+ #undef T0
+ #undef T1
+ #undef SwapPI13
+ #undef SwapPI2
+ #undef SwapEO
+ }
+
+ do
+ {
+ /* Code for 4 rounds, using factor 2 interleaving, 64-bit lanes mapped to 32-bit words */
+ switch ( nRounds )
+ {
+ case 0: KeccakRound0(); /* fall through */
+ case 3: KeccakRound1();
+ case 2: KeccakRound2();
+ case 1: KeccakRound3();
+ }
+ nRounds = 0;
+ }
+ while ( *pRoundConstants != 0xFF );
+
+ #undef Aba0
+ #undef Aba1
+ #undef Abe0
+ #undef Abe1
+ #undef Abi0
+ #undef Abi1
+ #undef Abo0
+ #undef Abo1
+ #undef Abu0
+ #undef Abu1
+ #undef Aga0
+ #undef Aga1
+ #undef Age0
+ #undef Age1
+ #undef Agi0
+ #undef Agi1
+ #undef Ago0
+ #undef Ago1
+ #undef Agu0
+ #undef Agu1
+ #undef Aka0
+ #undef Aka1
+ #undef Ake0
+ #undef Ake1
+ #undef Aki0
+ #undef Aki1
+ #undef Ako0
+ #undef Ako1
+ #undef Aku0
+ #undef Aku1
+ #undef Ama0
+ #undef Ama1
+ #undef Ame0
+ #undef Ame1
+ #undef Ami0
+ #undef Ami1
+ #undef Amo0
+ #undef Amo1
+ #undef Amu0
+ #undef Amu1
+ #undef Asa0
+ #undef Asa1
+ #undef Ase0
+ #undef Ase1
+ #undef Asi0
+ #undef Asi1
+ #undef Aso0
+ #undef Aso1
+ #undef Asu0
+ #undef Asu1
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP1600_Permute_12rounds(void *state)
+{
+ KeccakP1600_Permute_Nrounds(state, 12);
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP1600_Permute_24rounds(void *state)
+{
+ KeccakP1600_Permute_Nrounds(state, 24);
+}
diff --git a/node_modules/keccak/src/libkeccak-32/KeccakSponge-common.h b/node_modules/keccak/src/libkeccak-32/KeccakSponge-common.h
new file mode 100644
index 0000000..8fb3ba1
--- /dev/null
+++ b/node_modules/keccak/src/libkeccak-32/KeccakSponge-common.h
@@ -0,0 +1,35 @@
+/*
+Implementation by the Keccak Team, namely, Guido Bertoni, Joan Daemen,
+Michaël Peeters, Gilles Van Assche and Ronny Van Keer,
+hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to our website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#ifndef _KeccakSpongeCommon_h_
+#define _KeccakSpongeCommon_h_
+
+#include
+#include "align.h"
+
+#define KCP_DeclareSpongeStructure(prefix, size, alignment) \
+ ALIGN(alignment) typedef struct prefix##_SpongeInstanceStruct { \
+ unsigned char state[size]; \
+ unsigned int rate; \
+ unsigned int byteIOIndex; \
+ int squeezing; \
+ } prefix##_SpongeInstance;
+
+#define KCP_DeclareSpongeFunctions(prefix) \
+ int prefix##_Sponge(unsigned int rate, unsigned int capacity, const unsigned char *input, size_t inputByteLen, unsigned char suffix, unsigned char *output, size_t outputByteLen); \
+ int prefix##_SpongeInitialize(prefix##_SpongeInstance *spongeInstance, unsigned int rate, unsigned int capacity); \
+ int prefix##_SpongeAbsorb(prefix##_SpongeInstance *spongeInstance, const unsigned char *data, size_t dataByteLen); \
+ int prefix##_SpongeAbsorbLastFewBits(prefix##_SpongeInstance *spongeInstance, unsigned char delimitedData); \
+ int prefix##_SpongeSqueeze(prefix##_SpongeInstance *spongeInstance, unsigned char *data, size_t dataByteLen);
+
+#endif
diff --git a/node_modules/keccak/src/libkeccak-32/KeccakSponge.inc b/node_modules/keccak/src/libkeccak-32/KeccakSponge.inc
new file mode 100644
index 0000000..f6c59ce
--- /dev/null
+++ b/node_modules/keccak/src/libkeccak-32/KeccakSponge.inc
@@ -0,0 +1,311 @@
+/*
+Implementation by the Keccak Team, namely, Guido Bertoni, Joan Daemen,
+Michaël Peeters, Gilles Van Assche and Ronny Van Keer,
+hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to our website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#define JOIN0(a, b) a ## b
+#define JOIN(a, b) JOIN0(a, b)
+
+#define Sponge JOIN(prefix, _Sponge)
+#define SpongeInstance JOIN(prefix, _SpongeInstance)
+#define SpongeInitialize JOIN(prefix, _SpongeInitialize)
+#define SpongeAbsorb JOIN(prefix, _SpongeAbsorb)
+#define SpongeAbsorbLastFewBits JOIN(prefix, _SpongeAbsorbLastFewBits)
+#define SpongeSqueeze JOIN(prefix, _SpongeSqueeze)
+
+#define SnP_stateSizeInBytes JOIN(SnP, _stateSizeInBytes)
+#define SnP_stateAlignment JOIN(SnP, _stateAlignment)
+#define SnP_StaticInitialize JOIN(SnP, _StaticInitialize)
+#define SnP_Initialize JOIN(SnP, _Initialize)
+#define SnP_AddByte JOIN(SnP, _AddByte)
+#define SnP_AddBytes JOIN(SnP, _AddBytes)
+#define SnP_ExtractBytes JOIN(SnP, _ExtractBytes)
+
+int Sponge(unsigned int rate, unsigned int capacity, const unsigned char *input, size_t inputByteLen, unsigned char suffix, unsigned char *output, size_t outputByteLen)
+{
+ ALIGN(SnP_stateAlignment) unsigned char state[SnP_stateSizeInBytes];
+ unsigned int partialBlock;
+ const unsigned char *curInput = input;
+ unsigned char *curOutput = output;
+ unsigned int rateInBytes = rate/8;
+
+ if (rate+capacity != SnP_width)
+ return 1;
+ if ((rate <= 0) || (rate > SnP_width) || ((rate % 8) != 0))
+ return 1;
+ if (suffix == 0)
+ return 1;
+
+ /* Initialize the state */
+ SnP_StaticInitialize();
+ SnP_Initialize(state);
+
+ /* First, absorb whole blocks */
+#ifdef SnP_FastLoop_Absorb
+ if (((rateInBytes % (SnP_width/200)) == 0) && (inputByteLen >= rateInBytes)) {
+ /* fast lane: whole lane rate */
+ size_t j;
+ j = SnP_FastLoop_Absorb(state, rateInBytes/(SnP_width/200), curInput, inputByteLen);
+ curInput += j;
+ inputByteLen -= j;
+ }
+#endif
+ while(inputByteLen >= (size_t)rateInBytes) {
+ #ifdef KeccakReference
+ displayBytes(1, "Block to be absorbed", curInput, rateInBytes);
+ #endif
+ SnP_AddBytes(state, curInput, 0, rateInBytes);
+ SnP_Permute(state);
+ curInput += rateInBytes;
+ inputByteLen -= rateInBytes;
+ }
+
+ /* Then, absorb what remains */
+ partialBlock = (unsigned int)inputByteLen;
+ #ifdef KeccakReference
+ displayBytes(1, "Block to be absorbed (part)", curInput, partialBlock);
+ #endif
+ SnP_AddBytes(state, curInput, 0, partialBlock);
+
+ /* Finally, absorb the suffix */
+ #ifdef KeccakReference
+ {
+ unsigned char delimitedData1[1];
+ delimitedData1[0] = suffix;
+ displayBytes(1, "Block to be absorbed (last few bits + first bit of padding)", delimitedData1, 1);
+ }
+ #endif
+ /* Last few bits, whose delimiter coincides with first bit of padding */
+ SnP_AddByte(state, suffix, partialBlock);
+ /* If the first bit of padding is at position rate-1, we need a whole new block for the second bit of padding */
+ if ((suffix >= 0x80) && (partialBlock == (rateInBytes-1)))
+ SnP_Permute(state);
+ /* Second bit of padding */
+ SnP_AddByte(state, 0x80, rateInBytes-1);
+ #ifdef KeccakReference
+ {
+ unsigned char block[SnP_width/8];
+ memset(block, 0, SnP_width/8);
+ block[rateInBytes-1] = 0x80;
+ displayBytes(1, "Second bit of padding", block, rateInBytes);
+ }
+ #endif
+ SnP_Permute(state);
+ #ifdef KeccakReference
+ displayText(1, "--- Switching to squeezing phase ---");
+ #endif
+
+ /* First, output whole blocks */
+ while(outputByteLen > (size_t)rateInBytes) {
+ SnP_ExtractBytes(state, curOutput, 0, rateInBytes);
+ SnP_Permute(state);
+ #ifdef KeccakReference
+ displayBytes(1, "Squeezed block", curOutput, rateInBytes);
+ #endif
+ curOutput += rateInBytes;
+ outputByteLen -= rateInBytes;
+ }
+
+ /* Finally, output what remains */
+ partialBlock = (unsigned int)outputByteLen;
+ SnP_ExtractBytes(state, curOutput, 0, partialBlock);
+ #ifdef KeccakReference
+ displayBytes(1, "Squeezed block (part)", curOutput, partialBlock);
+ #endif
+
+ return 0;
+}
+
+/* ---------------------------------------------------------------- */
+/* ---------------------------------------------------------------- */
+/* ---------------------------------------------------------------- */
+
+int SpongeInitialize(SpongeInstance *instance, unsigned int rate, unsigned int capacity)
+{
+ if (rate+capacity != SnP_width)
+ return 1;
+ if ((rate <= 0) || (rate > SnP_width) || ((rate % 8) != 0))
+ return 1;
+ SnP_StaticInitialize();
+ SnP_Initialize(instance->state);
+ instance->rate = rate;
+ instance->byteIOIndex = 0;
+ instance->squeezing = 0;
+
+ return 0;
+}
+
+/* ---------------------------------------------------------------- */
+
+int SpongeAbsorb(SpongeInstance *instance, const unsigned char *data, size_t dataByteLen)
+{
+ size_t i, j;
+ unsigned int partialBlock;
+ const unsigned char *curData;
+ unsigned int rateInBytes = instance->rate/8;
+
+ if (instance->squeezing)
+ return 1; /* Too late for additional input */
+
+ i = 0;
+ curData = data;
+ while(i < dataByteLen) {
+ if ((instance->byteIOIndex == 0) && (dataByteLen >= (i + rateInBytes))) {
+#ifdef SnP_FastLoop_Absorb
+ /* processing full blocks first */
+ if ((rateInBytes % (SnP_width/200)) == 0) {
+ /* fast lane: whole lane rate */
+ j = SnP_FastLoop_Absorb(instance->state, rateInBytes/(SnP_width/200), curData, dataByteLen - i);
+ i += j;
+ curData += j;
+ }
+ else {
+#endif
+ for(j=dataByteLen-i; j>=rateInBytes; j-=rateInBytes) {
+ #ifdef KeccakReference
+ displayBytes(1, "Block to be absorbed", curData, rateInBytes);
+ #endif
+ SnP_AddBytes(instance->state, curData, 0, rateInBytes);
+ SnP_Permute(instance->state);
+ curData+=rateInBytes;
+ }
+ i = dataByteLen - j;
+#ifdef SnP_FastLoop_Absorb
+ }
+#endif
+ }
+ else {
+ /* normal lane: using the message queue */
+ partialBlock = (unsigned int)(dataByteLen - i);
+ if (partialBlock+instance->byteIOIndex > rateInBytes)
+ partialBlock = rateInBytes-instance->byteIOIndex;
+ #ifdef KeccakReference
+ displayBytes(1, "Block to be absorbed (part)", curData, partialBlock);
+ #endif
+ i += partialBlock;
+
+ SnP_AddBytes(instance->state, curData, instance->byteIOIndex, partialBlock);
+ curData += partialBlock;
+ instance->byteIOIndex += partialBlock;
+ if (instance->byteIOIndex == rateInBytes) {
+ SnP_Permute(instance->state);
+ instance->byteIOIndex = 0;
+ }
+ }
+ }
+ return 0;
+}
+
+/* ---------------------------------------------------------------- */
+
+int SpongeAbsorbLastFewBits(SpongeInstance *instance, unsigned char delimitedData)
+{
+ unsigned int rateInBytes = instance->rate/8;
+
+ if (delimitedData == 0)
+ return 1;
+ if (instance->squeezing)
+ return 1; /* Too late for additional input */
+
+ #ifdef KeccakReference
+ {
+ unsigned char delimitedData1[1];
+ delimitedData1[0] = delimitedData;
+ displayBytes(1, "Block to be absorbed (last few bits + first bit of padding)", delimitedData1, 1);
+ }
+ #endif
+ /* Last few bits, whose delimiter coincides with first bit of padding */
+ SnP_AddByte(instance->state, delimitedData, instance->byteIOIndex);
+ /* If the first bit of padding is at position rate-1, we need a whole new block for the second bit of padding */
+ if ((delimitedData >= 0x80) && (instance->byteIOIndex == (rateInBytes-1)))
+ SnP_Permute(instance->state);
+ /* Second bit of padding */
+ SnP_AddByte(instance->state, 0x80, rateInBytes-1);
+ #ifdef KeccakReference
+ {
+ unsigned char block[SnP_width/8];
+ memset(block, 0, SnP_width/8);
+ block[rateInBytes-1] = 0x80;
+ displayBytes(1, "Second bit of padding", block, rateInBytes);
+ }
+ #endif
+ SnP_Permute(instance->state);
+ instance->byteIOIndex = 0;
+ instance->squeezing = 1;
+ #ifdef KeccakReference
+ displayText(1, "--- Switching to squeezing phase ---");
+ #endif
+ return 0;
+}
+
+/* ---------------------------------------------------------------- */
+
+int SpongeSqueeze(SpongeInstance *instance, unsigned char *data, size_t dataByteLen)
+{
+ size_t i, j;
+ unsigned int partialBlock;
+ unsigned int rateInBytes = instance->rate/8;
+ unsigned char *curData;
+
+ if (!instance->squeezing)
+ SpongeAbsorbLastFewBits(instance, 0x01);
+
+ i = 0;
+ curData = data;
+ while(i < dataByteLen) {
+ if ((instance->byteIOIndex == rateInBytes) && (dataByteLen >= (i + rateInBytes))) {
+ for(j=dataByteLen-i; j>=rateInBytes; j-=rateInBytes) {
+ SnP_Permute(instance->state);
+ SnP_ExtractBytes(instance->state, curData, 0, rateInBytes);
+ #ifdef KeccakReference
+ displayBytes(1, "Squeezed block", curData, rateInBytes);
+ #endif
+ curData+=rateInBytes;
+ }
+ i = dataByteLen - j;
+ }
+ else {
+ /* normal lane: using the message queue */
+ if (instance->byteIOIndex == rateInBytes) {
+ SnP_Permute(instance->state);
+ instance->byteIOIndex = 0;
+ }
+ partialBlock = (unsigned int)(dataByteLen - i);
+ if (partialBlock+instance->byteIOIndex > rateInBytes)
+ partialBlock = rateInBytes-instance->byteIOIndex;
+ i += partialBlock;
+
+ SnP_ExtractBytes(instance->state, curData, instance->byteIOIndex, partialBlock);
+ #ifdef KeccakReference
+ displayBytes(1, "Squeezed block (part)", curData, partialBlock);
+ #endif
+ curData += partialBlock;
+ instance->byteIOIndex += partialBlock;
+ }
+ }
+ return 0;
+}
+
+/* ---------------------------------------------------------------- */
+
+#undef Sponge
+#undef SpongeInstance
+#undef SpongeInitialize
+#undef SpongeAbsorb
+#undef SpongeAbsorbLastFewBits
+#undef SpongeSqueeze
+#undef SnP_stateSizeInBytes
+#undef SnP_stateAlignment
+#undef SnP_StaticInitialize
+#undef SnP_Initialize
+#undef SnP_AddByte
+#undef SnP_AddBytes
+#undef SnP_ExtractBytes
diff --git a/node_modules/keccak/src/libkeccak-32/KeccakSpongeWidth1600.c b/node_modules/keccak/src/libkeccak-32/KeccakSpongeWidth1600.c
new file mode 100644
index 0000000..672ec36
--- /dev/null
+++ b/node_modules/keccak/src/libkeccak-32/KeccakSpongeWidth1600.c
@@ -0,0 +1,54 @@
+/*
+Implementation by the Keccak Team, namely, Guido Bertoni, Joan Daemen,
+Michaël Peeters, Gilles Van Assche and Ronny Van Keer,
+hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to our website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#include "KeccakSpongeWidth1600.h"
+
+#ifdef KeccakReference
+ #include "displayIntermediateValues.h"
+#endif
+
+#ifndef KeccakP1600_excluded
+ #include "KeccakP-1600-SnP.h"
+
+ #define prefix KeccakWidth1600
+ #define SnP KeccakP1600
+ #define SnP_width 1600
+ #define SnP_Permute KeccakP1600_Permute_24rounds
+ #if defined(KeccakF1600_FastLoop_supported)
+ #define SnP_FastLoop_Absorb KeccakF1600_FastLoop_Absorb
+ #endif
+ #include "KeccakSponge.inc"
+ #undef prefix
+ #undef SnP
+ #undef SnP_width
+ #undef SnP_Permute
+ #undef SnP_FastLoop_Absorb
+#endif
+
+#ifndef KeccakP1600_excluded
+ #include "KeccakP-1600-SnP.h"
+
+ #define prefix KeccakWidth1600_12rounds
+ #define SnP KeccakP1600
+ #define SnP_width 1600
+ #define SnP_Permute KeccakP1600_Permute_12rounds
+ #if defined(KeccakP1600_12rounds_FastLoop_supported)
+ #define SnP_FastLoop_Absorb KeccakP1600_12rounds_FastLoop_Absorb
+ #endif
+ #include "KeccakSponge.inc"
+ #undef prefix
+ #undef SnP
+ #undef SnP_width
+ #undef SnP_Permute
+ #undef SnP_FastLoop_Absorb
+#endif
diff --git a/node_modules/keccak/src/libkeccak-32/KeccakSpongeWidth1600.h b/node_modules/keccak/src/libkeccak-32/KeccakSpongeWidth1600.h
new file mode 100644
index 0000000..1558256
--- /dev/null
+++ b/node_modules/keccak/src/libkeccak-32/KeccakSpongeWidth1600.h
@@ -0,0 +1,31 @@
+/*
+Implementation by the Keccak Team, namely, Guido Bertoni, Joan Daemen,
+Michaël Peeters, Gilles Van Assche and Ronny Van Keer,
+hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to our website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#ifndef _KeccakSpongeWidth1600_h_
+#define _KeccakSpongeWidth1600_h_
+
+#include "KeccakSponge-common.h"
+
+#ifndef KeccakP1600_excluded
+ #include "KeccakP-1600-SnP.h"
+ KCP_DeclareSpongeStructure(KeccakWidth1600, KeccakP1600_stateSizeInBytes, KeccakP1600_stateAlignment)
+ KCP_DeclareSpongeFunctions(KeccakWidth1600)
+#endif
+
+#ifndef KeccakP1600_excluded
+ #include "KeccakP-1600-SnP.h"
+ KCP_DeclareSpongeStructure(KeccakWidth1600_12rounds, KeccakP1600_stateSizeInBytes, KeccakP1600_stateAlignment)
+ KCP_DeclareSpongeFunctions(KeccakWidth1600_12rounds)
+#endif
+
+#endif
diff --git a/node_modules/keccak/src/libkeccak-32/SnP-Relaned.h b/node_modules/keccak/src/libkeccak-32/SnP-Relaned.h
new file mode 100644
index 0000000..8dbf3d2
--- /dev/null
+++ b/node_modules/keccak/src/libkeccak-32/SnP-Relaned.h
@@ -0,0 +1,140 @@
+/*
+Implementation by the Keccak Team, namely, Guido Bertoni, Joan Daemen,
+Michaël Peeters, Gilles Van Assche and Ronny Van Keer,
+hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to our website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+
+---
+
+This file contains macros that help implement a permutation in a SnP-compatible way.
+It converts an implementation that implement state input/output functions
+in a lane-oriented fashion (i.e., using SnP_AddLanes() and SnP_AddBytesInLane,
+and similarly for Overwite, Extract and ExtractAndAdd) to the byte-oriented SnP.
+Please refer to SnP-documentation.h for more details.
+*/
+
+#ifndef _SnP_Relaned_h_
+#define _SnP_Relaned_h_
+
+#define SnP_AddBytes(state, data, offset, length, SnP_AddLanes, SnP_AddBytesInLane, SnP_laneLengthInBytes) \
+ { \
+ if ((offset) == 0) { \
+ SnP_AddLanes(state, data, (length)/SnP_laneLengthInBytes); \
+ SnP_AddBytesInLane(state, \
+ (length)/SnP_laneLengthInBytes, \
+ (data)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
+ 0, \
+ (length)%SnP_laneLengthInBytes); \
+ } \
+ else { \
+ unsigned int _sizeLeft = (length); \
+ unsigned int _lanePosition = (offset)/SnP_laneLengthInBytes; \
+ unsigned int _offsetInLane = (offset)%SnP_laneLengthInBytes; \
+ const unsigned char *_curData = (data); \
+ while(_sizeLeft > 0) { \
+ unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \
+ if (_bytesInLane > _sizeLeft) \
+ _bytesInLane = _sizeLeft; \
+ SnP_AddBytesInLane(state, _lanePosition, _curData, _offsetInLane, _bytesInLane); \
+ _sizeLeft -= _bytesInLane; \
+ _lanePosition++; \
+ _offsetInLane = 0; \
+ _curData += _bytesInLane; \
+ } \
+ } \
+ }
+
+#define SnP_OverwriteBytes(state, data, offset, length, SnP_OverwriteLanes, SnP_OverwriteBytesInLane, SnP_laneLengthInBytes) \
+ { \
+ if ((offset) == 0) { \
+ SnP_OverwriteLanes(state, data, (length)/SnP_laneLengthInBytes); \
+ SnP_OverwriteBytesInLane(state, \
+ (length)/SnP_laneLengthInBytes, \
+ (data)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
+ 0, \
+ (length)%SnP_laneLengthInBytes); \
+ } \
+ else { \
+ unsigned int _sizeLeft = (length); \
+ unsigned int _lanePosition = (offset)/SnP_laneLengthInBytes; \
+ unsigned int _offsetInLane = (offset)%SnP_laneLengthInBytes; \
+ const unsigned char *_curData = (data); \
+ while(_sizeLeft > 0) { \
+ unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \
+ if (_bytesInLane > _sizeLeft) \
+ _bytesInLane = _sizeLeft; \
+ SnP_OverwriteBytesInLane(state, _lanePosition, _curData, _offsetInLane, _bytesInLane); \
+ _sizeLeft -= _bytesInLane; \
+ _lanePosition++; \
+ _offsetInLane = 0; \
+ _curData += _bytesInLane; \
+ } \
+ } \
+ }
+
+#define SnP_ExtractBytes(state, data, offset, length, SnP_ExtractLanes, SnP_ExtractBytesInLane, SnP_laneLengthInBytes) \
+ { \
+ if ((offset) == 0) { \
+ SnP_ExtractLanes(state, data, (length)/SnP_laneLengthInBytes); \
+ SnP_ExtractBytesInLane(state, \
+ (length)/SnP_laneLengthInBytes, \
+ (data)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
+ 0, \
+ (length)%SnP_laneLengthInBytes); \
+ } \
+ else { \
+ unsigned int _sizeLeft = (length); \
+ unsigned int _lanePosition = (offset)/SnP_laneLengthInBytes; \
+ unsigned int _offsetInLane = (offset)%SnP_laneLengthInBytes; \
+ unsigned char *_curData = (data); \
+ while(_sizeLeft > 0) { \
+ unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \
+ if (_bytesInLane > _sizeLeft) \
+ _bytesInLane = _sizeLeft; \
+ SnP_ExtractBytesInLane(state, _lanePosition, _curData, _offsetInLane, _bytesInLane); \
+ _sizeLeft -= _bytesInLane; \
+ _lanePosition++; \
+ _offsetInLane = 0; \
+ _curData += _bytesInLane; \
+ } \
+ } \
+ }
+
+#define SnP_ExtractAndAddBytes(state, input, output, offset, length, SnP_ExtractAndAddLanes, SnP_ExtractAndAddBytesInLane, SnP_laneLengthInBytes) \
+ { \
+ if ((offset) == 0) { \
+ SnP_ExtractAndAddLanes(state, input, output, (length)/SnP_laneLengthInBytes); \
+ SnP_ExtractAndAddBytesInLane(state, \
+ (length)/SnP_laneLengthInBytes, \
+ (input)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
+ (output)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
+ 0, \
+ (length)%SnP_laneLengthInBytes); \
+ } \
+ else { \
+ unsigned int _sizeLeft = (length); \
+ unsigned int _lanePosition = (offset)/SnP_laneLengthInBytes; \
+ unsigned int _offsetInLane = (offset)%SnP_laneLengthInBytes; \
+ const unsigned char *_curInput = (input); \
+ unsigned char *_curOutput = (output); \
+ while(_sizeLeft > 0) { \
+ unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \
+ if (_bytesInLane > _sizeLeft) \
+ _bytesInLane = _sizeLeft; \
+ SnP_ExtractAndAddBytesInLane(state, _lanePosition, _curInput, _curOutput, _offsetInLane, _bytesInLane); \
+ _sizeLeft -= _bytesInLane; \
+ _lanePosition++; \
+ _offsetInLane = 0; \
+ _curInput += _bytesInLane; \
+ _curOutput += _bytesInLane; \
+ } \
+ } \
+ }
+
+#endif
diff --git a/node_modules/keccak/src/libkeccak-32/align.h b/node_modules/keccak/src/libkeccak-32/align.h
new file mode 100644
index 0000000..90c1b37
--- /dev/null
+++ b/node_modules/keccak/src/libkeccak-32/align.h
@@ -0,0 +1,32 @@
+/*
+Implementation by the Keccak Team, namely, Guido Bertoni, Joan Daemen,
+Michaël Peeters, Gilles Van Assche and Ronny Van Keer,
+hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to our website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#ifndef _align_h_
+#define _align_h_
+
+/* on Mac OS-X and possibly others, ALIGN(x) is defined in param.h, and -Werror chokes on the redef. */
+#ifdef ALIGN
+#undef ALIGN
+#endif
+
+#if defined(__GNUC__)
+#define ALIGN(x) __attribute__ ((aligned(x)))
+#elif defined(_MSC_VER)
+#define ALIGN(x) __declspec(align(x))
+#elif defined(__ARMCC_VERSION)
+#define ALIGN(x) __align(x)
+#else
+#define ALIGN(x)
+#endif
+
+#endif
diff --git a/node_modules/keccak/src/libkeccak-32/brg_endian.h b/node_modules/keccak/src/libkeccak-32/brg_endian.h
new file mode 100644
index 0000000..7c640b9
--- /dev/null
+++ b/node_modules/keccak/src/libkeccak-32/brg_endian.h
@@ -0,0 +1,143 @@
+/*
+ ---------------------------------------------------------------------------
+ Copyright (c) 1998-2008, Brian Gladman, Worcester, UK. All rights reserved.
+
+ LICENSE TERMS
+
+ The redistribution and use of this software (with or without changes)
+ is allowed without the payment of fees or royalties provided that:
+
+ 1. source code distributions include the above copyright notice, this
+ list of conditions and the following disclaimer;
+
+ 2. binary distributions include the above copyright notice, this list
+ of conditions and the following disclaimer in their documentation;
+
+ 3. the name of the copyright holder is not used to endorse products
+ built using this software without specific written permission.
+
+ DISCLAIMER
+
+ This software is provided 'as is' with no explicit or implied warranties
+ in respect of its properties, including, but not limited to, correctness
+ and/or fitness for purpose.
+ ---------------------------------------------------------------------------
+ Issue Date: 20/12/2007
+ Changes for ARM 9/9/2010
+*/
+
+#ifndef _BRG_ENDIAN_H
+#define _BRG_ENDIAN_H
+
+#define IS_BIG_ENDIAN 4321 /* byte 0 is most significant (mc68k) */
+#define IS_LITTLE_ENDIAN 1234 /* byte 0 is least significant (i386) */
+
+#if 0
+/* Include files where endian defines and byteswap functions may reside */
+#if defined( __sun )
+# include
+#elif defined( __FreeBSD__ ) || defined( __OpenBSD__ ) || defined( __NetBSD__ )
+# include
+#elif defined( BSD ) && ( BSD >= 199103 ) || defined( __APPLE__ ) || \
+ defined( __CYGWIN32__ ) || defined( __DJGPP__ ) || defined( __osf__ )
+# include
+#elif defined( __linux__ ) || defined( __GNUC__ ) || defined( __GNU_LIBRARY__ )
+# if !defined( __MINGW32__ ) && !defined( _AIX )
+# include
+# if !defined( __BEOS__ )
+# include
+# endif
+# endif
+#endif
+#endif
+
+/* Now attempt to set the define for platform byte order using any */
+/* of the four forms SYMBOL, _SYMBOL, __SYMBOL & __SYMBOL__, which */
+/* seem to encompass most endian symbol definitions */
+
+#if defined( BIG_ENDIAN ) && defined( LITTLE_ENDIAN )
+# if defined( BYTE_ORDER ) && BYTE_ORDER == BIG_ENDIAN
+# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+# elif defined( BYTE_ORDER ) && BYTE_ORDER == LITTLE_ENDIAN
+# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+# endif
+#elif defined( BIG_ENDIAN )
+# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#elif defined( LITTLE_ENDIAN )
+# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#endif
+
+#if defined( _BIG_ENDIAN ) && defined( _LITTLE_ENDIAN )
+# if defined( _BYTE_ORDER ) && _BYTE_ORDER == _BIG_ENDIAN
+# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+# elif defined( _BYTE_ORDER ) && _BYTE_ORDER == _LITTLE_ENDIAN
+# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+# endif
+#elif defined( _BIG_ENDIAN )
+# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#elif defined( _LITTLE_ENDIAN )
+# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#endif
+
+#if defined( __BIG_ENDIAN ) && defined( __LITTLE_ENDIAN )
+# if defined( __BYTE_ORDER ) && __BYTE_ORDER == __BIG_ENDIAN
+# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+# elif defined( __BYTE_ORDER ) && __BYTE_ORDER == __LITTLE_ENDIAN
+# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+# endif
+#elif defined( __BIG_ENDIAN )
+# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#elif defined( __LITTLE_ENDIAN )
+# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#endif
+
+#if defined( __BIG_ENDIAN__ ) && defined( __LITTLE_ENDIAN__ )
+# if defined( __BYTE_ORDER__ ) && __BYTE_ORDER__ == __BIG_ENDIAN__
+# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+# elif defined( __BYTE_ORDER__ ) && __BYTE_ORDER__ == __LITTLE_ENDIAN__
+# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+# endif
+#elif defined( __BIG_ENDIAN__ )
+# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#elif defined( __LITTLE_ENDIAN__ )
+# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#endif
+
+/* if the platform byte order could not be determined, then try to */
+/* set this define using common machine defines */
+#if !defined(PLATFORM_BYTE_ORDER)
+
+#if defined( __alpha__ ) || defined( __alpha ) || defined( i386 ) || \
+ defined( __i386__ ) || defined( _M_I86 ) || defined( _M_IX86 ) || \
+ defined( __OS2__ ) || defined( sun386 ) || defined( __TURBOC__ ) || \
+ defined( vax ) || defined( vms ) || defined( VMS ) || \
+ defined( __VMS ) || defined( _M_X64 )
+# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+
+#elif defined( AMIGA ) || defined( applec ) || defined( __AS400__ ) || \
+ defined( _CRAY ) || defined( __hppa ) || defined( __hp9000 ) || \
+ defined( ibm370 ) || defined( mc68000 ) || defined( m68k ) || \
+ defined( __MRC__ ) || defined( __MVS__ ) || defined( __MWERKS__ ) || \
+ defined( sparc ) || defined( __sparc) || defined( SYMANTEC_C ) || \
+ defined( __VOS__ ) || defined( __TIGCC__ ) || defined( __TANDEM ) || \
+ defined( THINK_C ) || defined( __VMCMS__ ) || defined( _AIX ) || \
+ defined( __s390__ ) || defined( __s390x__ ) || defined( __zarch__ )
+# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+
+#elif defined(__arm__)
+# ifdef __BIG_ENDIAN
+# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+# else
+# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+# endif
+#elif 1 /* **** EDIT HERE IF NECESSARY **** */
+# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#elif 0 /* **** EDIT HERE IF NECESSARY **** */
+# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#else
+# error Please edit lines 132 or 134 in brg_endian.h to set the platform byte order
+#endif
+
+#endif
+
+#endif
diff --git a/node_modules/keccak/src/libkeccak-64/KeccakP-1600-64.macros b/node_modules/keccak/src/libkeccak-64/KeccakP-1600-64.macros
new file mode 100644
index 0000000..60f8054
--- /dev/null
+++ b/node_modules/keccak/src/libkeccak-64/KeccakP-1600-64.macros
@@ -0,0 +1,745 @@
+/*
+Implementation by the Keccak Team, namely, Guido Bertoni, Joan Daemen,
+Michaël Peeters, Gilles Van Assche and Ronny Van Keer,
+hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to our website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#define declareABCDE \
+ UINT64 Aba, Abe, Abi, Abo, Abu; \
+ UINT64 Aga, Age, Agi, Ago, Agu; \
+ UINT64 Aka, Ake, Aki, Ako, Aku; \
+ UINT64 Ama, Ame, Ami, Amo, Amu; \
+ UINT64 Asa, Ase, Asi, Aso, Asu; \
+ UINT64 Bba, Bbe, Bbi, Bbo, Bbu; \
+ UINT64 Bga, Bge, Bgi, Bgo, Bgu; \
+ UINT64 Bka, Bke, Bki, Bko, Bku; \
+ UINT64 Bma, Bme, Bmi, Bmo, Bmu; \
+ UINT64 Bsa, Bse, Bsi, Bso, Bsu; \
+ UINT64 Ca, Ce, Ci, Co, Cu; \
+ UINT64 Da, De, Di, Do, Du; \
+ UINT64 Eba, Ebe, Ebi, Ebo, Ebu; \
+ UINT64 Ega, Ege, Egi, Ego, Egu; \
+ UINT64 Eka, Eke, Eki, Eko, Eku; \
+ UINT64 Ema, Eme, Emi, Emo, Emu; \
+ UINT64 Esa, Ese, Esi, Eso, Esu; \
+
+#define prepareTheta \
+ Ca = Aba^Aga^Aka^Ama^Asa; \
+ Ce = Abe^Age^Ake^Ame^Ase; \
+ Ci = Abi^Agi^Aki^Ami^Asi; \
+ Co = Abo^Ago^Ako^Amo^Aso; \
+ Cu = Abu^Agu^Aku^Amu^Asu; \
+
+#ifdef UseBebigokimisa
+/* --- Code for round, with prepare-theta (lane complementing pattern 'bebigokimisa') */
+/* --- 64-bit lanes mapped to 64-bit words */
+#define thetaRhoPiChiIotaPrepareTheta(i, A, E) \
+ Da = Cu^ROL64(Ce, 1); \
+ De = Ca^ROL64(Ci, 1); \
+ Di = Ce^ROL64(Co, 1); \
+ Do = Ci^ROL64(Cu, 1); \
+ Du = Co^ROL64(Ca, 1); \
+\
+ A##ba ^= Da; \
+ Bba = A##ba; \
+ A##ge ^= De; \
+ Bbe = ROL64(A##ge, 44); \
+ A##ki ^= Di; \
+ Bbi = ROL64(A##ki, 43); \
+ A##mo ^= Do; \
+ Bbo = ROL64(A##mo, 21); \
+ A##su ^= Du; \
+ Bbu = ROL64(A##su, 14); \
+ E##ba = Bba ^( Bbe | Bbi ); \
+ E##ba ^= KeccakF1600RoundConstants[i]; \
+ Ca = E##ba; \
+ E##be = Bbe ^((~Bbi)| Bbo ); \
+ Ce = E##be; \
+ E##bi = Bbi ^( Bbo & Bbu ); \
+ Ci = E##bi; \
+ E##bo = Bbo ^( Bbu | Bba ); \
+ Co = E##bo; \
+ E##bu = Bbu ^( Bba & Bbe ); \
+ Cu = E##bu; \
+\
+ A##bo ^= Do; \
+ Bga = ROL64(A##bo, 28); \
+ A##gu ^= Du; \
+ Bge = ROL64(A##gu, 20); \
+ A##ka ^= Da; \
+ Bgi = ROL64(A##ka, 3); \
+ A##me ^= De; \
+ Bgo = ROL64(A##me, 45); \
+ A##si ^= Di; \
+ Bgu = ROL64(A##si, 61); \
+ E##ga = Bga ^( Bge | Bgi ); \
+ Ca ^= E##ga; \
+ E##ge = Bge ^( Bgi & Bgo ); \
+ Ce ^= E##ge; \
+ E##gi = Bgi ^( Bgo |(~Bgu)); \
+ Ci ^= E##gi; \
+ E##go = Bgo ^( Bgu | Bga ); \
+ Co ^= E##go; \
+ E##gu = Bgu ^( Bga & Bge ); \
+ Cu ^= E##gu; \
+\
+ A##be ^= De; \
+ Bka = ROL64(A##be, 1); \
+ A##gi ^= Di; \
+ Bke = ROL64(A##gi, 6); \
+ A##ko ^= Do; \
+ Bki = ROL64(A##ko, 25); \
+ A##mu ^= Du; \
+ Bko = ROL64(A##mu, 8); \
+ A##sa ^= Da; \
+ Bku = ROL64(A##sa, 18); \
+ E##ka = Bka ^( Bke | Bki ); \
+ Ca ^= E##ka; \
+ E##ke = Bke ^( Bki & Bko ); \
+ Ce ^= E##ke; \
+ E##ki = Bki ^((~Bko)& Bku ); \
+ Ci ^= E##ki; \
+ E##ko = (~Bko)^( Bku | Bka ); \
+ Co ^= E##ko; \
+ E##ku = Bku ^( Bka & Bke ); \
+ Cu ^= E##ku; \
+\
+ A##bu ^= Du; \
+ Bma = ROL64(A##bu, 27); \
+ A##ga ^= Da; \
+ Bme = ROL64(A##ga, 36); \
+ A##ke ^= De; \
+ Bmi = ROL64(A##ke, 10); \
+ A##mi ^= Di; \
+ Bmo = ROL64(A##mi, 15); \
+ A##so ^= Do; \
+ Bmu = ROL64(A##so, 56); \
+ E##ma = Bma ^( Bme & Bmi ); \
+ Ca ^= E##ma; \
+ E##me = Bme ^( Bmi | Bmo ); \
+ Ce ^= E##me; \
+ E##mi = Bmi ^((~Bmo)| Bmu ); \
+ Ci ^= E##mi; \
+ E##mo = (~Bmo)^( Bmu & Bma ); \
+ Co ^= E##mo; \
+ E##mu = Bmu ^( Bma | Bme ); \
+ Cu ^= E##mu; \
+\
+ A##bi ^= Di; \
+ Bsa = ROL64(A##bi, 62); \
+ A##go ^= Do; \
+ Bse = ROL64(A##go, 55); \
+ A##ku ^= Du; \
+ Bsi = ROL64(A##ku, 39); \
+ A##ma ^= Da; \
+ Bso = ROL64(A##ma, 41); \
+ A##se ^= De; \
+ Bsu = ROL64(A##se, 2); \
+ E##sa = Bsa ^((~Bse)& Bsi ); \
+ Ca ^= E##sa; \
+ E##se = (~Bse)^( Bsi | Bso ); \
+ Ce ^= E##se; \
+ E##si = Bsi ^( Bso & Bsu ); \
+ Ci ^= E##si; \
+ E##so = Bso ^( Bsu | Bsa ); \
+ Co ^= E##so; \
+ E##su = Bsu ^( Bsa & Bse ); \
+ Cu ^= E##su; \
+\
+
+/* --- Code for round (lane complementing pattern 'bebigokimisa') */
+/* --- 64-bit lanes mapped to 64-bit words */
+#define thetaRhoPiChiIota(i, A, E) \
+ Da = Cu^ROL64(Ce, 1); \
+ De = Ca^ROL64(Ci, 1); \
+ Di = Ce^ROL64(Co, 1); \
+ Do = Ci^ROL64(Cu, 1); \
+ Du = Co^ROL64(Ca, 1); \
+\
+ A##ba ^= Da; \
+ Bba = A##ba; \
+ A##ge ^= De; \
+ Bbe = ROL64(A##ge, 44); \
+ A##ki ^= Di; \
+ Bbi = ROL64(A##ki, 43); \
+ A##mo ^= Do; \
+ Bbo = ROL64(A##mo, 21); \
+ A##su ^= Du; \
+ Bbu = ROL64(A##su, 14); \
+ E##ba = Bba ^( Bbe | Bbi ); \
+ E##ba ^= KeccakF1600RoundConstants[i]; \
+ E##be = Bbe ^((~Bbi)| Bbo ); \
+ E##bi = Bbi ^( Bbo & Bbu ); \
+ E##bo = Bbo ^( Bbu | Bba ); \
+ E##bu = Bbu ^( Bba & Bbe ); \
+\
+ A##bo ^= Do; \
+ Bga = ROL64(A##bo, 28); \
+ A##gu ^= Du; \
+ Bge = ROL64(A##gu, 20); \
+ A##ka ^= Da; \
+ Bgi = ROL64(A##ka, 3); \
+ A##me ^= De; \
+ Bgo = ROL64(A##me, 45); \
+ A##si ^= Di; \
+ Bgu = ROL64(A##si, 61); \
+ E##ga = Bga ^( Bge | Bgi ); \
+ E##ge = Bge ^( Bgi & Bgo ); \
+ E##gi = Bgi ^( Bgo |(~Bgu)); \
+ E##go = Bgo ^( Bgu | Bga ); \
+ E##gu = Bgu ^( Bga & Bge ); \
+\
+ A##be ^= De; \
+ Bka = ROL64(A##be, 1); \
+ A##gi ^= Di; \
+ Bke = ROL64(A##gi, 6); \
+ A##ko ^= Do; \
+ Bki = ROL64(A##ko, 25); \
+ A##mu ^= Du; \
+ Bko = ROL64(A##mu, 8); \
+ A##sa ^= Da; \
+ Bku = ROL64(A##sa, 18); \
+ E##ka = Bka ^( Bke | Bki ); \
+ E##ke = Bke ^( Bki & Bko ); \
+ E##ki = Bki ^((~Bko)& Bku ); \
+ E##ko = (~Bko)^( Bku | Bka ); \
+ E##ku = Bku ^( Bka & Bke ); \
+\
+ A##bu ^= Du; \
+ Bma = ROL64(A##bu, 27); \
+ A##ga ^= Da; \
+ Bme = ROL64(A##ga, 36); \
+ A##ke ^= De; \
+ Bmi = ROL64(A##ke, 10); \
+ A##mi ^= Di; \
+ Bmo = ROL64(A##mi, 15); \
+ A##so ^= Do; \
+ Bmu = ROL64(A##so, 56); \
+ E##ma = Bma ^( Bme & Bmi ); \
+ E##me = Bme ^( Bmi | Bmo ); \
+ E##mi = Bmi ^((~Bmo)| Bmu ); \
+ E##mo = (~Bmo)^( Bmu & Bma ); \
+ E##mu = Bmu ^( Bma | Bme ); \
+\
+ A##bi ^= Di; \
+ Bsa = ROL64(A##bi, 62); \
+ A##go ^= Do; \
+ Bse = ROL64(A##go, 55); \
+ A##ku ^= Du; \
+ Bsi = ROL64(A##ku, 39); \
+ A##ma ^= Da; \
+ Bso = ROL64(A##ma, 41); \
+ A##se ^= De; \
+ Bsu = ROL64(A##se, 2); \
+ E##sa = Bsa ^((~Bse)& Bsi ); \
+ E##se = (~Bse)^( Bsi | Bso ); \
+ E##si = Bsi ^( Bso & Bsu ); \
+ E##so = Bso ^( Bsu | Bsa ); \
+ E##su = Bsu ^( Bsa & Bse ); \
+\
+
+#else /* UseBebigokimisa */
+/* --- Code for round, with prepare-theta */
+/* --- 64-bit lanes mapped to 64-bit words */
+#define thetaRhoPiChiIotaPrepareTheta(i, A, E) \
+ Da = Cu^ROL64(Ce, 1); \
+ De = Ca^ROL64(Ci, 1); \
+ Di = Ce^ROL64(Co, 1); \
+ Do = Ci^ROL64(Cu, 1); \
+ Du = Co^ROL64(Ca, 1); \
+\
+ A##ba ^= Da; \
+ Bba = A##ba; \
+ A##ge ^= De; \
+ Bbe = ROL64(A##ge, 44); \
+ A##ki ^= Di; \
+ Bbi = ROL64(A##ki, 43); \
+ A##mo ^= Do; \
+ Bbo = ROL64(A##mo, 21); \
+ A##su ^= Du; \
+ Bbu = ROL64(A##su, 14); \
+ E##ba = Bba ^((~Bbe)& Bbi ); \
+ E##ba ^= KeccakF1600RoundConstants[i]; \
+ Ca = E##ba; \
+ E##be = Bbe ^((~Bbi)& Bbo ); \
+ Ce = E##be; \
+ E##bi = Bbi ^((~Bbo)& Bbu ); \
+ Ci = E##bi; \
+ E##bo = Bbo ^((~Bbu)& Bba ); \
+ Co = E##bo; \
+ E##bu = Bbu ^((~Bba)& Bbe ); \
+ Cu = E##bu; \
+\
+ A##bo ^= Do; \
+ Bga = ROL64(A##bo, 28); \
+ A##gu ^= Du; \
+ Bge = ROL64(A##gu, 20); \
+ A##ka ^= Da; \
+ Bgi = ROL64(A##ka, 3); \
+ A##me ^= De; \
+ Bgo = ROL64(A##me, 45); \
+ A##si ^= Di; \
+ Bgu = ROL64(A##si, 61); \
+ E##ga = Bga ^((~Bge)& Bgi ); \
+ Ca ^= E##ga; \
+ E##ge = Bge ^((~Bgi)& Bgo ); \
+ Ce ^= E##ge; \
+ E##gi = Bgi ^((~Bgo)& Bgu ); \
+ Ci ^= E##gi; \
+ E##go = Bgo ^((~Bgu)& Bga ); \
+ Co ^= E##go; \
+ E##gu = Bgu ^((~Bga)& Bge ); \
+ Cu ^= E##gu; \
+\
+ A##be ^= De; \
+ Bka = ROL64(A##be, 1); \
+ A##gi ^= Di; \
+ Bke = ROL64(A##gi, 6); \
+ A##ko ^= Do; \
+ Bki = ROL64(A##ko, 25); \
+ A##mu ^= Du; \
+ Bko = ROL64(A##mu, 8); \
+ A##sa ^= Da; \
+ Bku = ROL64(A##sa, 18); \
+ E##ka = Bka ^((~Bke)& Bki ); \
+ Ca ^= E##ka; \
+ E##ke = Bke ^((~Bki)& Bko ); \
+ Ce ^= E##ke; \
+ E##ki = Bki ^((~Bko)& Bku ); \
+ Ci ^= E##ki; \
+ E##ko = Bko ^((~Bku)& Bka ); \
+ Co ^= E##ko; \
+ E##ku = Bku ^((~Bka)& Bke ); \
+ Cu ^= E##ku; \
+\
+ A##bu ^= Du; \
+ Bma = ROL64(A##bu, 27); \
+ A##ga ^= Da; \
+ Bme = ROL64(A##ga, 36); \
+ A##ke ^= De; \
+ Bmi = ROL64(A##ke, 10); \
+ A##mi ^= Di; \
+ Bmo = ROL64(A##mi, 15); \
+ A##so ^= Do; \
+ Bmu = ROL64(A##so, 56); \
+ E##ma = Bma ^((~Bme)& Bmi ); \
+ Ca ^= E##ma; \
+ E##me = Bme ^((~Bmi)& Bmo ); \
+ Ce ^= E##me; \
+ E##mi = Bmi ^((~Bmo)& Bmu ); \
+ Ci ^= E##mi; \
+ E##mo = Bmo ^((~Bmu)& Bma ); \
+ Co ^= E##mo; \
+ E##mu = Bmu ^((~Bma)& Bme ); \
+ Cu ^= E##mu; \
+\
+ A##bi ^= Di; \
+ Bsa = ROL64(A##bi, 62); \
+ A##go ^= Do; \
+ Bse = ROL64(A##go, 55); \
+ A##ku ^= Du; \
+ Bsi = ROL64(A##ku, 39); \
+ A##ma ^= Da; \
+ Bso = ROL64(A##ma, 41); \
+ A##se ^= De; \
+ Bsu = ROL64(A##se, 2); \
+ E##sa = Bsa ^((~Bse)& Bsi ); \
+ Ca ^= E##sa; \
+ E##se = Bse ^((~Bsi)& Bso ); \
+ Ce ^= E##se; \
+ E##si = Bsi ^((~Bso)& Bsu ); \
+ Ci ^= E##si; \
+ E##so = Bso ^((~Bsu)& Bsa ); \
+ Co ^= E##so; \
+ E##su = Bsu ^((~Bsa)& Bse ); \
+ Cu ^= E##su; \
+\
+
+/* --- Code for round */
+/* --- 64-bit lanes mapped to 64-bit words */
+#define thetaRhoPiChiIota(i, A, E) \
+ Da = Cu^ROL64(Ce, 1); \
+ De = Ca^ROL64(Ci, 1); \
+ Di = Ce^ROL64(Co, 1); \
+ Do = Ci^ROL64(Cu, 1); \
+ Du = Co^ROL64(Ca, 1); \
+\
+ A##ba ^= Da; \
+ Bba = A##ba; \
+ A##ge ^= De; \
+ Bbe = ROL64(A##ge, 44); \
+ A##ki ^= Di; \
+ Bbi = ROL64(A##ki, 43); \
+ A##mo ^= Do; \
+ Bbo = ROL64(A##mo, 21); \
+ A##su ^= Du; \
+ Bbu = ROL64(A##su, 14); \
+ E##ba = Bba ^((~Bbe)& Bbi ); \
+ E##ba ^= KeccakF1600RoundConstants[i]; \
+ E##be = Bbe ^((~Bbi)& Bbo ); \
+ E##bi = Bbi ^((~Bbo)& Bbu ); \
+ E##bo = Bbo ^((~Bbu)& Bba ); \
+ E##bu = Bbu ^((~Bba)& Bbe ); \
+\
+ A##bo ^= Do; \
+ Bga = ROL64(A##bo, 28); \
+ A##gu ^= Du; \
+ Bge = ROL64(A##gu, 20); \
+ A##ka ^= Da; \
+ Bgi = ROL64(A##ka, 3); \
+ A##me ^= De; \
+ Bgo = ROL64(A##me, 45); \
+ A##si ^= Di; \
+ Bgu = ROL64(A##si, 61); \
+ E##ga = Bga ^((~Bge)& Bgi ); \
+ E##ge = Bge ^((~Bgi)& Bgo ); \
+ E##gi = Bgi ^((~Bgo)& Bgu ); \
+ E##go = Bgo ^((~Bgu)& Bga ); \
+ E##gu = Bgu ^((~Bga)& Bge ); \
+\
+ A##be ^= De; \
+ Bka = ROL64(A##be, 1); \
+ A##gi ^= Di; \
+ Bke = ROL64(A##gi, 6); \
+ A##ko ^= Do; \
+ Bki = ROL64(A##ko, 25); \
+ A##mu ^= Du; \
+ Bko = ROL64(A##mu, 8); \
+ A##sa ^= Da; \
+ Bku = ROL64(A##sa, 18); \
+ E##ka = Bka ^((~Bke)& Bki ); \
+ E##ke = Bke ^((~Bki)& Bko ); \
+ E##ki = Bki ^((~Bko)& Bku ); \
+ E##ko = Bko ^((~Bku)& Bka ); \
+ E##ku = Bku ^((~Bka)& Bke ); \
+\
+ A##bu ^= Du; \
+ Bma = ROL64(A##bu, 27); \
+ A##ga ^= Da; \
+ Bme = ROL64(A##ga, 36); \
+ A##ke ^= De; \
+ Bmi = ROL64(A##ke, 10); \
+ A##mi ^= Di; \
+ Bmo = ROL64(A##mi, 15); \
+ A##so ^= Do; \
+ Bmu = ROL64(A##so, 56); \
+ E##ma = Bma ^((~Bme)& Bmi ); \
+ E##me = Bme ^((~Bmi)& Bmo ); \
+ E##mi = Bmi ^((~Bmo)& Bmu ); \
+ E##mo = Bmo ^((~Bmu)& Bma ); \
+ E##mu = Bmu ^((~Bma)& Bme ); \
+\
+ A##bi ^= Di; \
+ Bsa = ROL64(A##bi, 62); \
+ A##go ^= Do; \
+ Bse = ROL64(A##go, 55); \
+ A##ku ^= Du; \
+ Bsi = ROL64(A##ku, 39); \
+ A##ma ^= Da; \
+ Bso = ROL64(A##ma, 41); \
+ A##se ^= De; \
+ Bsu = ROL64(A##se, 2); \
+ E##sa = Bsa ^((~Bse)& Bsi ); \
+ E##se = Bse ^((~Bsi)& Bso ); \
+ E##si = Bsi ^((~Bso)& Bsu ); \
+ E##so = Bso ^((~Bsu)& Bsa ); \
+ E##su = Bsu ^((~Bsa)& Bse ); \
+\
+
+#endif /* UseBebigokimisa */
+
+#define copyFromState(X, state) \
+ X##ba = state[ 0]; \
+ X##be = state[ 1]; \
+ X##bi = state[ 2]; \
+ X##bo = state[ 3]; \
+ X##bu = state[ 4]; \
+ X##ga = state[ 5]; \
+ X##ge = state[ 6]; \
+ X##gi = state[ 7]; \
+ X##go = state[ 8]; \
+ X##gu = state[ 9]; \
+ X##ka = state[10]; \
+ X##ke = state[11]; \
+ X##ki = state[12]; \
+ X##ko = state[13]; \
+ X##ku = state[14]; \
+ X##ma = state[15]; \
+ X##me = state[16]; \
+ X##mi = state[17]; \
+ X##mo = state[18]; \
+ X##mu = state[19]; \
+ X##sa = state[20]; \
+ X##se = state[21]; \
+ X##si = state[22]; \
+ X##so = state[23]; \
+ X##su = state[24]; \
+
+#define copyToState(state, X) \
+ state[ 0] = X##ba; \
+ state[ 1] = X##be; \
+ state[ 2] = X##bi; \
+ state[ 3] = X##bo; \
+ state[ 4] = X##bu; \
+ state[ 5] = X##ga; \
+ state[ 6] = X##ge; \
+ state[ 7] = X##gi; \
+ state[ 8] = X##go; \
+ state[ 9] = X##gu; \
+ state[10] = X##ka; \
+ state[11] = X##ke; \
+ state[12] = X##ki; \
+ state[13] = X##ko; \
+ state[14] = X##ku; \
+ state[15] = X##ma; \
+ state[16] = X##me; \
+ state[17] = X##mi; \
+ state[18] = X##mo; \
+ state[19] = X##mu; \
+ state[20] = X##sa; \
+ state[21] = X##se; \
+ state[22] = X##si; \
+ state[23] = X##so; \
+ state[24] = X##su; \
+
+#define copyStateVariables(X, Y) \
+ X##ba = Y##ba; \
+ X##be = Y##be; \
+ X##bi = Y##bi; \
+ X##bo = Y##bo; \
+ X##bu = Y##bu; \
+ X##ga = Y##ga; \
+ X##ge = Y##ge; \
+ X##gi = Y##gi; \
+ X##go = Y##go; \
+ X##gu = Y##gu; \
+ X##ka = Y##ka; \
+ X##ke = Y##ke; \
+ X##ki = Y##ki; \
+ X##ko = Y##ko; \
+ X##ku = Y##ku; \
+ X##ma = Y##ma; \
+ X##me = Y##me; \
+ X##mi = Y##mi; \
+ X##mo = Y##mo; \
+ X##mu = Y##mu; \
+ X##sa = Y##sa; \
+ X##se = Y##se; \
+ X##si = Y##si; \
+ X##so = Y##so; \
+ X##su = Y##su; \
+
+#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
+#define HTOLE64(x) (x)
+#else
+#define HTOLE64(x) (\
+ ((x & 0xff00000000000000ull) >> 56) | \
+ ((x & 0x00ff000000000000ull) >> 40) | \
+ ((x & 0x0000ff0000000000ull) >> 24) | \
+ ((x & 0x000000ff00000000ull) >> 8) | \
+ ((x & 0x00000000ff000000ull) << 8) | \
+ ((x & 0x0000000000ff0000ull) << 24) | \
+ ((x & 0x000000000000ff00ull) << 40) | \
+ ((x & 0x00000000000000ffull) << 56))
+#endif
+
+#define addInput(X, input, laneCount) \
+ if (laneCount == 21) { \
+ X##ba ^= HTOLE64(input[ 0]); \
+ X##be ^= HTOLE64(input[ 1]); \
+ X##bi ^= HTOLE64(input[ 2]); \
+ X##bo ^= HTOLE64(input[ 3]); \
+ X##bu ^= HTOLE64(input[ 4]); \
+ X##ga ^= HTOLE64(input[ 5]); \
+ X##ge ^= HTOLE64(input[ 6]); \
+ X##gi ^= HTOLE64(input[ 7]); \
+ X##go ^= HTOLE64(input[ 8]); \
+ X##gu ^= HTOLE64(input[ 9]); \
+ X##ka ^= HTOLE64(input[10]); \
+ X##ke ^= HTOLE64(input[11]); \
+ X##ki ^= HTOLE64(input[12]); \
+ X##ko ^= HTOLE64(input[13]); \
+ X##ku ^= HTOLE64(input[14]); \
+ X##ma ^= HTOLE64(input[15]); \
+ X##me ^= HTOLE64(input[16]); \
+ X##mi ^= HTOLE64(input[17]); \
+ X##mo ^= HTOLE64(input[18]); \
+ X##mu ^= HTOLE64(input[19]); \
+ X##sa ^= HTOLE64(input[20]); \
+ } \
+ else if (laneCount < 16) { \
+ if (laneCount < 8) { \
+ if (laneCount < 4) { \
+ if (laneCount < 2) { \
+ if (laneCount < 1) { \
+ } \
+ else { \
+ X##ba ^= HTOLE64(input[ 0]); \
+ } \
+ } \
+ else { \
+ X##ba ^= HTOLE64(input[ 0]); \
+ X##be ^= HTOLE64(input[ 1]); \
+ if (laneCount < 3) { \
+ } \
+ else { \
+ X##bi ^= HTOLE64(input[ 2]); \
+ } \
+ } \
+ } \
+ else { \
+ X##ba ^= HTOLE64(input[ 0]); \
+ X##be ^= HTOLE64(input[ 1]); \
+ X##bi ^= HTOLE64(input[ 2]); \
+ X##bo ^= HTOLE64(input[ 3]); \
+ if (laneCount < 6) { \
+ if (laneCount < 5) { \
+ } \
+ else { \
+ X##bu ^= HTOLE64(input[ 4]); \
+ } \
+ } \
+ else { \
+ X##bu ^= HTOLE64(input[ 4]); \
+ X##ga ^= HTOLE64(input[ 5]); \
+ if (laneCount < 7) { \
+ } \
+ else { \
+ X##ge ^= HTOLE64(input[ 6]); \
+ } \
+ } \
+ } \
+ } \
+ else { \
+ X##ba ^= HTOLE64(input[ 0]); \
+ X##be ^= HTOLE64(input[ 1]); \
+ X##bi ^= HTOLE64(input[ 2]); \
+ X##bo ^= HTOLE64(input[ 3]); \
+ X##bu ^= HTOLE64(input[ 4]); \
+ X##ga ^= HTOLE64(input[ 5]); \
+ X##ge ^= HTOLE64(input[ 6]); \
+ X##gi ^= HTOLE64(input[ 7]); \
+ if (laneCount < 12) { \
+ if (laneCount < 10) { \
+ if (laneCount < 9) { \
+ } \
+ else { \
+ X##go ^= HTOLE64(input[ 8]); \
+ } \
+ } \
+ else { \
+ X##go ^= HTOLE64(input[ 8]); \
+ X##gu ^= HTOLE64(input[ 9]); \
+ if (laneCount < 11) { \
+ } \
+ else { \
+ X##ka ^= HTOLE64(input[10]); \
+ } \
+ } \
+ } \
+ else { \
+ X##go ^= HTOLE64(input[ 8]); \
+ X##gu ^= HTOLE64(input[ 9]); \
+ X##ka ^= HTOLE64(input[10]); \
+ X##ke ^= HTOLE64(input[11]); \
+ if (laneCount < 14) { \
+ if (laneCount < 13) { \
+ } \
+ else { \
+ X##ki ^= HTOLE64(input[12]); \
+ } \
+ } \
+ else { \
+ X##ki ^= HTOLE64(input[12]); \
+ X##ko ^= HTOLE64(input[13]); \
+ if (laneCount < 15) { \
+ } \
+ else { \
+ X##ku ^= HTOLE64(input[14]); \
+ } \
+ } \
+ } \
+ } \
+ } \
+ else { \
+ X##ba ^= HTOLE64(input[ 0]); \
+ X##be ^= HTOLE64(input[ 1]); \
+ X##bi ^= HTOLE64(input[ 2]); \
+ X##bo ^= HTOLE64(input[ 3]); \
+ X##bu ^= HTOLE64(input[ 4]); \
+ X##ga ^= HTOLE64(input[ 5]); \
+ X##ge ^= HTOLE64(input[ 6]); \
+ X##gi ^= HTOLE64(input[ 7]); \
+ X##go ^= HTOLE64(input[ 8]); \
+ X##gu ^= HTOLE64(input[ 9]); \
+ X##ka ^= HTOLE64(input[10]); \
+ X##ke ^= HTOLE64(input[11]); \
+ X##ki ^= HTOLE64(input[12]); \
+ X##ko ^= HTOLE64(input[13]); \
+ X##ku ^= HTOLE64(input[14]); \
+ X##ma ^= HTOLE64(input[15]); \
+ if (laneCount < 24) { \
+ if (laneCount < 20) { \
+ if (laneCount < 18) { \
+ if (laneCount < 17) { \
+ } \
+ else { \
+ X##me ^= HTOLE64(input[16]); \
+ } \
+ } \
+ else { \
+ X##me ^= HTOLE64(input[16]); \
+ X##mi ^= HTOLE64(input[17]); \
+ if (laneCount < 19) { \
+ } \
+ else { \
+ X##mo ^= HTOLE64(input[18]); \
+ } \
+ } \
+ } \
+ else { \
+ X##me ^= HTOLE64(input[16]); \
+ X##mi ^= HTOLE64(input[17]); \
+ X##mo ^= HTOLE64(input[18]); \
+ X##mu ^= HTOLE64(input[19]); \
+ if (laneCount < 22) { \
+ if (laneCount < 21) { \
+ } \
+ else { \
+ X##sa ^= HTOLE64(input[20]); \
+ } \
+ } \
+ else { \
+ X##sa ^= HTOLE64(input[20]); \
+ X##se ^= HTOLE64(input[21]); \
+ if (laneCount < 23) { \
+ } \
+ else { \
+ X##si ^= HTOLE64(input[22]); \
+ } \
+ } \
+ } \
+ } \
+ else { \
+ X##me ^= HTOLE64(input[16]); \
+ X##mi ^= HTOLE64(input[17]); \
+ X##mo ^= HTOLE64(input[18]); \
+ X##mu ^= HTOLE64(input[19]); \
+ X##sa ^= HTOLE64(input[20]); \
+ X##se ^= HTOLE64(input[21]); \
+ X##si ^= HTOLE64(input[22]); \
+ X##so ^= HTOLE64(input[23]); \
+ if (laneCount < 25) { \
+ } \
+ else { \
+ X##su ^= HTOLE64(input[24]); \
+ } \
+ } \
+ }
diff --git a/node_modules/keccak/src/libkeccak-64/KeccakP-1600-SnP.h b/node_modules/keccak/src/libkeccak-64/KeccakP-1600-SnP.h
new file mode 100644
index 0000000..8335ae3
--- /dev/null
+++ b/node_modules/keccak/src/libkeccak-64/KeccakP-1600-SnP.h
@@ -0,0 +1,51 @@
+/*
+Implementation by the Keccak Team, namely, Guido Bertoni, Joan Daemen,
+Michaël Peeters, Gilles Van Assche and Ronny Van Keer,
+hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to our website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+
+---
+
+Please refer to SnP-documentation.h for more details.
+*/
+
+#ifndef _KeccakP_1600_SnP_h_
+#define _KeccakP_1600_SnP_h_
+
+#include "brg_endian.h"
+#include "KeccakP-1600-opt64-config.h"
+
+#define KeccakP1600_implementation "generic 64-bit optimized implementation (" KeccakP1600_implementation_config ")"
+#define KeccakP1600_stateSizeInBytes 200
+#define KeccakP1600_stateAlignment 8
+#define KeccakF1600_FastLoop_supported
+#define KeccakP1600_12rounds_FastLoop_supported
+
+#include
+
+#define KeccakP1600_StaticInitialize()
+void KeccakP1600_Initialize(void *state);
+#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
+#define KeccakP1600_AddByte(state, byte, offset) \
+ ((unsigned char*)(state))[(offset)] ^= (byte)
+#else
+void KeccakP1600_AddByte(void *state, unsigned char data, unsigned int offset);
+#endif
+void KeccakP1600_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length);
+void KeccakP1600_OverwriteBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length);
+void KeccakP1600_OverwriteWithZeroes(void *state, unsigned int byteCount);
+void KeccakP1600_Permute_Nrounds(void *state, unsigned int nrounds);
+void KeccakP1600_Permute_12rounds(void *state);
+void KeccakP1600_Permute_24rounds(void *state);
+void KeccakP1600_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length);
+void KeccakP1600_ExtractAndAddBytes(const void *state, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length);
+size_t KeccakF1600_FastLoop_Absorb(void *state, unsigned int laneCount, const unsigned char *data, size_t dataByteLen);
+size_t KeccakP1600_12rounds_FastLoop_Absorb(void *state, unsigned int laneCount, const unsigned char *data, size_t dataByteLen);
+
+#endif
diff --git a/node_modules/keccak/src/libkeccak-64/KeccakP-1600-opt64-config.h b/node_modules/keccak/src/libkeccak-64/KeccakP-1600-opt64-config.h
new file mode 100644
index 0000000..085b6c9
--- /dev/null
+++ b/node_modules/keccak/src/libkeccak-64/KeccakP-1600-opt64-config.h
@@ -0,0 +1,6 @@
+/*
+This file defines some parameters of the implementation in the parent directory.
+*/
+
+#define KeccakP1600_implementation_config "all rounds unrolled"
+#define KeccakP1600_fullUnrolling
diff --git a/node_modules/keccak/src/libkeccak-64/KeccakP-1600-opt64.c b/node_modules/keccak/src/libkeccak-64/KeccakP-1600-opt64.c
new file mode 100644
index 0000000..97e3ea6
--- /dev/null
+++ b/node_modules/keccak/src/libkeccak-64/KeccakP-1600-opt64.c
@@ -0,0 +1,564 @@
+/*
+Implementation by the Keccak Team, namely, Guido Bertoni, Joan Daemen,
+Michaël Peeters, Gilles Van Assche and Ronny Van Keer,
+hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to our website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+
+---
+
+This file implements Keccak-p[1600] in a SnP-compatible way.
+Please refer to SnP-documentation.h for more details.
+
+This implementation comes with KeccakP-1600-SnP.h in the same folder.
+Please refer to LowLevel.build for the exact list of other files it must be combined with.
+*/
+
+#include
+#include
+#include "brg_endian.h"
+#include "KeccakP-1600-opt64-config.h"
+
+typedef unsigned char UINT8;
+typedef unsigned long long int UINT64;
+
+#if defined(KeccakP1600_useLaneComplementing)
+#define UseBebigokimisa
+#endif
+
+#if defined(_MSC_VER)
+#define ROL64(a, offset) _rotl64(a, offset)
+#elif defined(KeccakP1600_useSHLD)
+ #define ROL64(x,N) ({ \
+ register UINT64 __out; \
+ register UINT64 __in = x; \
+ __asm__ ("shld %2,%0,%0" : "=r"(__out) : "0"(__in), "i"(N)); \
+ __out; \
+ })
+#else
+#define ROL64(a, offset) ((((UINT64)a) << offset) ^ (((UINT64)a) >> (64-offset)))
+#endif
+
+#include "KeccakP-1600-64.macros"
+#ifdef KeccakP1600_fullUnrolling
+#define FullUnrolling
+#else
+#define Unrolling KeccakP1600_unrolling
+#endif
+#include "KeccakP-1600-unrolling.macros"
+#include "SnP-Relaned.h"
+
+static const UINT64 KeccakF1600RoundConstants[24] = {
+ 0x0000000000000001ULL,
+ 0x0000000000008082ULL,
+ 0x800000000000808aULL,
+ 0x8000000080008000ULL,
+ 0x000000000000808bULL,
+ 0x0000000080000001ULL,
+ 0x8000000080008081ULL,
+ 0x8000000000008009ULL,
+ 0x000000000000008aULL,
+ 0x0000000000000088ULL,
+ 0x0000000080008009ULL,
+ 0x000000008000000aULL,
+ 0x000000008000808bULL,
+ 0x800000000000008bULL,
+ 0x8000000000008089ULL,
+ 0x8000000000008003ULL,
+ 0x8000000000008002ULL,
+ 0x8000000000000080ULL,
+ 0x000000000000800aULL,
+ 0x800000008000000aULL,
+ 0x8000000080008081ULL,
+ 0x8000000000008080ULL,
+ 0x0000000080000001ULL,
+ 0x8000000080008008ULL };
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP1600_Initialize(void *state)
+{
+ memset(state, 0, 200);
+#ifdef KeccakP1600_useLaneComplementing
+ ((UINT64*)state)[ 1] = ~(UINT64)0;
+ ((UINT64*)state)[ 2] = ~(UINT64)0;
+ ((UINT64*)state)[ 8] = ~(UINT64)0;
+ ((UINT64*)state)[12] = ~(UINT64)0;
+ ((UINT64*)state)[17] = ~(UINT64)0;
+ ((UINT64*)state)[20] = ~(UINT64)0;
+#endif
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP1600_AddBytesInLane(void *state, unsigned int lanePosition, const unsigned char *data, unsigned int offset, unsigned int length)
+{
+#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
+ UINT64 lane;
+ if (length == 0)
+ return;
+ if (length == 1)
+ lane = data[0];
+ else {
+ lane = 0;
+ memcpy(&lane, data, length);
+ }
+ lane <<= offset*8;
+#else
+ UINT64 lane = 0;
+ unsigned int i;
+ for(i=0; i>= offset*8;
+ for(i=0; i>= 8;
+ }
+#endif
+}
+
+/* ---------------------------------------------------------------- */
+
+#if (PLATFORM_BYTE_ORDER != IS_LITTLE_ENDIAN)
+static void fromWordToBytes(UINT8 *bytes, const UINT64 word)
+{
+ unsigned int i;
+
+ for(i=0; i<(64/8); i++)
+ bytes[i] = (word >> (8*i)) & 0xFF;
+}
+#endif
+
+void KeccakP1600_ExtractLanes(const void *state, unsigned char *data, unsigned int laneCount)
+{
+#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
+ memcpy(data, state, laneCount*8);
+#else
+ unsigned int i;
+
+ for(i=0; i 1) {
+ ((UINT64*)data)[ 1] = ~((UINT64*)data)[ 1];
+ if (laneCount > 2) {
+ ((UINT64*)data)[ 2] = ~((UINT64*)data)[ 2];
+ if (laneCount > 8) {
+ ((UINT64*)data)[ 8] = ~((UINT64*)data)[ 8];
+ if (laneCount > 12) {
+ ((UINT64*)data)[12] = ~((UINT64*)data)[12];
+ if (laneCount > 17) {
+ ((UINT64*)data)[17] = ~((UINT64*)data)[17];
+ if (laneCount > 20) {
+ ((UINT64*)data)[20] = ~((UINT64*)data)[20];
+ }
+ }
+ }
+ }
+ }
+ }
+#endif
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP1600_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length)
+{
+ SnP_ExtractBytes(state, data, offset, length, KeccakP1600_ExtractLanes, KeccakP1600_ExtractBytesInLane, 8);
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP1600_ExtractAndAddBytesInLane(const void *state, unsigned int lanePosition, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
+{
+ UINT64 lane = ((UINT64*)state)[lanePosition];
+#ifdef KeccakP1600_useLaneComplementing
+ if ((lanePosition == 1) || (lanePosition == 2) || (lanePosition == 8) || (lanePosition == 12) || (lanePosition == 17) || (lanePosition == 20))
+ lane = ~lane;
+#endif
+#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
+ {
+ unsigned int i;
+ UINT64 lane1[1];
+ lane1[0] = lane;
+ for(i=0; i>= offset*8;
+ for(i=0; i>= 8;
+ }
+#endif
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP1600_ExtractAndAddLanes(const void *state, const unsigned char *input, unsigned char *output, unsigned int laneCount)
+{
+ unsigned int i;
+#if (PLATFORM_BYTE_ORDER != IS_LITTLE_ENDIAN)
+ unsigned char temp[8];
+ unsigned int j;
+#endif
+
+ for(i=0; i 1) {
+ ((UINT64*)output)[ 1] = ~((UINT64*)output)[ 1];
+ if (laneCount > 2) {
+ ((UINT64*)output)[ 2] = ~((UINT64*)output)[ 2];
+ if (laneCount > 8) {
+ ((UINT64*)output)[ 8] = ~((UINT64*)output)[ 8];
+ if (laneCount > 12) {
+ ((UINT64*)output)[12] = ~((UINT64*)output)[12];
+ if (laneCount > 17) {
+ ((UINT64*)output)[17] = ~((UINT64*)output)[17];
+ if (laneCount > 20) {
+ ((UINT64*)output)[20] = ~((UINT64*)output)[20];
+ }
+ }
+ }
+ }
+ }
+ }
+#endif
+}
+
+/* ---------------------------------------------------------------- */
+
+void KeccakP1600_ExtractAndAddBytes(const void *state, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
+{
+ SnP_ExtractAndAddBytes(state, input, output, offset, length, KeccakP1600_ExtractAndAddLanes, KeccakP1600_ExtractAndAddBytesInLane, 8);
+}
+
+/* ---------------------------------------------------------------- */
+
+size_t KeccakF1600_FastLoop_Absorb(void *state, unsigned int laneCount, const unsigned char *data, size_t dataByteLen)
+{
+ size_t originalDataByteLen = dataByteLen;
+ declareABCDE
+ #ifndef KeccakP1600_fullUnrolling
+ unsigned int i;
+ #endif
+ UINT64 *stateAsLanes = (UINT64*)state;
+ UINT64 *inDataAsLanes = (UINT64*)data;
+
+ copyFromState(A, stateAsLanes)
+ while(dataByteLen >= laneCount*8) {
+ addInput(A, inDataAsLanes, laneCount)
+ rounds24
+ inDataAsLanes += laneCount;
+ dataByteLen -= laneCount*8;
+ }
+ copyToState(stateAsLanes, A)
+ return originalDataByteLen - dataByteLen;
+}
+
+/* ---------------------------------------------------------------- */
+
+size_t KeccakP1600_12rounds_FastLoop_Absorb(void *state, unsigned int laneCount, const unsigned char *data, size_t dataByteLen)
+{
+ size_t originalDataByteLen = dataByteLen;
+ declareABCDE
+ #ifndef KeccakP1600_fullUnrolling
+ unsigned int i;
+ #endif
+ UINT64 *stateAsLanes = (UINT64*)state;
+ UINT64 *inDataAsLanes = (UINT64*)data;
+
+ copyFromState(A, stateAsLanes)
+ while(dataByteLen >= laneCount*8) {
+ addInput(A, inDataAsLanes, laneCount)
+ rounds12
+ inDataAsLanes += laneCount;
+ dataByteLen -= laneCount*8;
+ }
+ copyToState(stateAsLanes, A)
+ return originalDataByteLen - dataByteLen;
+}
diff --git a/node_modules/keccak/src/libkeccak-64/KeccakP-1600-unrolling.macros b/node_modules/keccak/src/libkeccak-64/KeccakP-1600-unrolling.macros
new file mode 100644
index 0000000..197e9b0
--- /dev/null
+++ b/node_modules/keccak/src/libkeccak-64/KeccakP-1600-unrolling.macros
@@ -0,0 +1,302 @@
+/*
+Implementation by the Keccak Team, namely, Guido Bertoni, Joan Daemen,
+Michaël Peeters, Gilles Van Assche and Ronny Van Keer,
+hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to our website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#if (defined(FullUnrolling))
+#define rounds24 \
+ prepareTheta \
+ thetaRhoPiChiIotaPrepareTheta( 0, A, E) \
+ thetaRhoPiChiIotaPrepareTheta( 1, E, A) \
+ thetaRhoPiChiIotaPrepareTheta( 2, A, E) \
+ thetaRhoPiChiIotaPrepareTheta( 3, E, A) \
+ thetaRhoPiChiIotaPrepareTheta( 4, A, E) \
+ thetaRhoPiChiIotaPrepareTheta( 5, E, A) \
+ thetaRhoPiChiIotaPrepareTheta( 6, A, E) \
+ thetaRhoPiChiIotaPrepareTheta( 7, E, A) \
+ thetaRhoPiChiIotaPrepareTheta( 8, A, E) \
+ thetaRhoPiChiIotaPrepareTheta( 9, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(10, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(11, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(12, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(13, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(14, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(15, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(16, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(17, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(18, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(19, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(20, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(21, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(22, A, E) \
+ thetaRhoPiChiIota(23, E, A) \
+
+#define rounds12 \
+ prepareTheta \
+ thetaRhoPiChiIotaPrepareTheta(12, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(13, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(14, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(15, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(16, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(17, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(18, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(19, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(20, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(21, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(22, A, E) \
+ thetaRhoPiChiIota(23, E, A) \
+
+#define rounds6 \
+ prepareTheta \
+ thetaRhoPiChiIotaPrepareTheta(18, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(19, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(20, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(21, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(22, A, E) \
+ thetaRhoPiChiIota(23, E, A) \
+
+#define rounds4 \
+ prepareTheta \
+ thetaRhoPiChiIotaPrepareTheta(20, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(21, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(22, A, E) \
+ thetaRhoPiChiIota(23, E, A) \
+
+#elif (Unrolling == 12)
+#define rounds24 \
+ prepareTheta \
+ for(i=0; i<24; i+=12) { \
+ thetaRhoPiChiIotaPrepareTheta(i , A, E) \
+ thetaRhoPiChiIotaPrepareTheta(i+ 1, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(i+ 2, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(i+ 3, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(i+ 4, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(i+ 5, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(i+ 6, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(i+ 7, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(i+ 8, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(i+ 9, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(i+10, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(i+11, E, A) \
+ } \
+
+#define rounds12 \
+ prepareTheta \
+ thetaRhoPiChiIotaPrepareTheta(12, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(13, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(14, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(15, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(16, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(17, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(18, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(19, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(20, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(21, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(22, A, E) \
+ thetaRhoPiChiIota(23, E, A) \
+
+#define rounds6 \
+ prepareTheta \
+ thetaRhoPiChiIotaPrepareTheta(18, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(19, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(20, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(21, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(22, A, E) \
+ thetaRhoPiChiIota(23, E, A) \
+
+#define rounds4 \
+ prepareTheta \
+ thetaRhoPiChiIotaPrepareTheta(20, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(21, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(22, A, E) \
+ thetaRhoPiChiIota(23, E, A) \
+
+#elif (Unrolling == 6)
+#define rounds24 \
+ prepareTheta \
+ for(i=0; i<24; i+=6) { \
+ thetaRhoPiChiIotaPrepareTheta(i , A, E) \
+ thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(i+2, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(i+3, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(i+4, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(i+5, E, A) \
+ } \
+
+#define rounds12 \
+ prepareTheta \
+ for(i=12; i<24; i+=6) { \
+ thetaRhoPiChiIotaPrepareTheta(i , A, E) \
+ thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(i+2, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(i+3, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(i+4, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(i+5, E, A) \
+ } \
+
+#define rounds6 \
+ prepareTheta \
+ thetaRhoPiChiIotaPrepareTheta(18, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(19, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(20, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(21, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(22, A, E) \
+ thetaRhoPiChiIota(23, E, A) \
+
+#define rounds4 \
+ prepareTheta \
+ thetaRhoPiChiIotaPrepareTheta(20, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(21, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(22, A, E) \
+ thetaRhoPiChiIota(23, E, A) \
+
+#elif (Unrolling == 4)
+#define rounds24 \
+ prepareTheta \
+ for(i=0; i<24; i+=4) { \
+ thetaRhoPiChiIotaPrepareTheta(i , A, E) \
+ thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(i+2, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(i+3, E, A) \
+ } \
+
+#define rounds12 \
+ prepareTheta \
+ for(i=12; i<24; i+=4) { \
+ thetaRhoPiChiIotaPrepareTheta(i , A, E) \
+ thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(i+2, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(i+3, E, A) \
+ } \
+
+#define rounds6 \
+ prepareTheta \
+ for(i=18; i<24; i+=2) { \
+ thetaRhoPiChiIotaPrepareTheta(i , A, E) \
+ thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
+ } \
+
+#define rounds4 \
+ prepareTheta \
+ thetaRhoPiChiIotaPrepareTheta(20, A, E) \
+ thetaRhoPiChiIotaPrepareTheta(21, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(22, A, E) \
+ thetaRhoPiChiIota(23, E, A) \
+
+#elif (Unrolling == 3)
+#define rounds24 \
+ prepareTheta \
+ for(i=0; i<24; i+=3) { \
+ thetaRhoPiChiIotaPrepareTheta(i , A, E) \
+ thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(i+2, A, E) \
+ copyStateVariables(A, E) \
+ } \
+
+#define rounds12 \
+ prepareTheta \
+ for(i=12; i<24; i+=3) { \
+ thetaRhoPiChiIotaPrepareTheta(i , A, E) \
+ thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(i+2, A, E) \
+ copyStateVariables(A, E) \
+ } \
+
+#define rounds6 \
+ prepareTheta \
+ for(i=18; i<24; i+=3) { \
+ thetaRhoPiChiIotaPrepareTheta(i , A, E) \
+ thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
+ thetaRhoPiChiIotaPrepareTheta(i+2, A, E) \
+ copyStateVariables(A, E) \
+ } \
+
+#define rounds4 \
+ prepareTheta \
+ for(i=20; i<24; i+=2) { \
+ thetaRhoPiChiIotaPrepareTheta(i , A, E) \
+ thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
+ } \
+
+#elif (Unrolling == 2)
+#define rounds24 \
+ prepareTheta \
+ for(i=0; i<24; i+=2) { \
+ thetaRhoPiChiIotaPrepareTheta(i , A, E) \
+ thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
+ } \
+
+#define rounds12 \
+ prepareTheta \
+ for(i=12; i<24; i+=2) { \
+ thetaRhoPiChiIotaPrepareTheta(i , A, E) \
+ thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
+ } \
+
+#define rounds6 \
+ prepareTheta \
+ for(i=18; i<24; i+=2) { \
+ thetaRhoPiChiIotaPrepareTheta(i , A, E) \
+ thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
+ } \
+
+#define rounds4 \
+ prepareTheta \
+ for(i=20; i<24; i+=2) { \
+ thetaRhoPiChiIotaPrepareTheta(i , A, E) \
+ thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
+ } \
+
+#elif (Unrolling == 1)
+#define rounds24 \
+ prepareTheta \
+ for(i=0; i<24; i++) { \
+ thetaRhoPiChiIotaPrepareTheta(i , A, E) \
+ copyStateVariables(A, E) \
+ } \
+
+#define rounds12 \
+ prepareTheta \
+ for(i=12; i<24; i++) { \
+ thetaRhoPiChiIotaPrepareTheta(i , A, E) \
+ copyStateVariables(A, E) \
+ } \
+
+#define rounds6 \
+ prepareTheta \
+ for(i=18; i<24; i++) { \
+ thetaRhoPiChiIotaPrepareTheta(i , A, E) \
+ copyStateVariables(A, E) \
+ } \
+
+#define rounds4 \
+ prepareTheta \
+ for(i=20; i<24; i++) { \
+ thetaRhoPiChiIotaPrepareTheta(i , A, E) \
+ copyStateVariables(A, E) \
+ } \
+
+#else
+#error "Unrolling is not correctly specified!"
+#endif
+
+#define roundsN(__nrounds) \
+ prepareTheta \
+ i = 24 - (__nrounds); \
+ if ((i&1) != 0) { \
+ thetaRhoPiChiIotaPrepareTheta(i, A, E) \
+ copyStateVariables(A, E) \
+ ++i; \
+ } \
+ for( /* empty */; i<24; i+=2) { \
+ thetaRhoPiChiIotaPrepareTheta(i , A, E) \
+ thetaRhoPiChiIotaPrepareTheta(i+1, E, A) \
+ }
diff --git a/node_modules/keccak/src/libkeccak-64/KeccakSponge-common.h b/node_modules/keccak/src/libkeccak-64/KeccakSponge-common.h
new file mode 100644
index 0000000..8fb3ba1
--- /dev/null
+++ b/node_modules/keccak/src/libkeccak-64/KeccakSponge-common.h
@@ -0,0 +1,35 @@
+/*
+Implementation by the Keccak Team, namely, Guido Bertoni, Joan Daemen,
+Michaël Peeters, Gilles Van Assche and Ronny Van Keer,
+hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to our website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#ifndef _KeccakSpongeCommon_h_
+#define _KeccakSpongeCommon_h_
+
+#include
+#include "align.h"
+
+#define KCP_DeclareSpongeStructure(prefix, size, alignment) \
+ ALIGN(alignment) typedef struct prefix##_SpongeInstanceStruct { \
+ unsigned char state[size]; \
+ unsigned int rate; \
+ unsigned int byteIOIndex; \
+ int squeezing; \
+ } prefix##_SpongeInstance;
+
+#define KCP_DeclareSpongeFunctions(prefix) \
+ int prefix##_Sponge(unsigned int rate, unsigned int capacity, const unsigned char *input, size_t inputByteLen, unsigned char suffix, unsigned char *output, size_t outputByteLen); \
+ int prefix##_SpongeInitialize(prefix##_SpongeInstance *spongeInstance, unsigned int rate, unsigned int capacity); \
+ int prefix##_SpongeAbsorb(prefix##_SpongeInstance *spongeInstance, const unsigned char *data, size_t dataByteLen); \
+ int prefix##_SpongeAbsorbLastFewBits(prefix##_SpongeInstance *spongeInstance, unsigned char delimitedData); \
+ int prefix##_SpongeSqueeze(prefix##_SpongeInstance *spongeInstance, unsigned char *data, size_t dataByteLen);
+
+#endif
diff --git a/node_modules/keccak/src/libkeccak-64/KeccakSponge.inc b/node_modules/keccak/src/libkeccak-64/KeccakSponge.inc
new file mode 100644
index 0000000..f6c59ce
--- /dev/null
+++ b/node_modules/keccak/src/libkeccak-64/KeccakSponge.inc
@@ -0,0 +1,311 @@
+/*
+Implementation by the Keccak Team, namely, Guido Bertoni, Joan Daemen,
+Michaël Peeters, Gilles Van Assche and Ronny Van Keer,
+hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to our website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#define JOIN0(a, b) a ## b
+#define JOIN(a, b) JOIN0(a, b)
+
+#define Sponge JOIN(prefix, _Sponge)
+#define SpongeInstance JOIN(prefix, _SpongeInstance)
+#define SpongeInitialize JOIN(prefix, _SpongeInitialize)
+#define SpongeAbsorb JOIN(prefix, _SpongeAbsorb)
+#define SpongeAbsorbLastFewBits JOIN(prefix, _SpongeAbsorbLastFewBits)
+#define SpongeSqueeze JOIN(prefix, _SpongeSqueeze)
+
+#define SnP_stateSizeInBytes JOIN(SnP, _stateSizeInBytes)
+#define SnP_stateAlignment JOIN(SnP, _stateAlignment)
+#define SnP_StaticInitialize JOIN(SnP, _StaticInitialize)
+#define SnP_Initialize JOIN(SnP, _Initialize)
+#define SnP_AddByte JOIN(SnP, _AddByte)
+#define SnP_AddBytes JOIN(SnP, _AddBytes)
+#define SnP_ExtractBytes JOIN(SnP, _ExtractBytes)
+
+int Sponge(unsigned int rate, unsigned int capacity, const unsigned char *input, size_t inputByteLen, unsigned char suffix, unsigned char *output, size_t outputByteLen)
+{
+ ALIGN(SnP_stateAlignment) unsigned char state[SnP_stateSizeInBytes];
+ unsigned int partialBlock;
+ const unsigned char *curInput = input;
+ unsigned char *curOutput = output;
+ unsigned int rateInBytes = rate/8;
+
+ if (rate+capacity != SnP_width)
+ return 1;
+ if ((rate <= 0) || (rate > SnP_width) || ((rate % 8) != 0))
+ return 1;
+ if (suffix == 0)
+ return 1;
+
+ /* Initialize the state */
+ SnP_StaticInitialize();
+ SnP_Initialize(state);
+
+ /* First, absorb whole blocks */
+#ifdef SnP_FastLoop_Absorb
+ if (((rateInBytes % (SnP_width/200)) == 0) && (inputByteLen >= rateInBytes)) {
+ /* fast lane: whole lane rate */
+ size_t j;
+ j = SnP_FastLoop_Absorb(state, rateInBytes/(SnP_width/200), curInput, inputByteLen);
+ curInput += j;
+ inputByteLen -= j;
+ }
+#endif
+ while(inputByteLen >= (size_t)rateInBytes) {
+ #ifdef KeccakReference
+ displayBytes(1, "Block to be absorbed", curInput, rateInBytes);
+ #endif
+ SnP_AddBytes(state, curInput, 0, rateInBytes);
+ SnP_Permute(state);
+ curInput += rateInBytes;
+ inputByteLen -= rateInBytes;
+ }
+
+ /* Then, absorb what remains */
+ partialBlock = (unsigned int)inputByteLen;
+ #ifdef KeccakReference
+ displayBytes(1, "Block to be absorbed (part)", curInput, partialBlock);
+ #endif
+ SnP_AddBytes(state, curInput, 0, partialBlock);
+
+ /* Finally, absorb the suffix */
+ #ifdef KeccakReference
+ {
+ unsigned char delimitedData1[1];
+ delimitedData1[0] = suffix;
+ displayBytes(1, "Block to be absorbed (last few bits + first bit of padding)", delimitedData1, 1);
+ }
+ #endif
+ /* Last few bits, whose delimiter coincides with first bit of padding */
+ SnP_AddByte(state, suffix, partialBlock);
+ /* If the first bit of padding is at position rate-1, we need a whole new block for the second bit of padding */
+ if ((suffix >= 0x80) && (partialBlock == (rateInBytes-1)))
+ SnP_Permute(state);
+ /* Second bit of padding */
+ SnP_AddByte(state, 0x80, rateInBytes-1);
+ #ifdef KeccakReference
+ {
+ unsigned char block[SnP_width/8];
+ memset(block, 0, SnP_width/8);
+ block[rateInBytes-1] = 0x80;
+ displayBytes(1, "Second bit of padding", block, rateInBytes);
+ }
+ #endif
+ SnP_Permute(state);
+ #ifdef KeccakReference
+ displayText(1, "--- Switching to squeezing phase ---");
+ #endif
+
+ /* First, output whole blocks */
+ while(outputByteLen > (size_t)rateInBytes) {
+ SnP_ExtractBytes(state, curOutput, 0, rateInBytes);
+ SnP_Permute(state);
+ #ifdef KeccakReference
+ displayBytes(1, "Squeezed block", curOutput, rateInBytes);
+ #endif
+ curOutput += rateInBytes;
+ outputByteLen -= rateInBytes;
+ }
+
+ /* Finally, output what remains */
+ partialBlock = (unsigned int)outputByteLen;
+ SnP_ExtractBytes(state, curOutput, 0, partialBlock);
+ #ifdef KeccakReference
+ displayBytes(1, "Squeezed block (part)", curOutput, partialBlock);
+ #endif
+
+ return 0;
+}
+
+/* ---------------------------------------------------------------- */
+/* ---------------------------------------------------------------- */
+/* ---------------------------------------------------------------- */
+
+int SpongeInitialize(SpongeInstance *instance, unsigned int rate, unsigned int capacity)
+{
+ if (rate+capacity != SnP_width)
+ return 1;
+ if ((rate <= 0) || (rate > SnP_width) || ((rate % 8) != 0))
+ return 1;
+ SnP_StaticInitialize();
+ SnP_Initialize(instance->state);
+ instance->rate = rate;
+ instance->byteIOIndex = 0;
+ instance->squeezing = 0;
+
+ return 0;
+}
+
+/* ---------------------------------------------------------------- */
+
+int SpongeAbsorb(SpongeInstance *instance, const unsigned char *data, size_t dataByteLen)
+{
+ size_t i, j;
+ unsigned int partialBlock;
+ const unsigned char *curData;
+ unsigned int rateInBytes = instance->rate/8;
+
+ if (instance->squeezing)
+ return 1; /* Too late for additional input */
+
+ i = 0;
+ curData = data;
+ while(i < dataByteLen) {
+ if ((instance->byteIOIndex == 0) && (dataByteLen >= (i + rateInBytes))) {
+#ifdef SnP_FastLoop_Absorb
+ /* processing full blocks first */
+ if ((rateInBytes % (SnP_width/200)) == 0) {
+ /* fast lane: whole lane rate */
+ j = SnP_FastLoop_Absorb(instance->state, rateInBytes/(SnP_width/200), curData, dataByteLen - i);
+ i += j;
+ curData += j;
+ }
+ else {
+#endif
+ for(j=dataByteLen-i; j>=rateInBytes; j-=rateInBytes) {
+ #ifdef KeccakReference
+ displayBytes(1, "Block to be absorbed", curData, rateInBytes);
+ #endif
+ SnP_AddBytes(instance->state, curData, 0, rateInBytes);
+ SnP_Permute(instance->state);
+ curData+=rateInBytes;
+ }
+ i = dataByteLen - j;
+#ifdef SnP_FastLoop_Absorb
+ }
+#endif
+ }
+ else {
+ /* normal lane: using the message queue */
+ partialBlock = (unsigned int)(dataByteLen - i);
+ if (partialBlock+instance->byteIOIndex > rateInBytes)
+ partialBlock = rateInBytes-instance->byteIOIndex;
+ #ifdef KeccakReference
+ displayBytes(1, "Block to be absorbed (part)", curData, partialBlock);
+ #endif
+ i += partialBlock;
+
+ SnP_AddBytes(instance->state, curData, instance->byteIOIndex, partialBlock);
+ curData += partialBlock;
+ instance->byteIOIndex += partialBlock;
+ if (instance->byteIOIndex == rateInBytes) {
+ SnP_Permute(instance->state);
+ instance->byteIOIndex = 0;
+ }
+ }
+ }
+ return 0;
+}
+
+/* ---------------------------------------------------------------- */
+
+int SpongeAbsorbLastFewBits(SpongeInstance *instance, unsigned char delimitedData)
+{
+ unsigned int rateInBytes = instance->rate/8;
+
+ if (delimitedData == 0)
+ return 1;
+ if (instance->squeezing)
+ return 1; /* Too late for additional input */
+
+ #ifdef KeccakReference
+ {
+ unsigned char delimitedData1[1];
+ delimitedData1[0] = delimitedData;
+ displayBytes(1, "Block to be absorbed (last few bits + first bit of padding)", delimitedData1, 1);
+ }
+ #endif
+ /* Last few bits, whose delimiter coincides with first bit of padding */
+ SnP_AddByte(instance->state, delimitedData, instance->byteIOIndex);
+ /* If the first bit of padding is at position rate-1, we need a whole new block for the second bit of padding */
+ if ((delimitedData >= 0x80) && (instance->byteIOIndex == (rateInBytes-1)))
+ SnP_Permute(instance->state);
+ /* Second bit of padding */
+ SnP_AddByte(instance->state, 0x80, rateInBytes-1);
+ #ifdef KeccakReference
+ {
+ unsigned char block[SnP_width/8];
+ memset(block, 0, SnP_width/8);
+ block[rateInBytes-1] = 0x80;
+ displayBytes(1, "Second bit of padding", block, rateInBytes);
+ }
+ #endif
+ SnP_Permute(instance->state);
+ instance->byteIOIndex = 0;
+ instance->squeezing = 1;
+ #ifdef KeccakReference
+ displayText(1, "--- Switching to squeezing phase ---");
+ #endif
+ return 0;
+}
+
+/* ---------------------------------------------------------------- */
+
+int SpongeSqueeze(SpongeInstance *instance, unsigned char *data, size_t dataByteLen)
+{
+ size_t i, j;
+ unsigned int partialBlock;
+ unsigned int rateInBytes = instance->rate/8;
+ unsigned char *curData;
+
+ if (!instance->squeezing)
+ SpongeAbsorbLastFewBits(instance, 0x01);
+
+ i = 0;
+ curData = data;
+ while(i < dataByteLen) {
+ if ((instance->byteIOIndex == rateInBytes) && (dataByteLen >= (i + rateInBytes))) {
+ for(j=dataByteLen-i; j>=rateInBytes; j-=rateInBytes) {
+ SnP_Permute(instance->state);
+ SnP_ExtractBytes(instance->state, curData, 0, rateInBytes);
+ #ifdef KeccakReference
+ displayBytes(1, "Squeezed block", curData, rateInBytes);
+ #endif
+ curData+=rateInBytes;
+ }
+ i = dataByteLen - j;
+ }
+ else {
+ /* normal lane: using the message queue */
+ if (instance->byteIOIndex == rateInBytes) {
+ SnP_Permute(instance->state);
+ instance->byteIOIndex = 0;
+ }
+ partialBlock = (unsigned int)(dataByteLen - i);
+ if (partialBlock+instance->byteIOIndex > rateInBytes)
+ partialBlock = rateInBytes-instance->byteIOIndex;
+ i += partialBlock;
+
+ SnP_ExtractBytes(instance->state, curData, instance->byteIOIndex, partialBlock);
+ #ifdef KeccakReference
+ displayBytes(1, "Squeezed block (part)", curData, partialBlock);
+ #endif
+ curData += partialBlock;
+ instance->byteIOIndex += partialBlock;
+ }
+ }
+ return 0;
+}
+
+/* ---------------------------------------------------------------- */
+
+#undef Sponge
+#undef SpongeInstance
+#undef SpongeInitialize
+#undef SpongeAbsorb
+#undef SpongeAbsorbLastFewBits
+#undef SpongeSqueeze
+#undef SnP_stateSizeInBytes
+#undef SnP_stateAlignment
+#undef SnP_StaticInitialize
+#undef SnP_Initialize
+#undef SnP_AddByte
+#undef SnP_AddBytes
+#undef SnP_ExtractBytes
diff --git a/node_modules/keccak/src/libkeccak-64/KeccakSpongeWidth1600.c b/node_modules/keccak/src/libkeccak-64/KeccakSpongeWidth1600.c
new file mode 100644
index 0000000..672ec36
--- /dev/null
+++ b/node_modules/keccak/src/libkeccak-64/KeccakSpongeWidth1600.c
@@ -0,0 +1,54 @@
+/*
+Implementation by the Keccak Team, namely, Guido Bertoni, Joan Daemen,
+Michaël Peeters, Gilles Van Assche and Ronny Van Keer,
+hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to our website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#include "KeccakSpongeWidth1600.h"
+
+#ifdef KeccakReference
+ #include "displayIntermediateValues.h"
+#endif
+
+#ifndef KeccakP1600_excluded
+ #include "KeccakP-1600-SnP.h"
+
+ #define prefix KeccakWidth1600
+ #define SnP KeccakP1600
+ #define SnP_width 1600
+ #define SnP_Permute KeccakP1600_Permute_24rounds
+ #if defined(KeccakF1600_FastLoop_supported)
+ #define SnP_FastLoop_Absorb KeccakF1600_FastLoop_Absorb
+ #endif
+ #include "KeccakSponge.inc"
+ #undef prefix
+ #undef SnP
+ #undef SnP_width
+ #undef SnP_Permute
+ #undef SnP_FastLoop_Absorb
+#endif
+
+#ifndef KeccakP1600_excluded
+ #include "KeccakP-1600-SnP.h"
+
+ #define prefix KeccakWidth1600_12rounds
+ #define SnP KeccakP1600
+ #define SnP_width 1600
+ #define SnP_Permute KeccakP1600_Permute_12rounds
+ #if defined(KeccakP1600_12rounds_FastLoop_supported)
+ #define SnP_FastLoop_Absorb KeccakP1600_12rounds_FastLoop_Absorb
+ #endif
+ #include "KeccakSponge.inc"
+ #undef prefix
+ #undef SnP
+ #undef SnP_width
+ #undef SnP_Permute
+ #undef SnP_FastLoop_Absorb
+#endif
diff --git a/node_modules/keccak/src/libkeccak-64/KeccakSpongeWidth1600.h b/node_modules/keccak/src/libkeccak-64/KeccakSpongeWidth1600.h
new file mode 100644
index 0000000..1558256
--- /dev/null
+++ b/node_modules/keccak/src/libkeccak-64/KeccakSpongeWidth1600.h
@@ -0,0 +1,31 @@
+/*
+Implementation by the Keccak Team, namely, Guido Bertoni, Joan Daemen,
+Michaël Peeters, Gilles Van Assche and Ronny Van Keer,
+hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to our website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#ifndef _KeccakSpongeWidth1600_h_
+#define _KeccakSpongeWidth1600_h_
+
+#include "KeccakSponge-common.h"
+
+#ifndef KeccakP1600_excluded
+ #include "KeccakP-1600-SnP.h"
+ KCP_DeclareSpongeStructure(KeccakWidth1600, KeccakP1600_stateSizeInBytes, KeccakP1600_stateAlignment)
+ KCP_DeclareSpongeFunctions(KeccakWidth1600)
+#endif
+
+#ifndef KeccakP1600_excluded
+ #include "KeccakP-1600-SnP.h"
+ KCP_DeclareSpongeStructure(KeccakWidth1600_12rounds, KeccakP1600_stateSizeInBytes, KeccakP1600_stateAlignment)
+ KCP_DeclareSpongeFunctions(KeccakWidth1600_12rounds)
+#endif
+
+#endif
diff --git a/node_modules/keccak/src/libkeccak-64/SnP-Relaned.h b/node_modules/keccak/src/libkeccak-64/SnP-Relaned.h
new file mode 100644
index 0000000..8dbf3d2
--- /dev/null
+++ b/node_modules/keccak/src/libkeccak-64/SnP-Relaned.h
@@ -0,0 +1,140 @@
+/*
+Implementation by the Keccak Team, namely, Guido Bertoni, Joan Daemen,
+Michaël Peeters, Gilles Van Assche and Ronny Van Keer,
+hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to our website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+
+---
+
+This file contains macros that help implement a permutation in a SnP-compatible way.
+It converts an implementation that implement state input/output functions
+in a lane-oriented fashion (i.e., using SnP_AddLanes() and SnP_AddBytesInLane,
+and similarly for Overwite, Extract and ExtractAndAdd) to the byte-oriented SnP.
+Please refer to SnP-documentation.h for more details.
+*/
+
+#ifndef _SnP_Relaned_h_
+#define _SnP_Relaned_h_
+
+#define SnP_AddBytes(state, data, offset, length, SnP_AddLanes, SnP_AddBytesInLane, SnP_laneLengthInBytes) \
+ { \
+ if ((offset) == 0) { \
+ SnP_AddLanes(state, data, (length)/SnP_laneLengthInBytes); \
+ SnP_AddBytesInLane(state, \
+ (length)/SnP_laneLengthInBytes, \
+ (data)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
+ 0, \
+ (length)%SnP_laneLengthInBytes); \
+ } \
+ else { \
+ unsigned int _sizeLeft = (length); \
+ unsigned int _lanePosition = (offset)/SnP_laneLengthInBytes; \
+ unsigned int _offsetInLane = (offset)%SnP_laneLengthInBytes; \
+ const unsigned char *_curData = (data); \
+ while(_sizeLeft > 0) { \
+ unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \
+ if (_bytesInLane > _sizeLeft) \
+ _bytesInLane = _sizeLeft; \
+ SnP_AddBytesInLane(state, _lanePosition, _curData, _offsetInLane, _bytesInLane); \
+ _sizeLeft -= _bytesInLane; \
+ _lanePosition++; \
+ _offsetInLane = 0; \
+ _curData += _bytesInLane; \
+ } \
+ } \
+ }
+
+#define SnP_OverwriteBytes(state, data, offset, length, SnP_OverwriteLanes, SnP_OverwriteBytesInLane, SnP_laneLengthInBytes) \
+ { \
+ if ((offset) == 0) { \
+ SnP_OverwriteLanes(state, data, (length)/SnP_laneLengthInBytes); \
+ SnP_OverwriteBytesInLane(state, \
+ (length)/SnP_laneLengthInBytes, \
+ (data)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
+ 0, \
+ (length)%SnP_laneLengthInBytes); \
+ } \
+ else { \
+ unsigned int _sizeLeft = (length); \
+ unsigned int _lanePosition = (offset)/SnP_laneLengthInBytes; \
+ unsigned int _offsetInLane = (offset)%SnP_laneLengthInBytes; \
+ const unsigned char *_curData = (data); \
+ while(_sizeLeft > 0) { \
+ unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \
+ if (_bytesInLane > _sizeLeft) \
+ _bytesInLane = _sizeLeft; \
+ SnP_OverwriteBytesInLane(state, _lanePosition, _curData, _offsetInLane, _bytesInLane); \
+ _sizeLeft -= _bytesInLane; \
+ _lanePosition++; \
+ _offsetInLane = 0; \
+ _curData += _bytesInLane; \
+ } \
+ } \
+ }
+
+#define SnP_ExtractBytes(state, data, offset, length, SnP_ExtractLanes, SnP_ExtractBytesInLane, SnP_laneLengthInBytes) \
+ { \
+ if ((offset) == 0) { \
+ SnP_ExtractLanes(state, data, (length)/SnP_laneLengthInBytes); \
+ SnP_ExtractBytesInLane(state, \
+ (length)/SnP_laneLengthInBytes, \
+ (data)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
+ 0, \
+ (length)%SnP_laneLengthInBytes); \
+ } \
+ else { \
+ unsigned int _sizeLeft = (length); \
+ unsigned int _lanePosition = (offset)/SnP_laneLengthInBytes; \
+ unsigned int _offsetInLane = (offset)%SnP_laneLengthInBytes; \
+ unsigned char *_curData = (data); \
+ while(_sizeLeft > 0) { \
+ unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \
+ if (_bytesInLane > _sizeLeft) \
+ _bytesInLane = _sizeLeft; \
+ SnP_ExtractBytesInLane(state, _lanePosition, _curData, _offsetInLane, _bytesInLane); \
+ _sizeLeft -= _bytesInLane; \
+ _lanePosition++; \
+ _offsetInLane = 0; \
+ _curData += _bytesInLane; \
+ } \
+ } \
+ }
+
+#define SnP_ExtractAndAddBytes(state, input, output, offset, length, SnP_ExtractAndAddLanes, SnP_ExtractAndAddBytesInLane, SnP_laneLengthInBytes) \
+ { \
+ if ((offset) == 0) { \
+ SnP_ExtractAndAddLanes(state, input, output, (length)/SnP_laneLengthInBytes); \
+ SnP_ExtractAndAddBytesInLane(state, \
+ (length)/SnP_laneLengthInBytes, \
+ (input)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
+ (output)+((length)/SnP_laneLengthInBytes)*SnP_laneLengthInBytes, \
+ 0, \
+ (length)%SnP_laneLengthInBytes); \
+ } \
+ else { \
+ unsigned int _sizeLeft = (length); \
+ unsigned int _lanePosition = (offset)/SnP_laneLengthInBytes; \
+ unsigned int _offsetInLane = (offset)%SnP_laneLengthInBytes; \
+ const unsigned char *_curInput = (input); \
+ unsigned char *_curOutput = (output); \
+ while(_sizeLeft > 0) { \
+ unsigned int _bytesInLane = SnP_laneLengthInBytes - _offsetInLane; \
+ if (_bytesInLane > _sizeLeft) \
+ _bytesInLane = _sizeLeft; \
+ SnP_ExtractAndAddBytesInLane(state, _lanePosition, _curInput, _curOutput, _offsetInLane, _bytesInLane); \
+ _sizeLeft -= _bytesInLane; \
+ _lanePosition++; \
+ _offsetInLane = 0; \
+ _curInput += _bytesInLane; \
+ _curOutput += _bytesInLane; \
+ } \
+ } \
+ }
+
+#endif
diff --git a/node_modules/keccak/src/libkeccak-64/align.h b/node_modules/keccak/src/libkeccak-64/align.h
new file mode 100644
index 0000000..90c1b37
--- /dev/null
+++ b/node_modules/keccak/src/libkeccak-64/align.h
@@ -0,0 +1,32 @@
+/*
+Implementation by the Keccak Team, namely, Guido Bertoni, Joan Daemen,
+Michaël Peeters, Gilles Van Assche and Ronny Van Keer,
+hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to our website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#ifndef _align_h_
+#define _align_h_
+
+/* on Mac OS-X and possibly others, ALIGN(x) is defined in param.h, and -Werror chokes on the redef. */
+#ifdef ALIGN
+#undef ALIGN
+#endif
+
+#if defined(__GNUC__)
+#define ALIGN(x) __attribute__ ((aligned(x)))
+#elif defined(_MSC_VER)
+#define ALIGN(x) __declspec(align(x))
+#elif defined(__ARMCC_VERSION)
+#define ALIGN(x) __align(x)
+#else
+#define ALIGN(x)
+#endif
+
+#endif
diff --git a/node_modules/keccak/src/libkeccak-64/brg_endian.h b/node_modules/keccak/src/libkeccak-64/brg_endian.h
new file mode 100644
index 0000000..7c640b9
--- /dev/null
+++ b/node_modules/keccak/src/libkeccak-64/brg_endian.h
@@ -0,0 +1,143 @@
+/*
+ ---------------------------------------------------------------------------
+ Copyright (c) 1998-2008, Brian Gladman, Worcester, UK. All rights reserved.
+
+ LICENSE TERMS
+
+ The redistribution and use of this software (with or without changes)
+ is allowed without the payment of fees or royalties provided that:
+
+ 1. source code distributions include the above copyright notice, this
+ list of conditions and the following disclaimer;
+
+ 2. binary distributions include the above copyright notice, this list
+ of conditions and the following disclaimer in their documentation;
+
+ 3. the name of the copyright holder is not used to endorse products
+ built using this software without specific written permission.
+
+ DISCLAIMER
+
+ This software is provided 'as is' with no explicit or implied warranties
+ in respect of its properties, including, but not limited to, correctness
+ and/or fitness for purpose.
+ ---------------------------------------------------------------------------
+ Issue Date: 20/12/2007
+ Changes for ARM 9/9/2010
+*/
+
+#ifndef _BRG_ENDIAN_H
+#define _BRG_ENDIAN_H
+
+#define IS_BIG_ENDIAN 4321 /* byte 0 is most significant (mc68k) */
+#define IS_LITTLE_ENDIAN 1234 /* byte 0 is least significant (i386) */
+
+#if 0
+/* Include files where endian defines and byteswap functions may reside */
+#if defined( __sun )
+# include
+#elif defined( __FreeBSD__ ) || defined( __OpenBSD__ ) || defined( __NetBSD__ )
+# include
+#elif defined( BSD ) && ( BSD >= 199103 ) || defined( __APPLE__ ) || \
+ defined( __CYGWIN32__ ) || defined( __DJGPP__ ) || defined( __osf__ )
+# include
+#elif defined( __linux__ ) || defined( __GNUC__ ) || defined( __GNU_LIBRARY__ )
+# if !defined( __MINGW32__ ) && !defined( _AIX )
+# include
+# if !defined( __BEOS__ )
+# include
+# endif
+# endif
+#endif
+#endif
+
+/* Now attempt to set the define for platform byte order using any */
+/* of the four forms SYMBOL, _SYMBOL, __SYMBOL & __SYMBOL__, which */
+/* seem to encompass most endian symbol definitions */
+
+#if defined( BIG_ENDIAN ) && defined( LITTLE_ENDIAN )
+# if defined( BYTE_ORDER ) && BYTE_ORDER == BIG_ENDIAN
+# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+# elif defined( BYTE_ORDER ) && BYTE_ORDER == LITTLE_ENDIAN
+# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+# endif
+#elif defined( BIG_ENDIAN )
+# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#elif defined( LITTLE_ENDIAN )
+# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#endif
+
+#if defined( _BIG_ENDIAN ) && defined( _LITTLE_ENDIAN )
+# if defined( _BYTE_ORDER ) && _BYTE_ORDER == _BIG_ENDIAN
+# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+# elif defined( _BYTE_ORDER ) && _BYTE_ORDER == _LITTLE_ENDIAN
+# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+# endif
+#elif defined( _BIG_ENDIAN )
+# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#elif defined( _LITTLE_ENDIAN )
+# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#endif
+
+#if defined( __BIG_ENDIAN ) && defined( __LITTLE_ENDIAN )
+# if defined( __BYTE_ORDER ) && __BYTE_ORDER == __BIG_ENDIAN
+# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+# elif defined( __BYTE_ORDER ) && __BYTE_ORDER == __LITTLE_ENDIAN
+# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+# endif
+#elif defined( __BIG_ENDIAN )
+# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#elif defined( __LITTLE_ENDIAN )
+# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#endif
+
+#if defined( __BIG_ENDIAN__ ) && defined( __LITTLE_ENDIAN__ )
+# if defined( __BYTE_ORDER__ ) && __BYTE_ORDER__ == __BIG_ENDIAN__
+# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+# elif defined( __BYTE_ORDER__ ) && __BYTE_ORDER__ == __LITTLE_ENDIAN__
+# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+# endif
+#elif defined( __BIG_ENDIAN__ )
+# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#elif defined( __LITTLE_ENDIAN__ )
+# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#endif
+
+/* if the platform byte order could not be determined, then try to */
+/* set this define using common machine defines */
+#if !defined(PLATFORM_BYTE_ORDER)
+
+#if defined( __alpha__ ) || defined( __alpha ) || defined( i386 ) || \
+ defined( __i386__ ) || defined( _M_I86 ) || defined( _M_IX86 ) || \
+ defined( __OS2__ ) || defined( sun386 ) || defined( __TURBOC__ ) || \
+ defined( vax ) || defined( vms ) || defined( VMS ) || \
+ defined( __VMS ) || defined( _M_X64 )
+# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+
+#elif defined( AMIGA ) || defined( applec ) || defined( __AS400__ ) || \
+ defined( _CRAY ) || defined( __hppa ) || defined( __hp9000 ) || \
+ defined( ibm370 ) || defined( mc68000 ) || defined( m68k ) || \
+ defined( __MRC__ ) || defined( __MVS__ ) || defined( __MWERKS__ ) || \
+ defined( sparc ) || defined( __sparc) || defined( SYMANTEC_C ) || \
+ defined( __VOS__ ) || defined( __TIGCC__ ) || defined( __TANDEM ) || \
+ defined( THINK_C ) || defined( __VMCMS__ ) || defined( _AIX ) || \
+ defined( __s390__ ) || defined( __s390x__ ) || defined( __zarch__ )
+# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+
+#elif defined(__arm__)
+# ifdef __BIG_ENDIAN
+# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+# else
+# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+# endif
+#elif 1 /* **** EDIT HERE IF NECESSARY **** */
+# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#elif 0 /* **** EDIT HERE IF NECESSARY **** */
+# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#else
+# error Please edit lines 132 or 134 in brg_endian.h to set the platform byte order
+#endif
+
+#endif
+
+#endif
diff --git a/node_modules/nan/CHANGELOG.md b/node_modules/nan/CHANGELOG.md
new file mode 100644
index 0000000..93d9496
--- /dev/null
+++ b/node_modules/nan/CHANGELOG.md
@@ -0,0 +1,537 @@
+# NAN ChangeLog
+
+**Version 2.14.2: current Node 14.13.1, Node 0.12: 0.12.18, Node 0.10: 0.10.48, iojs: 3.3.1**
+
+### 2.14.2 Oct 13 2020
+
+ - Bugfix: fix gcc 8 function cast warning (#899) 35f0fab205574b2cbda04e6347c8b2db755e124f
+
+### 2.14.1 Apr 21 2020
+
+ - Bugfix: use GetBackingStore() instead of GetContents() (#888) 2c023bd447661a61071da318b0ff4003c3858d39
+
+### 2.14.0 May 16 2019
+
+ - Feature: Add missing methods to Nan::Maybe (#852) 4e962489fb84a184035b9fa74f245f650249aca6
+
+### 2.13.2 Mar 24 2019
+
+ - Bugfix: remove usage of deprecated `IsNearDeath` (#842) fbaf42252af279c3d867c6b193571f9711c39847
+
+### 2.13.1 Mar 14 2019
+
+ - Bugfix: check V8 version directly instead of inferring from NMV (#840) 12f9df9f393285de8fb4a8cd01478dc4fe3b089d
+
+### 2.13.0 Mar 13 2019
+
+ - Feature: add support for node master (#831) 113c0282072e7ff4f9dfc98b432fd894b798c2c
+
+### 2.12.1 Dec 18 2018
+
+ - Bugfix: Fix build breakage with Node.js 10.0.0-10.9.0. (#833) 625e90e8fef8d39ffa7247250a76a100b2487474
+
+### 2.12.0 Dec 16 2018
+
+ - Bugfix: Add scope.Escape() to Call() (#817) 2e5ed4fc3a8ac80a6ef1f2a55099ab3ac8800dc6
+ - Bugfix: Fix Node.js v10.12.0 deprecation warnings. 509859cc23b1770376b56550a027840a2ce0f73d
+ - Feature: Allow SetWeak() for non-object persistent handles. (#824) e6ef6a48e7e671fe3e4b7dddaa8912a3f8262ecd
+
+### 2.11.1 Sep 29 2018
+
+ - Fix: adapt to V8 7.0 24a22c3b25eeeec2016c6ec239bdd6169e985447
+
+### 2.11.0 Aug 25 2018
+
+ - Removal: remove `FunctionCallbackInfo::Callee` for nodejs `>= 10` 1a56c0a6efd4fac944cb46c30912a8e023bda7d4
+ - Bugfix: Fix `AsyncProgressWorkerBase::WorkProgress` sends invalid data b0c764d1dab11e9f8b37ffb81e2560a4498aad5e
+ - Feature: Introduce `GetCurrentEventLoop` b4911b0bb1f6d47d860e10ec014d941c51efac5e
+ - Feature: Add `NAN_MODULE_WORKER_ENABLED` macro as a replacement for `NAN_MODULE` b058fb047d18a58250e66ae831444441c1f2ac7a
+
+### 2.10.0 Mar 16 2018
+
+ - Deprecation: Deprecate `MakeCallback` 5e92b19a59e194241d6a658bd6ff7bfbda372950
+ - Feature: add `Nan::Call` overload 4482e1242fe124d166fc1a5b2be3c1cc849fe452
+ - Feature: add more `Nan::Call` overloads 8584e63e6d04c7d2eb8c4a664e4ef57d70bf672b
+ - Feature: Fix deprecation warnings for Node 10 1caf258243b0602ed56922bde74f1c91b0cbcb6a
+
+### 2.9.2 Feb 22 2018
+
+ - Bugfix: Bandaid for async hooks 212bd2f849be14ef1b02fc85010b053daa24252b
+
+### 2.9.1 Feb 22 2018
+
+ - Bugfix: Avoid deprecation warnings in deprecated `Nan::Callback::operator()` 372b14d91289df4604b0f81780709708c45a9aa4
+ - Bugfix: Avoid deprecation warnings in `Nan::JSON` 3bc294bce0b7d0a3ee4559926303e5ed4866fda2
+
+### 2.9.0 Feb 22 2018
+
+ - Deprecation: Deprecate legacy `Callback::Call` 6dd5fa690af61ca3523004b433304c581b3ea309
+ - Feature: introduce `AsyncResource` class 90c0a179c0d8cb5fd26f1a7d2b1d6231eb402d48o
+ - Feature: Add context aware `Nan::Callback::Call` functions 7169e09fb088418b6e388222e88b4c13f07ebaee
+ - Feature: Make `AsyncWorker` context aware 066ba21a6fb9e2b5230c9ed3a6fc51f1211736a4
+ - Feature: add `Callback` overload to `Nan::Call` 5328daf66e202658c1dc0d916c3aaba99b3cc606
+ - Bugfix: fix warning: suggest parentheses around `&&` within `||` b2bb63d68b8ae623a526b542764e1ac82319cb2c
+ - Bugfix: Fix compilation on io.js 3 d06114dba0a522fb436f0c5f47b994210968cd7b
+
+### 2.8.0 Nov 15 2017
+
+ - Deprecation: Deprecate `Nan::ForceSet` in favor of `Nan::DefineOwnProperty()` 95cbb976d6fbbba88ba0f86dd188223a8591b4e7
+ - Feature: Add `Nan::AsyncProgressQueueWorker` a976636ecc2ef617d1b061ce4a6edf39923691cb
+ - Feature: Add `Nan::DefineOwnProperty()` 95cbb976d6fbbba88ba0f86dd188223a8591b4e7
+ - Bugfix: Fix compiling on io.js 1 & 2 82705a64503ce60c62e98df5bd02972bba090900
+ - Bugfix: Use DefineOwnProperty instead of ForceSet 95cbb976d6fbbba88ba0f86dd188223a8591b4e7
+
+### 2.7.0 Aug 30 2017
+
+ - Feature: Add `Nan::To()` overload. b93280670c9f6da42ed4cf6cbf085ffdd87bd65b
+ - Bugfix: Fix ternary in `Nan::MaybeLocal::FromMaybe()`. 79a26f7d362e756a9524e672a82c3d603b542867
+
+### 2.6.2 Apr 12 2017
+
+ - Bugfix: Fix v8::JSON::Parse() deprecation warning. 87f6a3c65815fa062296a994cc863e2fa124867d
+
+### 2.6.1 Apr 6 2017
+
+ - Bugfix: nan_json.h: fix build breakage in Node 6 ac8d47dc3c10bfbf3f15a6b951633120c0ee6d51
+
+### 2.6.0 Apr 6 2017
+
+ - Feature: nan: add support for JSON::Parse & Stringify b533226c629cce70e1932a873bb6f849044a56c5
+
+### 2.5.1 Jan 23 2017
+
+ - Bugfix: Fix disappearing handle for private value 6a80995694f162ef63dbc9948fbefd45d4485aa0
+ - Bugfix: Add missing scopes a93b8bae6bc7d32a170db6e89228b7f60ee57112
+ - Bugfix: Use string::data instead of string::front in NewOneByteString d5f920371e67e1f3b268295daee6e83af86b6e50
+
+### 2.5.0 Dec 21 2016
+
+ - Feature: Support Private accessors a86255cb357e8ad8ccbf1f6a4a901c921e39a178
+ - Bugfix: Abort in delete operators that shouldn't be called 0fe38215ff8581703967dfd26c12793feb960018
+
+### 2.4.0 Jul 10 2016
+
+ - Feature: Rewrite Callback to add Callback::Reset c4cf44d61f8275cd5f7b0c911d7a806d4004f649
+ - Feature: AsyncProgressWorker: add template types for .send 1242c9a11a7ed481c8f08ec06316385cacc513d0
+ - Bugfix: Add constness to old Persistent comparison operators bd43cb9982c7639605d60fd073efe8cae165d9b2
+
+### 2.3.5 May 31 2016
+
+ - Bugfix: Replace NAN_INLINE with 'inline' keyword. 71819d8725f822990f439479c9aba3b240804909
+
+### 2.3.4 May 31 2016
+
+ - Bugfix: Remove V8 deprecation warnings 0592fb0a47f3a1c7763087ebea8e1138829f24f9
+ - Bugfix: Fix new versions not to use WeakCallbackInfo::IsFirstPass 615c19d9e03d4be2049c10db0151edbc3b229246
+ - Bugfix: Make ObjectWrap::handle() const d19af99595587fe7a26bd850af6595c2a7145afc
+ - Bugfix: Fix compilation errors related to 0592fb0a47f3a1c7763087ebea8e1138829f24f9 e9191c525b94f652718325e28610a1adcf90fed8
+
+### 2.3.3 May 4 2016
+
+ - Bugfix: Refactor SetMethod() to deal with v8::Templates (#566) b9083cf6d5de6ebe6bcb49c7502fbb7c0d9ddda8
+
+### 2.3.2 Apr 27 2016
+
+ - Bugfix: Fix compilation on outdated versions due to Handle removal f8b7c875d04d425a41dfd4f3f8345bc3a11e6c52
+
+### 2.3.1 Apr 27 2016
+
+ - Bugfix: Don't use deprecated v8::Template::Set() in SetMethod a90951e9ea70fa1b3836af4b925322919159100e
+
+### 2.3.0 Apr 27 2016
+
+ - Feature: added Signal() for invoking async callbacks without sending data from AsyncProgressWorker d8adba45f20e077d00561b20199133620c990b38
+ - Bugfix: Don't use deprecated v8::Template::Set() 00dacf0a4b86027415867fa7f1059acc499dcece
+
+### 2.2.1 Mar 29 2016
+
+ - Bugfix: Use NewFromUnsigned in ReturnValue::Set(uint32_t i) for pre_12 3a18f9bdce29826e0e4c217854bc476918241a58
+ - Performance: Remove unneeeded nullptr checks b715ef44887931c94f0d1605b3b1a4156eebece9
+
+### 2.2.0 Jan 9 2016
+
+ - Feature: Add Function::Call wrapper 4c157474dacf284d125c324177b45aa5dabc08c6
+ - Feature: Rename GC*logueCallback to GCCallback for > 4.0 3603435109f981606d300eb88004ca101283acec
+ - Bugfix: Fix Global::Pass for old versions 367e82a60fbaa52716232cc89db1cc3f685d77d9
+ - Bugfix: Remove weird MaybeLocal wrapping of what already is a MaybeLocal 23b4590db10c2ba66aee2338aebe9751c4cb190b
+
+### 2.1.0 Oct 8 2015
+
+ - Deprecation: Deprecate NanErrnoException in favor of ErrnoException 0af1ca4cf8b3f0f65ed31bc63a663ab3319da55c
+ - Feature: added helper class for accessing contents of typedarrays 17b51294c801e534479d5463697a73462d0ca555
+ - Feature: [Maybe types] Add MakeMaybe(...) 48d7b53d9702b0c7a060e69ea10fea8fb48d814d
+ - Feature: new: allow utf16 string with length 66ac6e65c8ab9394ef588adfc59131b3b9d8347b
+ - Feature: Introduce SetCallHandler and SetCallAsFunctionHandler 7764a9a115d60ba10dc24d86feb0fbc9b4f75537
+ - Bugfix: Enable creating Locals from Globals under Node 0.10. 9bf9b8b190821af889790fdc18ace57257e4f9ff
+ - Bugfix: Fix issue #462 where PropertyCallbackInfo data is not stored safely. 55f50adedd543098526c7b9f4fffd607d3f9861f
+
+### 2.0.9 Sep 8 2015
+
+ - Bugfix: EscapableHandleScope in Nan::NewBuffer for Node 0.8 and 0.10 b1654d7
+
+### 2.0.8 Aug 28 2015
+
+ - Work around duplicate linking bug in clang 11902da
+
+### 2.0.7 Aug 26 2015
+
+ - Build: Repackage
+
+### 2.0.6 Aug 26 2015
+
+ - Bugfix: Properly handle null callback in FunctionTemplate factory 6e99cb1
+ - Bugfix: Remove unused static std::map instances 525bddc
+ - Bugfix: Make better use of maybe versions of APIs bfba85b
+ - Bugfix: Fix shadowing issues with handle in ObjectWrap 0a9072d
+
+### 2.0.5 Aug 10 2015
+
+ - Bugfix: Reimplement weak callback in ObjectWrap 98d38c1
+ - Bugfix: Make sure callback classes are not assignable, copyable or movable 81f9b1d
+
+### 2.0.4 Aug 6 2015
+
+ - Build: Repackage
+
+### 2.0.3 Aug 6 2015
+
+ - Bugfix: Don't use clang++ / g++ syntax extension. 231450e
+
+### 2.0.2 Aug 6 2015
+
+ - Build: Repackage
+
+### 2.0.1 Aug 6 2015
+
+ - Bugfix: Add workaround for missing REPLACE_INVALID_UTF8 60d6687
+ - Bugfix: Reimplement ObjectWrap from scratch to prevent memory leaks 6484601
+ - Bugfix: Fix Persistent leak in FunctionCallbackInfo and PropertyCallbackInfo 641ef5f
+ - Bugfix: Add missing overload for Nan::NewInstance that takes argc/argv 29450ed
+
+### 2.0.0 Jul 31 2015
+
+ - Change: Renamed identifiers with leading underscores b5932b4
+ - Change: Replaced NanObjectWrapHandle with class NanObjectWrap 464f1e1
+ - Change: Replace NanScope and NanEscpableScope macros with classes 47751c4
+ - Change: Rename NanNewBufferHandle to NanNewBuffer 6745f99
+ - Change: Rename NanBufferUse to NanNewBuffer 3e8b0a5
+ - Change: Rename NanNewBuffer to NanCopyBuffer d6af78d
+ - Change: Remove Nan prefix from all names 72d1f67
+ - Change: Update Buffer API for new upstream changes d5d3291
+ - Change: Rename Scope and EscapableScope to HandleScope and EscapableHandleScope 21a7a6a
+ - Change: Get rid of Handles e6c0daf
+ - Feature: Support io.js 3 with V8 4.4
+ - Feature: Introduce NanPersistent 7fed696
+ - Feature: Introduce NanGlobal 4408da1
+ - Feature: Added NanTryCatch 10f1ca4
+ - Feature: Update for V8 v4.3 4b6404a
+ - Feature: Introduce NanNewOneByteString c543d32
+ - Feature: Introduce namespace Nan 67ed1b1
+ - Removal: Remove NanLocker and NanUnlocker dd6e401
+ - Removal: Remove string converters, except NanUtf8String, which now follows the node implementation b5d00a9
+ - Removal: Remove NanReturn* macros d90a25c
+ - Removal: Remove HasInstance e8f84fe
+
+
+### 1.9.0 Jul 31 2015
+
+ - Feature: Added `NanFatalException` 81d4a2c
+ - Feature: Added more error types 4265f06
+ - Feature: Added dereference and function call operators to NanCallback c4b2ed0
+ - Feature: Added indexed GetFromPersistent and SaveToPersistent edd510c
+ - Feature: Added more overloads of SaveToPersistent and GetFromPersistent 8b1cef6
+ - Feature: Added NanErrnoException dd87d9e
+ - Correctness: Prevent assign, copy, and move for classes that do not support it 1f55c59, 4b808cb, c96d9b2, fba4a29, 3357130
+ - Deprecation: Deprecate `NanGetPointerSafe` and `NanSetPointerSafe` 81d4a2c
+ - Deprecation: Deprecate `NanBooleanOptionValue` and `NanUInt32OptionValue` 0ad254b
+
+### 1.8.4 Apr 26 2015
+
+ - Build: Repackage
+
+### 1.8.3 Apr 26 2015
+
+ - Bugfix: Include missing header 1af8648
+
+### 1.8.2 Apr 23 2015
+
+ - Build: Repackage
+
+### 1.8.1 Apr 23 2015
+
+ - Bugfix: NanObjectWrapHandle should take a pointer 155f1d3
+
+### 1.8.0 Apr 23 2015
+
+ - Feature: Allow primitives with NanReturnValue 2e4475e
+ - Feature: Added comparison operators to NanCallback 55b075e
+ - Feature: Backport thread local storage 15bb7fa
+ - Removal: Remove support for signatures with arguments 8a2069d
+ - Correcteness: Replaced NanObjectWrapHandle macro with function 0bc6d59
+
+### 1.7.0 Feb 28 2015
+
+ - Feature: Made NanCallback::Call accept optional target 8d54da7
+ - Feature: Support atom-shell 0.21 0b7f1bb
+
+### 1.6.2 Feb 6 2015
+
+ - Bugfix: NanEncode: fix argument type for node::Encode on io.js 2be8639
+
+### 1.6.1 Jan 23 2015
+
+ - Build: version bump
+
+### 1.5.3 Jan 23 2015
+
+ - Build: repackage
+
+### 1.6.0 Jan 23 2015
+
+ - Deprecated `NanNewContextHandle` in favor of `NanNew` 49259af
+ - Support utility functions moved in newer v8 versions (Node 0.11.15, io.js 1.0) a0aa179
+ - Added `NanEncode`, `NanDecodeBytes` and `NanDecodeWrite` 75e6fb9
+
+### 1.5.2 Jan 23 2015
+
+ - Bugfix: Fix non-inline definition build error with clang++ 21d96a1, 60fadd4
+ - Bugfix: Readded missing String constructors 18d828f
+ - Bugfix: Add overload handling NanNew(..) 5ef813b
+ - Bugfix: Fix uv_work_cb versioning 997e4ae
+ - Bugfix: Add function factory and test 4eca89c
+ - Bugfix: Add object template factory and test cdcb951
+ - Correctness: Lifted an io.js related typedef c9490be
+ - Correctness: Make explicit downcasts of String lengths 00074e6
+ - Windows: Limit the scope of disabled warning C4530 83d7deb
+
+### 1.5.1 Jan 15 2015
+
+ - Build: version bump
+
+### 1.4.3 Jan 15 2015
+
+ - Build: version bump
+
+### 1.4.2 Jan 15 2015
+
+ - Feature: Support io.js 0dbc5e8
+
+### 1.5.0 Jan 14 2015
+
+ - Feature: Support io.js b003843
+ - Correctness: Improved NanNew internals 9cd4f6a
+ - Feature: Implement progress to NanAsyncWorker 8d6a160
+
+### 1.4.1 Nov 8 2014
+
+ - Bugfix: Handle DEBUG definition correctly
+ - Bugfix: Accept int as Boolean
+
+### 1.4.0 Nov 1 2014
+
+ - Feature: Added NAN_GC_CALLBACK 6a5c245
+ - Performance: Removed unnecessary local handle creation 18a7243, 41fe2f8
+ - Correctness: Added constness to references in NanHasInstance 02c61cd
+ - Warnings: Fixed spurious warnings from -Wundef and -Wshadow, 541b122, 99d8cb6
+ - Windoze: Shut Visual Studio up when compiling 8d558c1
+ - License: Switch to plain MIT from custom hacked MIT license 11de983
+ - Build: Added test target to Makefile e232e46
+ - Performance: Removed superfluous scope in NanAsyncWorker f4b7821
+ - Sugar/Feature: Added NanReturnThis() and NanReturnHolder() shorthands 237a5ff, d697208
+ - Feature: Added suitable overload of NanNew for v8::Integer::NewFromUnsigned b27b450
+
+### 1.3.0 Aug 2 2014
+
+ - Added NanNew(std::string)
+ - Added NanNew(std::string&)
+ - Added NanAsciiString helper class
+ - Added NanUtf8String helper class
+ - Added NanUcs2String helper class
+ - Deprecated NanRawString()
+ - Deprecated NanCString()
+ - Added NanGetIsolateData(v8::Isolate *isolate)
+ - Added NanMakeCallback(v8::Handle target, v8::Handle func, int argc, v8::Handle* argv)
+ - Added NanMakeCallback(v8::Handle target, v8::Handle symbol, int argc, v8::Handle* argv)
+ - Added NanMakeCallback(v8::Handle target, const char* method, int argc, v8::Handle* argv)
+ - Added NanSetTemplate(v8::Handle templ, v8::Handle name , v8::Handle value, v8::PropertyAttribute attributes)
+ - Added NanSetPrototypeTemplate(v8::Local templ, v8::Handle name, v8::Handle value, v8::PropertyAttribute attributes)
+ - Added NanSetInstanceTemplate(v8::Local templ, const char *name, v8::Handle value)
+ - Added NanSetInstanceTemplate(v8::Local templ, v8::Handle name, v8::Handle value, v8::PropertyAttribute attributes)
+
+### 1.2.0 Jun 5 2014
+
+ - Add NanSetPrototypeTemplate
+ - Changed NAN_WEAK_CALLBACK internals, switched _NanWeakCallbackData to class,
+ introduced _NanWeakCallbackDispatcher
+ - Removed -Wno-unused-local-typedefs from test builds
+ - Made test builds Windows compatible ('Sleep()')
+
+### 1.1.2 May 28 2014
+
+ - Release to fix more stuff-ups in 1.1.1
+
+### 1.1.1 May 28 2014
+
+ - Release to fix version mismatch in nan.h and lack of changelog entry for 1.1.0
+
+### 1.1.0 May 25 2014
+
+ - Remove nan_isolate, use v8::Isolate::GetCurrent() internally instead
+ - Additional explicit overloads for NanNew(): (char*,int), (uint8_t*[,int]),
+ (uint16_t*[,int), double, int, unsigned int, bool, v8::String::ExternalStringResource*,
+ v8::String::ExternalAsciiStringResource*
+ - Deprecate NanSymbol()
+ - Added SetErrorMessage() and ErrorMessage() to NanAsyncWorker
+
+### 1.0.0 May 4 2014
+
+ - Heavy API changes for V8 3.25 / Node 0.11.13
+ - Use cpplint.py
+ - Removed NanInitPersistent
+ - Removed NanPersistentToLocal
+ - Removed NanFromV8String
+ - Removed NanMakeWeak
+ - Removed NanNewLocal
+ - Removed NAN_WEAK_CALLBACK_OBJECT
+ - Removed NAN_WEAK_CALLBACK_DATA
+ - Introduce NanNew, replaces NanNewLocal, NanPersistentToLocal, adds many overloaded typed versions
+ - Introduce NanUndefined, NanNull, NanTrue and NanFalse
+ - Introduce NanEscapableScope and NanEscapeScope
+ - Introduce NanMakeWeakPersistent (requires a special callback to work on both old and new node)
+ - Introduce NanMakeCallback for node::MakeCallback
+ - Introduce NanSetTemplate
+ - Introduce NanGetCurrentContext
+ - Introduce NanCompileScript and NanRunScript
+ - Introduce NanAdjustExternalMemory
+ - Introduce NanAddGCEpilogueCallback, NanAddGCPrologueCallback, NanRemoveGCEpilogueCallback, NanRemoveGCPrologueCallback
+ - Introduce NanGetHeapStatistics
+ - Rename NanAsyncWorker#SavePersistent() to SaveToPersistent()
+
+### 0.8.0 Jan 9 2014
+
+ - NanDispose -> NanDisposePersistent, deprecate NanDispose
+ - Extract _NAN_*_RETURN_TYPE, pull up NAN_*()
+
+### 0.7.1 Jan 9 2014
+
+ - Fixes to work against debug builds of Node
+ - Safer NanPersistentToLocal (avoid reinterpret_cast)
+ - Speed up common NanRawString case by only extracting flattened string when necessary
+
+### 0.7.0 Dec 17 2013
+
+ - New no-arg form of NanCallback() constructor.
+ - NanCallback#Call takes Handle rather than Local
+ - Removed deprecated NanCallback#Run method, use NanCallback#Call instead
+ - Split off _NAN_*_ARGS_TYPE from _NAN_*_ARGS
+ - Restore (unofficial) Node 0.6 compatibility at NanCallback#Call()
+ - Introduce NanRawString() for char* (or appropriate void*) from v8::String
+ (replacement for NanFromV8String)
+ - Introduce NanCString() for null-terminated char* from v8::String
+
+### 0.6.0 Nov 21 2013
+
+ - Introduce NanNewLocal(v8::Handle value) for use in place of
+ v8::Local::New(...) since v8 started requiring isolate in Node 0.11.9
+
+### 0.5.2 Nov 16 2013
+
+ - Convert SavePersistent and GetFromPersistent in NanAsyncWorker from protected and public
+
+### 0.5.1 Nov 12 2013
+
+ - Use node::MakeCallback() instead of direct v8::Function::Call()
+
+### 0.5.0 Nov 11 2013
+
+ - Added @TooTallNate as collaborator
+ - New, much simpler, "include_dirs" for binding.gyp
+ - Added full range of NAN_INDEX_* macros to match NAN_PROPERTY_* macros
+
+### 0.4.4 Nov 2 2013
+
+ - Isolate argument from v8::Persistent::MakeWeak removed for 0.11.8+
+
+### 0.4.3 Nov 2 2013
+
+ - Include node_object_wrap.h, removed from node.h for Node 0.11.8.
+
+### 0.4.2 Nov 2 2013
+
+ - Handle deprecation of v8::Persistent::Dispose(v8::Isolate* isolate)) for
+ Node 0.11.8 release.
+
+### 0.4.1 Sep 16 2013
+
+ - Added explicit `#include ` as it was removed from node.h for v0.11.8
+
+### 0.4.0 Sep 2 2013
+
+ - Added NAN_INLINE and NAN_DEPRECATED and made use of them
+ - Added NanError, NanTypeError and NanRangeError
+ - Cleaned up code
+
+### 0.3.2 Aug 30 2013
+
+ - Fix missing scope declaration in GetFromPersistent() and SaveToPersistent
+ in NanAsyncWorker
+
+### 0.3.1 Aug 20 2013
+
+ - fix "not all control paths return a value" compile warning on some platforms
+
+### 0.3.0 Aug 19 2013
+
+ - Made NAN work with NPM
+ - Lots of fixes to NanFromV8String, pulling in features from new Node core
+ - Changed node::encoding to Nan::Encoding in NanFromV8String to unify the API
+ - Added optional error number argument for NanThrowError()
+ - Added NanInitPersistent()
+ - Added NanReturnNull() and NanReturnEmptyString()
+ - Added NanLocker and NanUnlocker
+ - Added missing scopes
+ - Made sure to clear disposed Persistent handles
+ - Changed NanAsyncWorker to allocate error messages on the heap
+ - Changed NanThrowError(Local) to NanThrowError(Handle)
+ - Fixed leak in NanAsyncWorker when errmsg is used
+
+### 0.2.2 Aug 5 2013
+
+ - Fixed usage of undefined variable with node::BASE64 in NanFromV8String()
+
+### 0.2.1 Aug 5 2013
+
+ - Fixed 0.8 breakage, node::BUFFER encoding type not available in 0.8 for
+ NanFromV8String()
+
+### 0.2.0 Aug 5 2013
+
+ - Added NAN_PROPERTY_GETTER, NAN_PROPERTY_SETTER, NAN_PROPERTY_ENUMERATOR,
+ NAN_PROPERTY_DELETER, NAN_PROPERTY_QUERY
+ - Extracted _NAN_METHOD_ARGS, _NAN_GETTER_ARGS, _NAN_SETTER_ARGS,
+ _NAN_PROPERTY_GETTER_ARGS, _NAN_PROPERTY_SETTER_ARGS,
+ _NAN_PROPERTY_ENUMERATOR_ARGS, _NAN_PROPERTY_DELETER_ARGS,
+ _NAN_PROPERTY_QUERY_ARGS
+ - Added NanGetInternalFieldPointer, NanSetInternalFieldPointer
+ - Added NAN_WEAK_CALLBACK, NAN_WEAK_CALLBACK_OBJECT,
+ NAN_WEAK_CALLBACK_DATA, NanMakeWeak
+ - Renamed THROW_ERROR to _NAN_THROW_ERROR
+ - Added NanNewBufferHandle(char*, size_t, node::smalloc::FreeCallback, void*)
+ - Added NanBufferUse(char*, uint32_t)
+ - Added NanNewContextHandle(v8::ExtensionConfiguration*,
+ v8::Handle, v8::Handle)
+ - Fixed broken NanCallback#GetFunction()
+ - Added optional encoding and size arguments to NanFromV8String()
+ - Added NanGetPointerSafe() and NanSetPointerSafe()
+ - Added initial test suite (to be expanded)
+ - Allow NanUInt32OptionValue to convert any Number object
+
+### 0.1.0 Jul 21 2013
+
+ - Added `NAN_GETTER`, `NAN_SETTER`
+ - Added `NanThrowError` with single Local argument
+ - Added `NanNewBufferHandle` with single uint32_t argument
+ - Added `NanHasInstance(Persistent&, Handle)`
+ - Added `Local NanCallback#GetFunction()`
+ - Added `NanCallback#Call(int, Local[])`
+ - Deprecated `NanCallback#Run(int, Local[])` in favour of Call
diff --git a/node_modules/nan/LICENSE.md b/node_modules/nan/LICENSE.md
new file mode 100644
index 0000000..dddd13d
--- /dev/null
+++ b/node_modules/nan/LICENSE.md
@@ -0,0 +1,13 @@
+The MIT License (MIT)
+=====================
+
+Copyright (c) 2018 NAN contributors
+-----------------------------------
+
+*NAN contributors listed at *
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/nan/README.md b/node_modules/nan/README.md
new file mode 100644
index 0000000..f671ef1
--- /dev/null
+++ b/node_modules/nan/README.md
@@ -0,0 +1,455 @@
+Native Abstractions for Node.js
+===============================
+
+**A header file filled with macro and utility goodness for making add-on development for Node.js easier across versions 0.8, 0.10, 0.12, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 and 14.**
+
+***Current version: 2.14.2***
+
+*(See [CHANGELOG.md](https://github.com/nodejs/nan/blob/master/CHANGELOG.md) for complete ChangeLog)*
+
+[](https://nodei.co/npm/nan/) [](https://nodei.co/npm/nan/)
+
+[](https://travis-ci.org/nodejs/nan)
+[](https://ci.appveyor.com/project/RodVagg/nan)
+
+Thanks to the crazy changes in V8 (and some in Node core), keeping native addons compiling happily across versions, particularly 0.10 to 0.12 to 4.0, is a minor nightmare. The goal of this project is to store all logic necessary to develop native Node.js addons without having to inspect `NODE_MODULE_VERSION` and get yourself into a macro-tangle.
+
+This project also contains some helper utilities that make addon development a bit more pleasant.
+
+ * **[News & Updates](#news)**
+ * **[Usage](#usage)**
+ * **[Example](#example)**
+ * **[API](#api)**
+ * **[Tests](#tests)**
+ * **[Known issues](#issues)**
+ * **[Governance & Contributing](#governance)**
+
+` in your *.cpp* files:
+
+``` python
+"include_dirs" : [
+ "` when compiling your addon.
+
+Nan::FunctionCallbackInfoNan::PropertyCallbackInfoNan::ReturnValueMethod declaration Getter declaration Setter declaration Property getter declaration Property setter declaration Property enumerator declaration Property deleter declaration Property query declaration Index getter declaration Index setter declaration Index enumerator declaration Index deleter declaration Index query declaration Nan::SetMethod()Nan::SetPrototypeMethod()Nan::SetAccessor()Nan::SetNamedPropertyHandler()Nan::SetIndexedPropertyHandler()Nan::SetTemplate()Nan::SetPrototypeTemplate()Nan::SetInstanceTemplate()Nan::SetCallHandler()Nan::SetCallAsFunctionHandler()Nan::HandleScopeNan::EscapableHandleScopeNan::PersistentBase & v8::PersistentBaseNan::NonCopyablePersistentTraits & v8::NonCopyablePersistentTraitsNan::CopyablePersistentTraits & v8::CopyablePersistentTraitsNan::PersistentNan::GlobalNan::WeakCallbackInfoNan::WeakCallbackTypeNan::New()Nan::Undefined()Nan::Null()Nan::True()Nan::False()Nan::EmptyString()Nan::To()Nan::MaybeLocalNan::MaybeNan::NothingNan::JustNan::Call()Nan::ToDetailString()Nan::ToArrayIndex()Nan::Equals()Nan::NewInstance()Nan::GetFunction()Nan::Set()Nan::DefineOwnProperty()Nan::ForceSet()Nan::Get()Nan::GetPropertyAttributes()Nan::Has()Nan::Delete()Nan::GetPropertyNames()Nan::GetOwnPropertyNames()Nan::SetPrototype()Nan::ObjectProtoToString()Nan::HasOwnProperty()Nan::HasRealNamedProperty()Nan::HasRealIndexedProperty()Nan::HasRealNamedCallbackProperty()Nan::GetRealNamedPropertyInPrototypeChain()Nan::GetRealNamedProperty()Nan::CallAsFunction()Nan::CallAsConstructor()Nan::GetSourceLine()Nan::GetLineNumber()Nan::GetStartColumn()Nan::GetEndColumn()Nan::CloneElementAt()Nan::HasPrivate()Nan::GetPrivate()Nan::SetPrivate()Nan::DeletePrivate()Nan::MakeMaybe()Nan::CompileScript()Nan::RunScript()Nan::JSON.ParseNan::JSON.StringifyNan::Error()Nan::RangeError()Nan::ReferenceError()Nan::SyntaxError()Nan::TypeError()Nan::ThrowError()Nan::ThrowRangeError()Nan::ThrowReferenceError()Nan::ThrowSyntaxError()Nan::ThrowTypeError()Nan::FatalException()Nan::ErrnoException()Nan::TryCatchNan::NewBuffer()Nan::CopyBuffer()Nan::FreeCallback()Nan::CallbackNan::AsyncWorkerNan::AsyncProgressWorkerBase & Nan::AsyncProgressWorkerNan::AsyncProgressQueueWorkerNan::AsyncQueueWorkerNan::EncodingNan::Encode()Nan::DecodeBytes()Nan::DecodeWrite()Nan::ObjectWrapNAN_GC_CALLBACK()Nan::AddGCEpilogueCallback()Nan::RemoveGCEpilogueCallback()Nan::AddGCPrologueCallback()Nan::RemoveGCPrologueCallback()Nan::GetHeapStatistics()Nan::SetCounterFunction()Nan::SetCreateHistogramFunction()Nan::SetAddHistogramSampleFunction()Nan::IdleNotification()Nan::LowMemoryNotification()Nan::ContextDisposedNotification()Nan::GetInternalFieldPointer()Nan::SetInternalFieldPointer()Nan::AdjustExternalMemory()Nan::Utf8StringNan::GetCurrentContext()Nan::SetIsolateData()Nan::GetIsolateData()Nan::TypedArrayContentsNan::AsyncResourceNan::MakeCallback()NAN_MODULE_INIT()Nan::Export()(reinterpret_cast(HandleScope::CreateHandle(
+ ~~~~~~~~~~~~~^~~~~~~~~~~~
+```
+
+This can be worked around by patching your local versions of v8.h corresponding to Node 0.12 to make
+`v8::Handle` a friend of `v8::HandleScope`. Since neither Node.js not V8 support this release line anymore
+this patch cannot be released by either project in an official release.
+
+For this reason, we do not test against Node.js 0.12 on OSX in this project's CI. If you need to support
+that configuration, you will need to either get an older compiler, or apply a source patch to the version
+of V8 headers as a workaround.
+
+Nan::AsyncWorkerNan::AsyncProgressWorkerBase & Nan::AsyncProgressWorkerNan::AsyncProgressQueueWorkerNan::AsyncQueueWorker &value);
+
+ void SaveToPersistent(const v8::Local &key,
+ const v8::Local &value);
+
+ void SaveToPersistent(uint32_t index,
+ const v8::Local &value);
+
+ v8::Local GetFromPersistent(const char *key) const;
+
+ v8::Local GetFromPersistent(const v8::Local &key) const;
+
+ v8::Local GetFromPersistent(uint32_t index) const;
+
+ virtual void Execute() = 0;
+
+ uv_work_t request;
+
+ virtual void Destroy();
+
+ protected:
+ Persistent persistentHandle;
+
+ Callback *callback;
+
+ virtual void HandleOKCallback();
+
+ virtual void HandleErrorCallback();
+
+ void SetErrorMessage(const char *msg);
+
+ const char* ErrorMessage();
+};
+```
+
+` for compatibility.
+
+`Nan::AsyncProgressWorkerBase` & `Nan::AsyncProgressWorker` is intended for best-effort delivery of nonessential progress messages, e.g. a progress bar. The last event sent before the main thread is woken will be delivered.
+
+Definition:
+
+```c++
+template
+class AsyncProgressWorkerBase : public AsyncWorker {
+ public:
+ explicit AsyncProgressWorkerBase(Callback *callback_, const char* resource_name = ...);
+
+ virtual ~AsyncProgressWorkerBase();
+
+ void WorkProgress();
+
+ class ExecutionProgress {
+ public:
+ void Signal() const;
+ void Send(const T* data, size_t count) const;
+ };
+
+ virtual void Execute(const ExecutionProgress& progress) = 0;
+
+ virtual void HandleProgressCallback(const T *data, size_t count) = 0;
+
+ virtual void Destroy();
+};
+
+typedef AsyncProgressWorkerBase AsyncProgressWorker;
+```
+
+
+class AsyncProgressQueueWorker : public AsyncWorker {
+ public:
+ explicit AsyncProgressQueueWorker(Callback *callback_, const char* resource_name = "nan:AsyncProgressQueueWorker");
+
+ virtual ~AsyncProgressQueueWorker();
+
+ void WorkProgress();
+
+ class ExecutionProgress {
+ public:
+ void Send(const T* data, size_t count) const;
+ };
+
+ virtual void Execute(const ExecutionProgress& progress) = 0;
+
+ virtual void HandleProgressCallback(const T *data, size_t count) = 0;
+
+ virtual void Destroy();
+};
+```
+
+Nan::NewBuffer()Nan::CopyBuffer()Nan::FreeCallback() Nan::NewBuffer(uint32_t size)
+Nan::MaybeLocal Nan::NewBuffer(char* data, uint32_t size)
+Nan::MaybeLocal Nan::NewBuffer(char *data,
+ size_t length,
+ Nan::FreeCallback callback,
+ void *hint)
+```
+
+
+ Nan::CopyBuffer(const char *data, uint32_t size)
+```
+
+
+Nan::Callback &fn);
+
+ ~Callback();
+
+ bool operator==(const Callback &other) const;
+
+ bool operator!=(const Callback &other) const;
+
+ v8::Local operator*() const;
+
+ MaybeLocal operator()(AsyncResource* async_resource,
+ v8::Local target,
+ int argc = 0,
+ v8::Local argv[] = 0) const;
+
+ MaybeLocal operator()(AsyncResource* async_resource,
+ int argc = 0,
+ v8::Local argv[] = 0) const;
+
+ void SetFunction(const v8::Local &fn);
+
+ v8::Local GetFunction() const;
+
+ bool IsEmpty() const;
+
+ void Reset(const v8::Local &fn);
+
+ void Reset();
+
+ MaybeLocal Call(v8::Local target,
+ int argc,
+ v8::Local argv[],
+ AsyncResource* async_resource) const;
+ MaybeLocal Call(int argc,
+ v8::Local argv[],
+ AsyncResource* async_resource) const;
+
+ // Deprecated versions. Use the versions that accept an async_resource instead
+ // as they run the callback in the correct async context as specified by the
+ // resource. If you want to call a synchronous JS function (i.e. on a
+ // non-empty JS stack), you can use Nan::Call instead.
+ v8::Local operator()(v8::Local target,
+ int argc = 0,
+ v8::Local argv[] = 0) const;
+
+ v8::Local operator()(int argc = 0,
+ v8::Local argv[] = 0) const;
+ v8::Local Call(v8::Local target,
+ int argc,
+ v8::Local argv[]) const;
+
+ v8::Local Call(int argc, v8::Local argv[]) const;
+};
+```
+
+Example usage:
+
+```c++
+v8::Local function;
+Nan::Callback callback(function);
+callback.Call(0, 0);
+```
diff --git a/node_modules/nan/doc/converters.md b/node_modules/nan/doc/converters.md
new file mode 100644
index 0000000..d20861b
--- /dev/null
+++ b/node_modules/nan/doc/converters.md
@@ -0,0 +1,41 @@
+## Converters
+
+NAN contains functions that convert `v8::Value`s to other `v8::Value` types and native types. Since type conversion is not guaranteed to succeed, they return `Nan::Maybe` types. These converters can be used in place of `value->ToX()` and `value->XValue()` (where `X` is one of the types, e.g. `Boolean`) in a way that provides a consistent interface across V8 versions. Newer versions of V8 use the new `v8::Maybe` and `v8::MaybeLocal` types for these conversions, older versions don't have this functionality so it is provided by NAN.
+
+ - Nan::To()` to a different subtype of `v8::Value` or to a native data type. Returns a `Nan::MaybeLocal<>` or a `Nan::Maybe<>` accordingly.
+
+See [maybe_types.md](./maybe_types.md) for more information on `Nan::Maybe` types.
+
+Signatures:
+
+```c++
+// V8 types
+Nan::MaybeLocal Nan::To(v8::Local val);
+Nan::MaybeLocal Nan::To(v8::Local val);
+Nan::MaybeLocal Nan::To(v8::Local val);
+Nan::MaybeLocal Nan::To(v8::Local val);
+Nan::MaybeLocal Nan::To(v8::Local val);
+Nan::MaybeLocal Nan::To(v8::Local val);
+Nan::MaybeLocal Nan::To(v8::Local val);
+
+// Native types
+Nan::Maybe Nan::To(v8::Local val);
+Nan::Maybe Nan::To(v8::Local val);
+Nan::Maybe Nan::To(v8::Local val);
+Nan::Maybe Nan::To(v8::Local val);
+Nan::Maybe Nan::To(v8::Local val);
+```
+
+### Example
+
+```c++
+v8::Local val;
+Nan::MaybeLocal str = Nan::To(val);
+Nan::Maybe d = Nan::To(val);
+```
+
diff --git a/node_modules/nan/doc/errors.md b/node_modules/nan/doc/errors.md
new file mode 100644
index 0000000..843435b
--- /dev/null
+++ b/node_modules/nan/doc/errors.md
@@ -0,0 +1,226 @@
+## Errors
+
+NAN includes helpers for creating, throwing and catching Errors as much of this functionality varies across the supported versions of V8 and must be abstracted.
+
+Note that an Error object is simply a specialized form of `v8::Value`.
+
+Also consult the V8 Embedders Guide section on [Exceptions](https://developers.google.com/v8/embed#exceptions) for more information.
+
+ - Nan::Error()Nan::RangeError()Nan::ReferenceError()Nan::SyntaxError()Nan::TypeError()Nan::ThrowError()Nan::ThrowRangeError()Nan::ThrowReferenceError()Nan::ThrowSyntaxError()Nan::ThrowTypeError()Nan::FatalException()Nan::ErrnoException()Nan::TryCatch Nan::Error(const char *msg);
+v8::Local Nan::Error(v8::Local msg);
+```
+
+
+ Nan::RangeError(const char *msg);
+v8::Local Nan::RangeError(v8::Local msg);
+```
+
+
+ Nan::ReferenceError(const char *msg);
+v8::Local Nan::ReferenceError(v8::Local msg);
+```
+
+
+ Nan::SyntaxError(const char *msg);
+v8::Local Nan::SyntaxError(v8::Local msg);
+```
+
+
+ Nan::TypeError(const char *msg);
+v8::Local Nan::TypeError(v8::Local msg);
+```
+
+
+ msg);
+void Nan::ThrowError(v8::Local error);
+```
+
+
+ msg);
+void Nan::ThrowRangeError(v8::Local error);
+```
+
+
+ msg);
+void Nan::ThrowReferenceError(v8::Local error);
+```
+
+
+ msg);
+void Nan::ThrowSyntaxError(v8::Local error);
+```
+
+
+ msg);
+void Nan::ThrowTypeError(v8::Local error);
+```
+
+ Nan::ErrnoException(int errorno,
+ const char* syscall = NULL,
+ const char* message = NULL,
+ const char* path = NULL);
+```
+
+
+ ReThrow();
+
+ v8::Local Exception() const;
+
+ // Nan::MaybeLocal for older versions of V8
+ v8::MaybeLocal StackTrace() const;
+
+ v8::Local Message() const;
+
+ void Reset();
+
+ void SetVerbose(bool value);
+
+ void SetCaptureMessage(bool value);
+};
+```
+
diff --git a/node_modules/nan/doc/json.md b/node_modules/nan/doc/json.md
new file mode 100644
index 0000000..d142597
--- /dev/null
+++ b/node_modules/nan/doc/json.md
@@ -0,0 +1,62 @@
+## JSON
+
+The _JSON_ object provides the c++ versions of the methods offered by the `JSON` object in javascript. V8 exposes these methods via the `v8::JSON` object.
+
+ - Nan::JSON.ParseNan::JSON.Stringify Nan::JSON::Parse(v8::Local json_string);
+```
+
+Use `JSON.Parse(json_string)` to parse a string into a `v8::Value`.
+
+Example:
+
+```c++
+v8::Local json_string = Nan::New("{ \"JSON\": \"object\" }").ToLocalChecked();
+
+Nan::JSON NanJSON;
+Nan::MaybeLocal result = NanJSON.Parse(json_string);
+if (!result.IsEmpty()) {
+ v8::Local val = result.ToLocalChecked();
+}
+```
+
+ Nan::JSON::Stringify(v8::Local json_object, v8::Local gap = v8::Local());
+```
+
+Use `JSON.Stringify(value)` to stringify a `v8::Object`.
+
+Example:
+
+```c++
+// using `v8::Local val` from the `JSON::Parse` example
+v8::Local obj = Nan::To(val).ToLocalChecked();
+
+Nan::JSON NanJSON;
+Nan::MaybeLocal result = NanJSON.Stringify(obj);
+if (!result.IsEmpty()) {
+ v8::Local stringified = result.ToLocalChecked();
+}
+```
+
diff --git a/node_modules/nan/doc/maybe_types.md b/node_modules/nan/doc/maybe_types.md
new file mode 100644
index 0000000..142851a
--- /dev/null
+++ b/node_modules/nan/doc/maybe_types.md
@@ -0,0 +1,583 @@
+## Maybe Types
+
+The `Nan::MaybeLocal` and `Nan::Maybe` types are monads that encapsulate `v8::Local` handles that _may be empty_.
+
+* **Maybe Types**
+ - Nan::MaybeLocalNan::MaybeNan::NothingNan::JustNan::Call()Nan::ToDetailString()Nan::ToArrayIndex()Nan::Equals()Nan::NewInstance()Nan::GetFunction()Nan::Set()Nan::DefineOwnProperty()Nan::ForceSet()Nan::Get()Nan::GetPropertyAttributes()Nan::Has()Nan::Delete()Nan::GetPropertyNames()Nan::GetOwnPropertyNames()Nan::SetPrototype()Nan::ObjectProtoToString()Nan::HasOwnProperty()Nan::HasRealNamedProperty()Nan::HasRealIndexedProperty()Nan::HasRealNamedCallbackProperty()Nan::GetRealNamedPropertyInPrototypeChain()Nan::GetRealNamedProperty()Nan::CallAsFunction()Nan::CallAsConstructor()Nan::GetSourceLine()Nan::GetLineNumber()Nan::GetStartColumn()Nan::GetEndColumn()Nan::CloneElementAt()Nan::HasPrivate()Nan::GetPrivate()Nan::SetPrivate()Nan::DeletePrivate()Nan::MakeMaybe()` is a wrapper around [`v8::Local`](https://v8docs.nodesource.com/node-8.16/de/deb/classv8_1_1_local.html) that enforces a check that determines whether the `v8::Local` is empty before it can be used.
+
+If an API method returns a `Nan::MaybeLocal`, the API method can potentially fail either because an exception is thrown, or because an exception is pending, e.g. because a previous API call threw an exception that hasn't been caught yet, or because a `v8::TerminateExecution` exception was thrown. In that case, an empty `Nan::MaybeLocal` is returned.
+
+Definition:
+
+```c++
+template class Nan::MaybeLocal {
+ public:
+ MaybeLocal();
+
+ template MaybeLocal(v8::Local that);
+
+ bool IsEmpty() const;
+
+ template bool ToLocal(v8::Local *out);
+
+ // Will crash if the MaybeLocal<> is empty.
+ v8::Local ToLocalChecked();
+
+ template 
+
+Dotenv is a zero-dependency module that loads environment variables from a `.env` file into [`process.env`](https://nodejs.org/docs/latest/api/process.html#process_process_env). Storing configuration in the environment separate from code is based on [The Twelve-Factor App](http://12factor.net/config) methodology.
+
+[](https://travis-ci.org/motdotla/dotenv)
+[](https://ci.appveyor.com/project/motdotla/dotenv/branch/master)
+[](https://www.npmjs.com/package/dotenv)
+[](https://github.com/feross/standard)
+[](https://coveralls.io/github/motdotla/dotenv?branch=coverall-intergration)
+[](LICENSE)
+[](https://conventionalcommits.org)
+
+## Install
+
+```bash
+# with npm
+npm install dotenv
+
+# or with Yarn
+yarn add dotenv
+```
+
+## Usage
+
+As early as possible in your application, require and configure dotenv.
+
+```javascript
+require('dotenv').config()
+```
+
+Create a `.env` file in the root directory of your project. Add
+environment-specific variables on new lines in the form of `NAME=VALUE`.
+For example:
+
+```dosini
+DB_HOST=localhost
+DB_USER=root
+DB_PASS=s1mpl3
+```
+
+`process.env` now has the keys and values you defined in your `.env` file.
+
+```javascript
+const db = require('db')
+db.connect({
+ host: process.env.DB_HOST,
+ username: process.env.DB_USER,
+ password: process.env.DB_PASS
+})
+```
+
+### Preload
+
+You can use the `--require` (`-r`) [command line option](https://nodejs.org/api/cli.html#cli_r_require_module) to preload dotenv. By doing this, you do not need to require and load dotenv in your application code. This is the preferred approach when using `import` instead of `require`.
+
+```bash
+$ node -r dotenv/config your_script.js
+```
+
+The configuration options below are supported as command line arguments in the format `dotenv_config_