feat: Add Be and tbd skill, also added Roadmap file

Skills/@be/be/node_modules/crypto-browserify/.npmignore

@@ -0,0 +1 @@
+node_modules

Skills/@be/be/node_modules/crypto-browserify/.travis.yml

@@ -0,0 +1,5 @@
+language: node_js
+node_js:
+  - 0.8
+  - "0.10"
+

Skills/@be/be/node_modules/crypto-browserify/LICENSE

@@ -0,0 +1,24 @@
+The MIT License
+
+Copyright (c) 2013 Dominic Tarr
+
+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.

Skills/@be/be/node_modules/crypto-browserify/example/bundle.js

@@ -0,0 +1,637 @@
+var require = function (file, cwd) {
+    var resolved = require.resolve(file, cwd || '/');
+    var mod = require.modules[resolved];
+    if (!mod) throw new Error(
+        'Failed to resolve module ' + file + ', tried ' + resolved
+    );
+    var res = mod._cached ? mod._cached : mod();
+    return res;
+}
+
+require.paths = [];
+require.modules = {};
+require.extensions = [".js",".coffee"];
+
+require._core = {
+    'assert': true,
+    'events': true,
+    'fs': true,
+    'path': true,
+    'vm': true
+};
+
+require.resolve = (function () {
+    return function (x, cwd) {
+        if (!cwd) cwd = '/';
+        
+        if (require._core[x]) return x;
+        var path = require.modules.path();
+        cwd = path.resolve('/', cwd);
+        var y = cwd || '/';
+        
+        if (x.match(/^(?:\.\.?\/|\/)/)) {
+            var m = loadAsFileSync(path.resolve(y, x))
+                || loadAsDirectorySync(path.resolve(y, x));
+            if (m) return m;
+        }
+        
+        var n = loadNodeModulesSync(x, y);
+        if (n) return n;
+        
+        throw new Error("Cannot find module '" + x + "'");
+        
+        function loadAsFileSync (x) {
+            if (require.modules[x]) {
+                return x;
+            }
+            
+            for (var i = 0; i < require.extensions.length; i++) {
+                var ext = require.extensions[i];
+                if (require.modules[x + ext]) return x + ext;
+            }
+        }
+        
+        function loadAsDirectorySync (x) {
+            x = x.replace(/\/+$/, '');
+            var pkgfile = x + '/package.json';
+            if (require.modules[pkgfile]) {
+                var pkg = require.modules[pkgfile]();
+                var b = pkg.browserify;
+                if (typeof b === 'object' && b.main) {
+                    var m = loadAsFileSync(path.resolve(x, b.main));
+                    if (m) return m;
+                }
+                else if (typeof b === 'string') {
+                    var m = loadAsFileSync(path.resolve(x, b));
+                    if (m) return m;
+                }
+                else if (pkg.main) {
+                    var m = loadAsFileSync(path.resolve(x, pkg.main));
+                    if (m) return m;
+                }
+            }
+            
+            return loadAsFileSync(x + '/index');
+        }
+        
+        function loadNodeModulesSync (x, start) {
+            var dirs = nodeModulesPathsSync(start);
+            for (var i = 0; i < dirs.length; i++) {
+                var dir = dirs[i];
+                var m = loadAsFileSync(dir + '/' + x);
+                if (m) return m;
+                var n = loadAsDirectorySync(dir + '/' + x);
+                if (n) return n;
+            }
+            
+            var m = loadAsFileSync(x);
+            if (m) return m;
+        }
+        
+        function nodeModulesPathsSync (start) {
+            var parts;
+            if (start === '/') parts = [ '' ];
+            else parts = path.normalize(start).split('/');
+            
+            var dirs = [];
+            for (var i = parts.length - 1; i >= 0; i--) {
+                if (parts[i] === 'node_modules') continue;
+                var dir = parts.slice(0, i + 1).join('/') + '/node_modules';
+                dirs.push(dir);
+            }
+            
+            return dirs;
+        }
+    };
+})();
+
+require.alias = function (from, to) {
+    var path = require.modules.path();
+    var res = null;
+    try {
+        res = require.resolve(from + '/package.json', '/');
+    }
+    catch (err) {
+        res = require.resolve(from, '/');
+    }
+    var basedir = path.dirname(res);
+    
+    var keys = (Object.keys || function (obj) {
+        var res = [];
+        for (var key in obj) res.push(key)
+        return res;
+    })(require.modules);
+    
+    for (var i = 0; i < keys.length; i++) {
+        var key = keys[i];
+        if (key.slice(0, basedir.length + 1) === basedir + '/') {
+            var f = key.slice(basedir.length);
+            require.modules[to + f] = require.modules[basedir + f];
+        }
+        else if (key === basedir) {
+            require.modules[to] = require.modules[basedir];
+        }
+    }
+};
+
+require.define = function (filename, fn) {
+    var dirname = require._core[filename]
+        ? ''
+        : require.modules.path().dirname(filename)
+    ;
+    
+    var require_ = function (file) {
+        return require(file, dirname)
+    };
+    require_.resolve = function (name) {
+        return require.resolve(name, dirname);
+    };
+    require_.modules = require.modules;
+    require_.define = require.define;
+    var module_ = { exports : {} };
+    
+    require.modules[filename] = function () {
+        require.modules[filename]._cached = module_.exports;
+        fn.call(
+            module_.exports,
+            require_,
+            module_,
+            module_.exports,
+            dirname,
+            filename
+        );
+        require.modules[filename]._cached = module_.exports;
+        return module_.exports;
+    };
+};
+
+if (typeof process === 'undefined') process = {};
+
+if (!process.nextTick) process.nextTick = (function () {
+    var queue = [];
+    var canPost = typeof window !== 'undefined'
+        && window.postMessage && window.addEventListener
+    ;
+    
+    if (canPost) {
+        window.addEventListener('message', function (ev) {
+            if (ev.source === window && ev.data === 'browserify-tick') {
+                ev.stopPropagation();
+                if (queue.length > 0) {
+                    var fn = queue.shift();
+                    fn();
+                }
+            }
+        }, true);
+    }
+    
+    return function (fn) {
+        if (canPost) {
+            queue.push(fn);
+            window.postMessage('browserify-tick', '*');
+        }
+        else setTimeout(fn, 0);
+    };
+})();
+
+if (!process.title) process.title = 'browser';
+
+if (!process.binding) process.binding = function (name) {
+    if (name === 'evals') return require('vm')
+    else throw new Error('No such module')
+};
+
+if (!process.cwd) process.cwd = function () { return '.' };
+
+if (!process.env) process.env = {};
+if (!process.argv) process.argv = [];
+
+require.define("path", function (require, module, exports, __dirname, __filename) {
+function filter (xs, fn) {
+    var res = [];
+    for (var i = 0; i < xs.length; i++) {
+        if (fn(xs[i], i, xs)) res.push(xs[i]);
+    }
+    return res;
+}
+
+// resolves . and .. elements in a path array with directory names there
+// must be no slashes, empty elements, or device names (c:\) in the array
+// (so also no leading and trailing slashes - it does not distinguish
+// relative and absolute paths)
+function normalizeArray(parts, allowAboveRoot) {
+  // if the path tries to go above the root, `up` ends up > 0
+  var up = 0;
+  for (var i = parts.length; i >= 0; i--) {
+    var last = parts[i];
+    if (last == '.') {
+      parts.splice(i, 1);
+    } else if (last === '..') {
+      parts.splice(i, 1);
+      up++;
+    } else if (up) {
+      parts.splice(i, 1);
+      up--;
+    }
+  }
+
+  // if the path is allowed to go above the root, restore leading ..s
+  if (allowAboveRoot) {
+    for (; up--; up) {
+      parts.unshift('..');
+    }
+  }
+
+  return parts;
+}
+
+// Regex to split a filename into [*, dir, basename, ext]
+// posix version
+var splitPathRe = /^(.+\/(?!$)|\/)?((?:.+?)?(\.[^.]*)?)$/;
+
+// path.resolve([from ...], to)
+// posix version
+exports.resolve = function() {
+var resolvedPath = '',
+    resolvedAbsolute = false;
+
+for (var i = arguments.length; i >= -1 && !resolvedAbsolute; i--) {
+  var path = (i >= 0)
+      ? arguments[i]
+      : process.cwd();
+
+  // Skip empty and invalid entries
+  if (typeof path !== 'string' || !path) {
+    continue;
+  }
+
+  resolvedPath = path + '/' + resolvedPath;
+  resolvedAbsolute = path.charAt(0) === '/';
+}
+
+// At this point the path should be resolved to a full absolute path, but
+// handle relative paths to be safe (might happen when process.cwd() fails)
+
+// Normalize the path
+resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {
+    return !!p;
+  }), !resolvedAbsolute).join('/');
+
+  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
+};
+
+// path.normalize(path)
+// posix version
+exports.normalize = function(path) {
+var isAbsolute = path.charAt(0) === '/',
+    trailingSlash = path.slice(-1) === '/';
+
+// Normalize the path
+path = normalizeArray(filter(path.split('/'), function(p) {
+    return !!p;
+  }), !isAbsolute).join('/');
+
+  if (!path && !isAbsolute) {
+    path = '.';
+  }
+  if (path && trailingSlash) {
+    path += '/';
+  }
+  
+  return (isAbsolute ? '/' : '') + path;
+};
+
+
+// posix version
+exports.join = function() {
+  var paths = Array.prototype.slice.call(arguments, 0);
+  return exports.normalize(filter(paths, function(p, index) {
+    return p && typeof p === 'string';
+  }).join('/'));
+};
+
+
+exports.dirname = function(path) {
+  var dir = splitPathRe.exec(path)[1] || '';
+  var isWindows = false;
+  if (!dir) {
+    // No dirname
+    return '.';
+  } else if (dir.length === 1 ||
+      (isWindows && dir.length <= 3 && dir.charAt(1) === ':')) {
+    // It is just a slash or a drive letter with a slash
+    return dir;
+  } else {
+    // It is a full dirname, strip trailing slash
+    return dir.substring(0, dir.length - 1);
+  }
+};
+
+
+exports.basename = function(path, ext) {
+  var f = splitPathRe.exec(path)[2] || '';
+  // TODO: make this comparison case-insensitive on windows?
+  if (ext && f.substr(-1 * ext.length) === ext) {
+    f = f.substr(0, f.length - ext.length);
+  }
+  return f;
+};
+
+
+exports.extname = function(path) {
+  return splitPathRe.exec(path)[3] || '';
+};
+
+});
+
+require.define("crypto", function (require, module, exports, __dirname, __filename) {
+module.exports = require("crypto-browserify")
+});
+
+require.define("/node_modules/crypto-browserify/package.json", function (require, module, exports, __dirname, __filename) {
+module.exports = {}
+});
+
+require.define("/node_modules/crypto-browserify/index.js", function (require, module, exports, __dirname, __filename) {
+var sha = require('./sha')
+
+var algorithms = {
+  sha1: {
+    hex: sha.hex_sha1,
+    binary: sha.b64_sha1,
+    ascii: sha.str_sha1
+  }
+}
+
+function error () {
+  var m = [].slice.call(arguments).join(' ')
+  throw new Error([
+    m,
+    'we accept pull requests',
+    'http://github.com/dominictarr/crypto-browserify'
+    ].join('\n'))
+}
+
+exports.createHash = function (alg) {
+  alg = alg || 'sha1'
+  if(!algorithms[alg])
+    error('algorithm:', alg, 'is not yet supported')
+  var s = ''
+  _alg = algorithms[alg]
+  return {
+    update: function (data) {
+      s += data
+      return this
+    },
+    digest: function (enc) {
+      enc = enc || 'binary'
+      var fn 
+      if(!(fn = _alg[enc]))
+        error('encoding:', enc , 'is not yet supported for algorithm', alg)
+      var r = fn(s)
+      s = null //not meant to use the hash after you've called digest.
+      return r
+    }
+  }
+}
+// the least I can do is make error messages for the rest of the node.js/crypto api.
+;['createCredentials'
+, 'createHmac'
+, 'createCypher'
+, 'createCypheriv'
+, 'createDecipher'
+, 'createDecipheriv'
+, 'createSign'
+, 'createVerify'
+, 'createDeffieHellman',
+, 'pbkdf2',
+, 'randomBytes' ].forEach(function (name) {
+  exports[name] = function () {
+    error('sorry,', name, 'is not implemented yet')
+  }
+})
+
+});
+
+require.define("/node_modules/crypto-browserify/sha.js", function (require, module, exports, __dirname, __filename) {
+/*
+ * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
+ * in FIPS PUB 180-1
+ * Version 2.1a Copyright Paul Johnston 2000 - 2002.
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ * Distributed under the BSD License
+ * See http://pajhome.org.uk/crypt/md5 for details.
+ */
+
+exports.hex_sha1 = hex_sha1;
+exports.b64_sha1 = b64_sha1;
+exports.str_sha1 = str_sha1;
+exports.hex_hmac_sha1 = hex_hmac_sha1;
+exports.b64_hmac_sha1 = b64_hmac_sha1;
+exports.str_hmac_sha1 = str_hmac_sha1;
+
+/*
+ * Configurable variables. You may need to tweak these to be compatible with
+ * the server-side, but the defaults work in most cases.
+ */
+var hexcase = 0;  /* hex output format. 0 - lowercase; 1 - uppercase        */
+var b64pad  = ""; /* base-64 pad character. "=" for strict RFC compliance   */
+var chrsz   = 8;  /* bits per input character. 8 - ASCII; 16 - Unicode      */
+
+/*
+ * These are the functions you'll usually want to call
+ * They take string arguments and return either hex or base-64 encoded strings
+ */
+function hex_sha1(s){return binb2hex(core_sha1(str2binb(s),s.length * chrsz));}
+function b64_sha1(s){return binb2b64(core_sha1(str2binb(s),s.length * chrsz));}
+function str_sha1(s){return binb2str(core_sha1(str2binb(s),s.length * chrsz));}
+function hex_hmac_sha1(key, data){ return binb2hex(core_hmac_sha1(key, data));}
+function b64_hmac_sha1(key, data){ return binb2b64(core_hmac_sha1(key, data));}
+function str_hmac_sha1(key, data){ return binb2str(core_hmac_sha1(key, data));}
+
+/*
+ * Perform a simple self-test to see if the VM is working
+ */
+function sha1_vm_test()
+{
+  return hex_sha1("abc") == "a9993e364706816aba3e25717850c26c9cd0d89d";
+}
+
+/*
+ * Calculate the SHA-1 of an array of big-endian words, and a bit length
+ */
+function core_sha1(x, len)
+{
+  /* append padding */
+  x[len >> 5] |= 0x80 << (24 - len % 32);
+  x[((len + 64 >> 9) << 4) + 15] = len;
+
+  var w = Array(80);
+  var a =  1732584193;
+  var b = -271733879;
+  var c = -1732584194;
+  var d =  271733878;
+  var e = -1009589776;
+
+  for(var i = 0; i < x.length; i += 16)
+  {
+    var olda = a;
+    var oldb = b;
+    var oldc = c;
+    var oldd = d;
+    var olde = e;
+
+    for(var j = 0; j < 80; j++)
+    {
+      if(j < 16) w[j] = x[i + j];
+      else w[j] = rol(w[j-3] ^ w[j-8] ^ w[j-14] ^ w[j-16], 1);
+      var t = safe_add(safe_add(rol(a, 5), sha1_ft(j, b, c, d)),
+                       safe_add(safe_add(e, w[j]), sha1_kt(j)));
+      e = d;
+      d = c;
+      c = rol(b, 30);
+      b = a;
+      a = t;
+    }
+
+    a = safe_add(a, olda);
+    b = safe_add(b, oldb);
+    c = safe_add(c, oldc);
+    d = safe_add(d, oldd);
+    e = safe_add(e, olde);
+  }
+  return Array(a, b, c, d, e);
+
+}
+
+/*
+ * Perform the appropriate triplet combination function for the current
+ * iteration
+ */
+function sha1_ft(t, b, c, d)
+{
+  if(t < 20) return (b & c) | ((~b) & d);
+  if(t < 40) return b ^ c ^ d;
+  if(t < 60) return (b & c) | (b & d) | (c & d);
+  return b ^ c ^ d;
+}
+
+/*
+ * Determine the appropriate additive constant for the current iteration
+ */
+function sha1_kt(t)
+{
+  return (t < 20) ?  1518500249 : (t < 40) ?  1859775393 :
+         (t < 60) ? -1894007588 : -899497514;
+}
+
+/*
+ * Calculate the HMAC-SHA1 of a key and some data
+ */
+function core_hmac_sha1(key, data)
+{
+  var bkey = str2binb(key);
+  if(bkey.length > 16) bkey = core_sha1(bkey, key.length * chrsz);
+
+  var ipad = Array(16), opad = Array(16);
+  for(var i = 0; i < 16; i++)
+  {
+    ipad[i] = bkey[i] ^ 0x36363636;
+    opad[i] = bkey[i] ^ 0x5C5C5C5C;
+  }
+
+  var hash = core_sha1(ipad.concat(str2binb(data)), 512 + data.length * chrsz);
+  return core_sha1(opad.concat(hash), 512 + 160);
+}
+
+/*
+ * Add integers, wrapping at 2^32. This uses 16-bit operations internally
+ * to work around bugs in some JS interpreters.
+ */
+function safe_add(x, y)
+{
+  var lsw = (x & 0xFFFF) + (y & 0xFFFF);
+  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+  return (msw << 16) | (lsw & 0xFFFF);
+}
+
+/*
+ * Bitwise rotate a 32-bit number to the left.
+ */
+function rol(num, cnt)
+{
+  return (num << cnt) | (num >>> (32 - cnt));
+}
+
+/*
+ * Convert an 8-bit or 16-bit string to an array of big-endian words
+ * In 8-bit function, characters >255 have their hi-byte silently ignored.
+ */
+function str2binb(str)
+{
+  var bin = Array();
+  var mask = (1 << chrsz) - 1;
+  for(var i = 0; i < str.length * chrsz; i += chrsz)
+    bin[i>>5] |= (str.charCodeAt(i / chrsz) & mask) << (32 - chrsz - i%32);
+  return bin;
+}
+
+/*
+ * Convert an array of big-endian words to a string
+ */
+function binb2str(bin)
+{
+  var str = "";
+  var mask = (1 << chrsz) - 1;
+  for(var i = 0; i < bin.length * 32; i += chrsz)
+    str += String.fromCharCode((bin[i>>5] >>> (32 - chrsz - i%32)) & mask);
+  return str;
+}
+
+/*
+ * Convert an array of big-endian words to a hex string.
+ */
+function binb2hex(binarray)
+{
+  var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
+  var str = "";
+  for(var i = 0; i < binarray.length * 4; i++)
+  {
+    str += hex_tab.charAt((binarray[i>>2] >> ((3 - i%4)*8+4)) & 0xF) +
+           hex_tab.charAt((binarray[i>>2] >> ((3 - i%4)*8  )) & 0xF);
+  }
+  return str;
+}
+
+/*
+ * Convert an array of big-endian words to a base-64 string
+ */
+function binb2b64(binarray)
+{
+  var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  var str = "";
+  for(var i = 0; i < binarray.length * 4; i += 3)
+  {
+    var triplet = (((binarray[i   >> 2] >> 8 * (3 -  i   %4)) & 0xFF) << 16)
+                | (((binarray[i+1 >> 2] >> 8 * (3 - (i+1)%4)) & 0xFF) << 8 )
+                |  ((binarray[i+2 >> 2] >> 8 * (3 - (i+2)%4)) & 0xFF);
+    for(var j = 0; j < 4; j++)
+    {
+      if(i * 8 + j * 6 > binarray.length * 32) str += b64pad;
+      else str += tab.charAt((triplet >> 6*(3-j)) & 0x3F);
+    }
+  }
+  return str;
+}
+
+
+});
+
+require.define("/test.js", function (require, module, exports, __dirname, __filename) {
+    var crypto = require('crypto')
+var abc = crypto.createHash('sha1').update('abc').digest('hex')
+console.log(abc)
+//require('hello').inlineCall().call2()
+
+});
+require("/test.js");

Skills/@be/be/node_modules/crypto-browserify/example/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html>
+<script src=bundle.js></script>
+<body>
+  <pre>
+  require('crypto').createHash('sha1').update('abc').digest('hex') == '<span id=ans></span>'
+  </pre>
+</body>
+<script>
+  document.getElementById('ans').innerHTML = require('crypto').createHash('sha1').update('abc').digest('hex')
+</script>
+</html>

Skills/@be/be/node_modules/crypto-browserify/example/test.js

@@ -0,0 +1,4 @@
+var crypto = require('crypto')
+var abc = crypto.createHash('sha1').update('abc').digest('hex')
+console.log(abc)
+//require('hello').inlineCall().call2()

Skills/@be/be/node_modules/crypto-browserify/helpers.js

@@ -0,0 +1,35 @@
+var Buffer = require('buffer').Buffer;
+var intSize = 4;
+var zeroBuffer = new Buffer(intSize); zeroBuffer.fill(0);
+var chrsz = 8;
+
+function toArray(buf, bigEndian) {
+  if ((buf.length % intSize) !== 0) {
+    var len = buf.length + (intSize - (buf.length % intSize));
+    buf = Buffer.concat([buf, zeroBuffer], len);
+  }
+
+  var arr = [];
+  var fn = bigEndian ? buf.readInt32BE : buf.readInt32LE;
+  for (var i = 0; i < buf.length; i += intSize) {
+    arr.push(fn.call(buf, i));
+  }
+  return arr;
+}
+
+function toBuffer(arr, size, bigEndian) {
+  var buf = new Buffer(size);
+  var fn = bigEndian ? buf.writeInt32BE : buf.writeInt32LE;
+  for (var i = 0; i < arr.length; i++) {
+    fn.call(buf, arr[i], i * 4, true);
+  }
+  return buf;
+}
+
+function hash(buf, fn, hashSize, bigEndian) {
+  if (!Buffer.isBuffer(buf)) buf = new Buffer(buf);
+  var arr = fn(toArray(buf, bigEndian), buf.length * chrsz);
+  return toBuffer(arr, hashSize, bigEndian);
+}
+
+module.exports = { hash: hash };

Skills/@be/be/node_modules/crypto-browserify/index.js

@@ -0,0 +1,97 @@
+var Buffer = require('buffer').Buffer
+var sha = require('./sha')
+var sha256 = require('./sha256')
+var rng = require('./rng')
+var md5 = require('./md5')
+
+var algorithms = {
+  sha1: sha,
+  sha256: sha256,
+  md5: md5
+}
+
+var blocksize = 64
+var zeroBuffer = new Buffer(blocksize); zeroBuffer.fill(0)
+function hmac(fn, key, data) {
+  if(!Buffer.isBuffer(key)) key = new Buffer(key)
+  if(!Buffer.isBuffer(data)) data = new Buffer(data)
+
+  if(key.length > blocksize) {
+    key = fn(key)
+  } else if(key.length < blocksize) {
+    key = Buffer.concat([key, zeroBuffer], blocksize)
+  }
+
+  var ipad = new Buffer(blocksize), opad = new Buffer(blocksize)
+  for(var i = 0; i < blocksize; i++) {
+    ipad[i] = key[i] ^ 0x36
+    opad[i] = key[i] ^ 0x5C
+  }
+
+  var hash = fn(Buffer.concat([ipad, data]))
+  return fn(Buffer.concat([opad, hash]))
+}
+
+function hash(alg, key) {
+  alg = alg || 'sha1'
+  var fn = algorithms[alg]
+  var bufs = []
+  var length = 0
+  if(!fn) error('algorithm:', alg, 'is not yet supported')
+  return {
+    update: function (data) {
+      if(!Buffer.isBuffer(data)) data = new Buffer(data)
+        
+      bufs.push(data)
+      length += data.length
+      return this
+    },
+    digest: function (enc) {
+      var buf = Buffer.concat(bufs)
+      var r = key ? hmac(fn, key, buf) : fn(buf)
+      bufs = null
+      return enc ? r.toString(enc) : r
+    }
+  }
+}
+
+function error () {
+  var m = [].slice.call(arguments).join(' ')
+  throw new Error([
+    m,
+    'we accept pull requests',
+    'http://github.com/dominictarr/crypto-browserify'
+    ].join('\n'))
+}
+
+exports.createHash = function (alg) { return hash(alg) }
+exports.createHmac = function (alg, key) { return hash(alg, key) }
+exports.randomBytes = function(size, callback) {
+  if (callback && callback.call) {
+    try {
+      callback.call(this, undefined, new Buffer(rng(size)))
+    } catch (err) { callback(err) }
+  } else {
+    return new Buffer(rng(size))
+  }
+}
+
+function each(a, f) {
+  for(var i in a)
+    f(a[i], i)
+}
+
+// the least I can do is make error messages for the rest of the node.js/crypto api.
+each(['createCredentials'
+, 'createCipher'
+, 'createCipheriv'
+, 'createDecipher'
+, 'createDecipheriv'
+, 'createSign'
+, 'createVerify'
+, 'createDiffieHellman'
+, 'pbkdf2'], function (name) {
+  exports[name] = function () {
+    error('sorry,', name, 'is not implemented yet')
+  }
+})

Skills/@be/be/node_modules/crypto-browserify/md5.js

@@ -0,0 +1,163 @@
+/*
+ * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
+ * Digest Algorithm, as defined in RFC 1321.
+ * Version 2.1 Copyright (C) Paul Johnston 1999 - 2002.
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ * Distributed under the BSD License
+ * See http://pajhome.org.uk/crypt/md5 for more info.
+ */
+
+var helpers = require('./helpers');
+
+/*
+ * Perform a simple self-test to see if the VM is working
+ */
+function md5_vm_test()
+{
+  return hex_md5("abc") == "900150983cd24fb0d6963f7d28e17f72";
+}
+
+/*
+ * Calculate the MD5 of an array of little-endian words, and a bit length
+ */
+function core_md5(x, len)
+{
+  /* append padding */
+  x[len >> 5] |= 0x80 << ((len) % 32);
+  x[(((len + 64) >>> 9) << 4) + 14] = len;
+
+  var a =  1732584193;
+  var b = -271733879;
+  var c = -1732584194;
+  var d =  271733878;
+
+  for(var i = 0; i < x.length; i += 16)
+  {
+    var olda = a;
+    var oldb = b;
+    var oldc = c;
+    var oldd = d;
+
+    a = md5_ff(a, b, c, d, x[i+ 0], 7 , -680876936);
+    d = md5_ff(d, a, b, c, x[i+ 1], 12, -389564586);
+    c = md5_ff(c, d, a, b, x[i+ 2], 17,  606105819);
+    b = md5_ff(b, c, d, a, x[i+ 3], 22, -1044525330);
+    a = md5_ff(a, b, c, d, x[i+ 4], 7 , -176418897);
+    d = md5_ff(d, a, b, c, x[i+ 5], 12,  1200080426);
+    c = md5_ff(c, d, a, b, x[i+ 6], 17, -1473231341);
+    b = md5_ff(b, c, d, a, x[i+ 7], 22, -45705983);
+    a = md5_ff(a, b, c, d, x[i+ 8], 7 ,  1770035416);
+    d = md5_ff(d, a, b, c, x[i+ 9], 12, -1958414417);
+    c = md5_ff(c, d, a, b, x[i+10], 17, -42063);
+    b = md5_ff(b, c, d, a, x[i+11], 22, -1990404162);
+    a = md5_ff(a, b, c, d, x[i+12], 7 ,  1804603682);
+    d = md5_ff(d, a, b, c, x[i+13], 12, -40341101);
+    c = md5_ff(c, d, a, b, x[i+14], 17, -1502002290);
+    b = md5_ff(b, c, d, a, x[i+15], 22,  1236535329);
+
+    a = md5_gg(a, b, c, d, x[i+ 1], 5 , -165796510);
+    d = md5_gg(d, a, b, c, x[i+ 6], 9 , -1069501632);
+    c = md5_gg(c, d, a, b, x[i+11], 14,  643717713);
+    b = md5_gg(b, c, d, a, x[i+ 0], 20, -373897302);
+    a = md5_gg(a, b, c, d, x[i+ 5], 5 , -701558691);
+    d = md5_gg(d, a, b, c, x[i+10], 9 ,  38016083);
+    c = md5_gg(c, d, a, b, x[i+15], 14, -660478335);
+    b = md5_gg(b, c, d, a, x[i+ 4], 20, -405537848);
+    a = md5_gg(a, b, c, d, x[i+ 9], 5 ,  568446438);
+    d = md5_gg(d, a, b, c, x[i+14], 9 , -1019803690);
+    c = md5_gg(c, d, a, b, x[i+ 3], 14, -187363961);
+    b = md5_gg(b, c, d, a, x[i+ 8], 20,  1163531501);
+    a = md5_gg(a, b, c, d, x[i+13], 5 , -1444681467);
+    d = md5_gg(d, a, b, c, x[i+ 2], 9 , -51403784);
+    c = md5_gg(c, d, a, b, x[i+ 7], 14,  1735328473);
+    b = md5_gg(b, c, d, a, x[i+12], 20, -1926607734);
+
+    a = md5_hh(a, b, c, d, x[i+ 5], 4 , -378558);
+    d = md5_hh(d, a, b, c, x[i+ 8], 11, -2022574463);
+    c = md5_hh(c, d, a, b, x[i+11], 16,  1839030562);
+    b = md5_hh(b, c, d, a, x[i+14], 23, -35309556);
+    a = md5_hh(a, b, c, d, x[i+ 1], 4 , -1530992060);
+    d = md5_hh(d, a, b, c, x[i+ 4], 11,  1272893353);
+    c = md5_hh(c, d, a, b, x[i+ 7], 16, -155497632);
+    b = md5_hh(b, c, d, a, x[i+10], 23, -1094730640);
+    a = md5_hh(a, b, c, d, x[i+13], 4 ,  681279174);
+    d = md5_hh(d, a, b, c, x[i+ 0], 11, -358537222);
+    c = md5_hh(c, d, a, b, x[i+ 3], 16, -722521979);
+    b = md5_hh(b, c, d, a, x[i+ 6], 23,  76029189);
+    a = md5_hh(a, b, c, d, x[i+ 9], 4 , -640364487);
+    d = md5_hh(d, a, b, c, x[i+12], 11, -421815835);
+    c = md5_hh(c, d, a, b, x[i+15], 16,  530742520);
+    b = md5_hh(b, c, d, a, x[i+ 2], 23, -995338651);
+
+    a = md5_ii(a, b, c, d, x[i+ 0], 6 , -198630844);
+    d = md5_ii(d, a, b, c, x[i+ 7], 10,  1126891415);
+    c = md5_ii(c, d, a, b, x[i+14], 15, -1416354905);
+    b = md5_ii(b, c, d, a, x[i+ 5], 21, -57434055);
+    a = md5_ii(a, b, c, d, x[i+12], 6 ,  1700485571);
+    d = md5_ii(d, a, b, c, x[i+ 3], 10, -1894986606);
+    c = md5_ii(c, d, a, b, x[i+10], 15, -1051523);
+    b = md5_ii(b, c, d, a, x[i+ 1], 21, -2054922799);
+    a = md5_ii(a, b, c, d, x[i+ 8], 6 ,  1873313359);
+    d = md5_ii(d, a, b, c, x[i+15], 10, -30611744);
+    c = md5_ii(c, d, a, b, x[i+ 6], 15, -1560198380);
+    b = md5_ii(b, c, d, a, x[i+13], 21,  1309151649);
+    a = md5_ii(a, b, c, d, x[i+ 4], 6 , -145523070);
+    d = md5_ii(d, a, b, c, x[i+11], 10, -1120210379);
+    c = md5_ii(c, d, a, b, x[i+ 2], 15,  718787259);
+    b = md5_ii(b, c, d, a, x[i+ 9], 21, -343485551);
+
+    a = safe_add(a, olda);
+    b = safe_add(b, oldb);
+    c = safe_add(c, oldc);
+    d = safe_add(d, oldd);
+  }
+  return Array(a, b, c, d);
+
+}
+
+/*
+ * These functions implement the four basic operations the algorithm uses.
+ */
+function md5_cmn(q, a, b, x, s, t)
+{
+  return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s),b);
+}
+function md5_ff(a, b, c, d, x, s, t)
+{
+  return md5_cmn((b & c) | ((~b) & d), a, b, x, s, t);
+}
+function md5_gg(a, b, c, d, x, s, t)
+{
+  return md5_cmn((b & d) | (c & (~d)), a, b, x, s, t);
+}
+function md5_hh(a, b, c, d, x, s, t)
+{
+  return md5_cmn(b ^ c ^ d, a, b, x, s, t);
+}
+function md5_ii(a, b, c, d, x, s, t)
+{
+  return md5_cmn(c ^ (b | (~d)), a, b, x, s, t);
+}
+
+/*
+ * Add integers, wrapping at 2^32. This uses 16-bit operations internally
+ * to work around bugs in some JS interpreters.
+ */
+function safe_add(x, y)
+{
+  var lsw = (x & 0xFFFF) + (y & 0xFFFF);
+  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+  return (msw << 16) | (lsw & 0xFFFF);
+}
+
+/*
+ * Bitwise rotate a 32-bit number to the left.
+ */
+function bit_rol(num, cnt)
+{
+  return (num << cnt) | (num >>> (32 - cnt));
+}
+
+module.exports = function md5(buf) {
+  return helpers.hash(buf, core_md5, 16);
+};

Skills/@be/be/node_modules/crypto-browserify/package.json

@@ -0,0 +1,37 @@
+{
+  "author": "Dominic Tarr <dominic.tarr@gmail.com> (dominictarr.com)",
+  "name": "crypto-browserify",
+  "description": "partial implementation of crypto for the browser",
+  "version": "1.0.9",
+  "homepage": "https://github.com/dominictarr/crypto-browserify",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/dominictarr/crypto-browserify.git"
+  },
+  "scripts": {
+    "test": "node test/node.js"
+  },
+  "engines": {
+    "node": "*"
+  },
+  "dependencies": {
+  },
+  "devDependencies": {
+    "brfs": "~0.0.8",
+    "tape": "~1.0.4"
+  },
+  "testling": {
+    "files": "test/browser.js",
+    "browsers": [
+      "ie/8..latest",
+      "chrome/20..latest",
+      "firefox/10..latest",
+      "safari/latest",
+      "opera/11.0..latest",
+      "iphone/6",
+      "ipad/6"
+    ]
+  },
+  "optionalDependencies": {},
+  "license": "MIT"
+}

Skills/@be/be/node_modules/crypto-browserify/readme.markdown

@@ -0,0 +1,20 @@
+# crypto-browserify
+
+A (partial) port of `crypto` to the browser.
+
+
+[![travis](https://secure.travis-ci.org/dominictarr/crypto-browserify.png?branch=master)](https://travis-ci.org/dominictarr/crypto-browserify)
+
+[![browser support](http://ci.testling.com/dominictarr/crypto-browserify.png)](http://ci.testling.com/dominictarr/crypto-browserify)
+
+
+Basically, I found some crypto implemented in JS lieing on the internet somewhere
+and wrapped it in the part of the `crypto` api that I am currently using.
+
+In a way that will be compatible with [browserify](https://github.com/substack/node-browserify/).
+
+I will extend this if I need more features, or if anyone else wants to extend this,
+I will add you as a maintainer.
+
+Provided that you agree that it should replicate the [node.js/crypto](http://nodejs.org/api/crypto.html) api exactly, of course.
+

Skills/@be/be/node_modules/crypto-browserify/rng.js

@@ -0,0 +1,31 @@
+// Original code adapted from Robert Kieffer.
+// details at https://github.com/broofa/node-uuid
+(function() {
+  var _global = this;
+
+  var mathRNG, whatwgRNG;
+
+  // NOTE: Math.random() does not guarantee "cryptographic quality"
+  mathRNG = function(size) {
+    var bytes = new Array(size);
+    var r;
+
+    for (var i = 0, r; i < size; i++) {
+      if ((i & 0x03) == 0) r = Math.random() * 0x100000000;
+      bytes[i] = r >>> ((i & 0x03) << 3) & 0xff;
+    }
+
+    return bytes;
+  }
+
+  if (_global.crypto && crypto.getRandomValues) {
+    whatwgRNG = function(size) {
+      var bytes = new Uint8Array(size);
+      crypto.getRandomValues(bytes);
+      return bytes;
+    }
+  }
+
+  module.exports = whatwgRNG || mathRNG;
+
+}())

Skills/@be/be/node_modules/crypto-browserify/sha.js

@@ -0,0 +1,101 @@
+/*
+ * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
+ * in FIPS PUB 180-1
+ * Version 2.1a Copyright Paul Johnston 2000 - 2002.
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ * Distributed under the BSD License
+ * See http://pajhome.org.uk/crypt/md5 for details.
+ */
+
+var helpers = require('./helpers');
+
+/*
+ * Calculate the SHA-1 of an array of big-endian words, and a bit length
+ */
+function core_sha1(x, len)
+{
+  /* append padding */
+  x[len >> 5] |= 0x80 << (24 - len % 32);
+  x[((len + 64 >> 9) << 4) + 15] = len;
+
+  var w = Array(80);
+  var a =  1732584193;
+  var b = -271733879;
+  var c = -1732584194;
+  var d =  271733878;
+  var e = -1009589776;
+
+  for(var i = 0; i < x.length; i += 16)
+  {
+    var olda = a;
+    var oldb = b;
+    var oldc = c;
+    var oldd = d;
+    var olde = e;
+
+    for(var j = 0; j < 80; j++)
+    {
+      if(j < 16) w[j] = x[i + j];
+      else w[j] = rol(w[j-3] ^ w[j-8] ^ w[j-14] ^ w[j-16], 1);
+      var t = safe_add(safe_add(rol(a, 5), sha1_ft(j, b, c, d)),
+                       safe_add(safe_add(e, w[j]), sha1_kt(j)));
+      e = d;
+      d = c;
+      c = rol(b, 30);
+      b = a;
+      a = t;
+    }
+
+    a = safe_add(a, olda);
+    b = safe_add(b, oldb);
+    c = safe_add(c, oldc);
+    d = safe_add(d, oldd);
+    e = safe_add(e, olde);
+  }
+  return Array(a, b, c, d, e);
+
+}
+
+/*
+ * Perform the appropriate triplet combination function for the current
+ * iteration
+ */
+function sha1_ft(t, b, c, d)
+{
+  if(t < 20) return (b & c) | ((~b) & d);
+  if(t < 40) return b ^ c ^ d;
+  if(t < 60) return (b & c) | (b & d) | (c & d);
+  return b ^ c ^ d;
+}
+
+/*
+ * Determine the appropriate additive constant for the current iteration
+ */
+function sha1_kt(t)
+{
+  return (t < 20) ?  1518500249 : (t < 40) ?  1859775393 :
+         (t < 60) ? -1894007588 : -899497514;
+}
+
+/*
+ * Add integers, wrapping at 2^32. This uses 16-bit operations internally
+ * to work around bugs in some JS interpreters.
+ */
+function safe_add(x, y)
+{
+  var lsw = (x & 0xFFFF) + (y & 0xFFFF);
+  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+  return (msw << 16) | (lsw & 0xFFFF);
+}
+
+/*
+ * Bitwise rotate a 32-bit number to the left.
+ */
+function rol(num, cnt)
+{
+  return (num << cnt) | (num >>> (32 - cnt));
+}
+
+module.exports = function sha1(buf) {
+  return helpers.hash(buf, core_sha1, 20, true);
+};

Skills/@be/be/node_modules/crypto-browserify/sha256.js

@@ -0,0 +1,79 @@
+
+/**
+ * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
+ * in FIPS 180-2
+ * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ *
+ */
+
+var helpers = require('./helpers');
+
+var safe_add = function(x, y) {
+  var lsw = (x & 0xFFFF) + (y & 0xFFFF);
+  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+  return (msw << 16) | (lsw & 0xFFFF);
+};
+
+var S = function(X, n) {
+  return (X >>> n) | (X << (32 - n));
+};
+
+var R = function(X, n) {
+  return (X >>> n);
+};
+
+var Ch = function(x, y, z) {
+  return ((x & y) ^ ((~x) & z));
+};
+
+var Maj = function(x, y, z) {
+  return ((x & y) ^ (x & z) ^ (y & z));
+};
+
+var Sigma0256 = function(x) {
+  return (S(x, 2) ^ S(x, 13) ^ S(x, 22));
+};
+
+var Sigma1256 = function(x) {
+  return (S(x, 6) ^ S(x, 11) ^ S(x, 25));
+};
+
+var Gamma0256 = function(x) {
+  return (S(x, 7) ^ S(x, 18) ^ R(x, 3));
+};
+
+var Gamma1256 = function(x) {
+  return (S(x, 17) ^ S(x, 19) ^ R(x, 10));
+};
+
+var core_sha256 = function(m, l) {
+  var K = new Array(0x428A2F98,0x71374491,0xB5C0FBCF,0xE9B5DBA5,0x3956C25B,0x59F111F1,0x923F82A4,0xAB1C5ED5,0xD807AA98,0x12835B01,0x243185BE,0x550C7DC3,0x72BE5D74,0x80DEB1FE,0x9BDC06A7,0xC19BF174,0xE49B69C1,0xEFBE4786,0xFC19DC6,0x240CA1CC,0x2DE92C6F,0x4A7484AA,0x5CB0A9DC,0x76F988DA,0x983E5152,0xA831C66D,0xB00327C8,0xBF597FC7,0xC6E00BF3,0xD5A79147,0x6CA6351,0x14292967,0x27B70A85,0x2E1B2138,0x4D2C6DFC,0x53380D13,0x650A7354,0x766A0ABB,0x81C2C92E,0x92722C85,0xA2BFE8A1,0xA81A664B,0xC24B8B70,0xC76C51A3,0xD192E819,0xD6990624,0xF40E3585,0x106AA070,0x19A4C116,0x1E376C08,0x2748774C,0x34B0BCB5,0x391C0CB3,0x4ED8AA4A,0x5B9CCA4F,0x682E6FF3,0x748F82EE,0x78A5636F,0x84C87814,0x8CC70208,0x90BEFFFA,0xA4506CEB,0xBEF9A3F7,0xC67178F2);
+  var HASH = new Array(0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19);
+    var W = new Array(64);
+    var a, b, c, d, e, f, g, h, i, j;
+    var T1, T2;
+  /* append padding */
+  m[l >> 5] |= 0x80 << (24 - l % 32);
+  m[((l + 64 >> 9) << 4) + 15] = l;
+  for (var i = 0; i < m.length; i += 16) {
+    a = HASH[0]; b = HASH[1]; c = HASH[2]; d = HASH[3]; e = HASH[4]; f = HASH[5]; g = HASH[6]; h = HASH[7];
+    for (var j = 0; j < 64; j++) {
+      if (j < 16) {
+        W[j] = m[j + i];
+      } else {
+        W[j] = safe_add(safe_add(safe_add(Gamma1256(W[j - 2]), W[j - 7]), Gamma0256(W[j - 15])), W[j - 16]);
+      }
+      T1 = safe_add(safe_add(safe_add(safe_add(h, Sigma1256(e)), Ch(e, f, g)), K[j]), W[j]);
+      T2 = safe_add(Sigma0256(a), Maj(a, b, c));
+      h = g; g = f; f = e; e = safe_add(d, T1); d = c; c = b; b = a; a = safe_add(T1, T2);
+    }
+    HASH[0] = safe_add(a, HASH[0]); HASH[1] = safe_add(b, HASH[1]); HASH[2] = safe_add(c, HASH[2]); HASH[3] = safe_add(d, HASH[3]);
+    HASH[4] = safe_add(e, HASH[4]); HASH[5] = safe_add(f, HASH[5]); HASH[6] = safe_add(g, HASH[6]); HASH[7] = safe_add(h, HASH[7]);
+  }
+  return HASH;
+};
+
+module.exports = function sha256(buf) {
+  return helpers.hash(buf, core_sha256, 32, true);
+};

Skills/@be/be/node_modules/crypto-browserify/test/browser.js

@@ -0,0 +1,100 @@
+var test = require('tape');
+var Buffer = require('buffer').Buffer;
+
+var crypto = require('../');
+
+var algorithms = ['sha1', 'sha256', 'md5'];
+var encodings = ['binary', 'hex', 'base64'];
+
+
+// We can't compare against node's crypto library directly because when
+// using testling we only have another version of crypto-browserify to
+// check against. So we'll use a cached version of the expected values
+// generated by node crypto.
+var EXPECTED = {};
+
+EXPECTED['sha1-hash-binary'] = atob('qvTGHdzF6KLavt4PO0gs2a6pQ00=');
+EXPECTED['sha1-hash-hex'] = 'aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d';
+EXPECTED['sha1-hash-base64'] = 'qvTGHdzF6KLavt4PO0gs2a6pQ00=';
+
+EXPECTED['sha256-hash-binary'] = atob('LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ=');
+EXPECTED['sha256-hash-hex'] = '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824';
+EXPECTED['sha256-hash-base64'] = 'LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ=';
+
+EXPECTED['md5-hash-binary'] = atob('XUFAKrxLKna5cZ2REBfFkg==');
+EXPECTED['md5-hash-hex'] = '5d41402abc4b2a76b9719d911017c592';
+EXPECTED['md5-hash-base64'] = 'XUFAKrxLKna5cZ2REBfFkg==';
+
+EXPECTED['sha1-hmac-binary'] = atob('URIFXAX5RPhXVe/FzYlw4ZTp9Fs=');
+EXPECTED['sha1-hmac-hex'] = '5112055c05f944f85755efc5cd8970e194e9f45b';
+EXPECTED['sha1-hmac-base64'] = 'URIFXAX5RPhXVe/FzYlw4ZTp9Fs=';
+
+EXPECTED['sha256-hmac-binary'] = atob('iKqz7ejTrflNJquQ07r9SiCDBww7zOnAFO4EpEOEfAs=');
+EXPECTED['sha256-hmac-hex'] = '88aab3ede8d3adf94d26ab90d3bafd4a2083070c3bcce9c014ee04a443847c0b';
+EXPECTED['sha256-hmac-base64'] = 'iKqz7ejTrflNJquQ07r9SiCDBww7zOnAFO4EpEOEfAs=';
+
+EXPECTED['md5-hmac-binary'] = atob('ut5jhjxh7QsxZYBuzWrO/A==');
+EXPECTED['md5-hmac-hex'] = 'bade63863c61ed0b3165806ecd6acefc';
+EXPECTED['md5-hmac-base64'] = 'ut5jhjxh7QsxZYBuzWrO/A==';
+
+EXPECTED['md5-with-binary'] = '27549c8ff29ca52f7957f89c328dbb6d';
+EXPECTED['sha1-with-binary'] = '4fa10dda29053b237b5d9703151c852c61e6d8d7';
+EXPECTED['sha256-with-binary'] = '424ff84246aabc1560a2881b9664108dfe26784c762d930c4ff396c085f4183b';
+
+EXPECTED['md5-empty-string'] = 'd41d8cd98f00b204e9800998ecf8427e';
+EXPECTED['sha1-empty-string'] = 'da39a3ee5e6b4b0d3255bfef95601890afd80709';
+EXPECTED['sha256-empty-string'] = 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855';
+
+
+algorithms.forEach(function (algorithm) {
+    encodings.forEach(function (encoding) {
+        test(algorithm + ' hash using ' + encoding, function (t) {
+            t.plan(1);
+            var actual = crypto.createHash(algorithm).update('hello', 'utf-8').digest(encoding);
+            var expected = EXPECTED[algorithm + '-hash-' + encoding];
+            t.equal(actual, expected);
+            t.end();
+        });
+
+        test(algorithm + ' hmac using ' + encoding, function (t) {
+            t.plan(1);
+            var actual = crypto.createHmac(algorithm, 'secret').update('hello', 'utf-8').digest(encoding);
+            var expected = EXPECTED[algorithm + '-hmac-' + encoding];
+            t.equal(actual, expected);
+            t.end();
+        });
+    });
+
+    test(algorithm + ' with empty string', function (t) {
+        t.plan(1);
+        var actual = crypto.createHash(algorithm).update('', 'utf-8').digest('hex');
+        var expected = EXPECTED[algorithm + '-empty-string'];
+        t.equal(actual, expected);
+        t.end();
+    });
+
+    test(algorithm + ' with raw binary', function (t) {
+        t.plan(1);
+        var seed = 'hello';
+        for (var i = 0; i < 1000; i++) {
+            seed = crypto.createHash(algorithm).update(seed).digest('binary');
+        }
+        var actual = crypto.createHash(algorithm).update(seed).digest('hex');
+        var expected = EXPECTED[algorithm + '-with-binary'];
+        t.equal(actual, expected);
+        t.end();
+    });
+});
+
+
+test('randomBytes', function (t) {
+    t.plan(5);
+    t.equal(crypto.randomBytes(10).length, 10);
+    t.ok(crypto.randomBytes(10) instanceof Buffer);
+    crypto.randomBytes(10, function(ex, bytes) {
+        t.error(ex);
+        t.equal(bytes.length, 10);
+        t.ok(bytes instanceof Buffer);
+        t.end();
+  });
+});

Skills/@be/be/node_modules/crypto-browserify/test/node.js

@@ -0,0 +1,77 @@
+var test = require('tape');
+
+var crypto = require('crypto');
+var cryptoB = require('../');
+var fs = require('fs');
+
+function assertSame(name, fn) {
+    test(name, function (t) {
+        t.plan(1);
+        fn(crypto, function (err, expected) {
+            fn(cryptoB, function (err, actual) {
+                t.equal(actual, expected);
+                t.end();
+            });
+        });
+    });
+}
+
+var algorithms = ['sha1', 'sha256', 'md5'];
+var encodings = ['binary', 'hex', 'base64'];
+
+
+algorithms.forEach(function (algorithm) {
+    encodings.forEach(function (encoding) {
+        assertSame(algorithm + ' hash using ' + encoding, function (crypto, cb) {
+            cb(null, crypto.createHash(algorithm).update('hellø', 'utf-8').digest(encoding));
+        })
+
+        assertSame(algorithm + ' hmac using ' + encoding, function (crypto, cb) {
+            cb(null, crypto.createHmac(algorithm, 'secret').update('hellø', 'utf-8').digest(encoding))
+        })
+    });
+
+    assertSame(algorithm + ' with raw binary', function (crypto, cb) {
+        var seed = 'hellø';
+        for (var i = 0; i < 1000; i++) {
+            seed = crypto.createHash(algorithm).update(new Buffer(seed)).digest('binary');
+        }
+        cb(null, crypto.createHash(algorithm).update(new Buffer(seed)).digest('hex'));
+    });
+
+    assertSame(algorithm + ' empty string', function (crypto, cb) {
+        cb(null, crypto.createHash(algorithm).update('').digest('hex'));
+    });
+});
+
+function pad(n, w) {
+  n = n + ''; return new Array(w - n.length + 1).join('0') + n;
+}
+
+var vectors = fs.readdirSync(__dirname + '/vectors').sort().
+    filter(function (t) { return t.match(/\.dat$/); }).
+    map(function (t) { return fs.readFileSync(__dirname + '/vectors/' + t); });
+
+['md5', 'sha1', 'sha256'].forEach(function (algorithm) {
+    test(algorithm, function (t) {
+        function hash(data) { return cryptoB.createHash(algorithm).update(data).digest('hex'); }
+
+        var hashes = fs.readFileSync(__dirname + '/vectors/byte-hashes.' + algorithm).toString().split(/\r?\n/);
+        t.plan(vectors.length);
+        for (var i = 0; i < vectors.length; i++) {
+            t.equal(hash(vectors[i]), hashes[i], 'byte' + pad(i, 4) + '.dat');
+        }
+    });
+});
+
+test('randomBytes', function (t) {
+    t.plan(5);
+    t.equal(cryptoB.randomBytes(10).length, 10);
+    t.ok(cryptoB.randomBytes(10) instanceof Buffer);
+    cryptoB.randomBytes(10, function(ex, bytes) {
+        t.error(ex);
+        t.equal(bytes.length, 10);
+        t.ok(bytes instanceof Buffer);
+        t.end();
+  });
+});

Skills/@be/be/node_modules/crypto-browserify/test/package.json

@@ -0,0 +1,7 @@
+{
+  "browserify": {
+    "transform": [
+      "brfs"
+    ]
+  }
+}

Skills/@be/be/node_modules/crypto-browserify/test/simple.js

@@ -0,0 +1,36 @@
+var test = require("tape")
+
+var crypto = require('crypto')
+var cryptoB = require('../')
+
+function assertSame (fn) {
+  test(fn.name, function (t) {
+    t.plan(1)
+    fn(crypto, function (err, expected) {
+      fn(cryptoB, function (err, actual) {
+        t.equal(actual, expected)
+        t.end()
+      })
+    })
+  })
+}
+
+assertSame(function sha1 (crypto, cb) {
+  cb(null, crypto.createHash('sha1').update('hello', 'utf-8').digest('hex'))
+})
+
+assertSame(function md5(crypto, cb) {
+  cb(null, crypto.createHash('md5').update('hello', 'utf-8').digest('hex'))
+})
+
+test('randomBytes', function (t) {
+  t.plan(5)
+  t.equal(cryptoB.randomBytes(10).length, 10)
+  t.ok(cryptoB.randomBytes(10) instanceof Buffer)
+  cryptoB.randomBytes(10, function(ex, bytes) {
+    t.error(ex)
+    t.equal(bytes.length, 10)
+    t.ok(bytes instanceof Buffer)
+    t.end()
+  })
+})

Skills/@be/be/node_modules/crypto-browserify/test/vectors/Readme.txt

@@ -0,0 +1,25 @@
+
+File formats:
+
+There are two files included for this byte-oriented test.  
+One file contains the messages and the other file contains the hashes.
+
+The message files provided use "compact strings" to store the message values.  
+Compact strings are used to represented the messages in a compact form.  
+A compact string has the form
+	z || b || n(1) || n(2) || ... || n(z)
+where z>=0 that represents the number of n, b is either 0 or 1, and 
+each n(i) is a decimal integer representing a positive number.  
+The length of the compact string is given by the summation of the n(i).
+
+The compact string is interpreted as the representation of the bit string 
+consisting of b repeated n(1) times, followed by 1-b repeated n(2) times, 
+followed by b repeated n(3) times, and so on.
+
+Example:
+	M = 5 1 7 13 5 1 2
+	where z = 5 and b = 1.  Then the compact string M represents the bit string
+	1111111000000000000011111011
+	where 1 is repeated 7 times, 0 is repeated 13 times, 1 is repeated 5 times,
+	0 is repeated 1 time, and 1 is repeated 2 times.
+

Skills/@be/be/node_modules/crypto-browserify/test/vectors/byte-hashes.md5

@@ -0,0 +1,196 @@
+d41d8cd98f00b204e9800998ecf8427e
+c3e97dd6e97fb5125688c97f36720cbe
+038701ca277a9d4de87bff428dd30a12
+bc60c6192e361d99b59d47250668a852
+542c3a0ab6b51bc6a88fa7bb567bca3e
+e035f9e748a2a09a4fbdcf18c4f58bf1
+3b4cc9226a236742d72578c5915b6c3c
+35950208a022baac90056636827158ce
+84cedff2ed1b78b395cc8651094f4ce3
+7badf748f4cb700272a72edfea22e9bf
+a1bb6e142739dbdb0925747d95e0a1ad
+0cd9b72dfdee8efd2e1515f4c5a62284
+ef07c13e75d50578d09052aa21a7cffb
+cf3b261af9344bf83b4dd82b30242c78
+530710f65fb98fff8eb927e2938cb8c5
+4e6d73658b27e19d4bb4500625001e39
+c8e5f2f272b1ef88ec62dd0d9d54e902
+031cbf1fb05b4ec09f3c93235d0f49ac
+8c0e1400df02ba8c4809b705e5f5e114
+57ec48278e19f71f54c570a5ab306df7
+ecd3dc346a2337b95389a094a031610f
+f11d91eae492225cbd82ef356aa96f9f
+26bd8b480216c723ce75da98b9bd430c
+80999c2d12f623e4f87e0550a8e3523a
+00945c1bd739ce389ac24bb93f6f9a85
+7ab55f0bd5dca5b17ecaa7fef73ed87b
+e3cedd606ad51dd18532abd3079a3e0c
+df5ecc6732e22cc25836398a10222e97
+863b6d9962ee3761bbb9cd8a8367589e
+683c9384e29efe82dd3ac847904c28e8
+b3d948e72159ddc9c600d75512c5f115
+ce8633a6cf189b07e022147bbbd0f350
+8df17372eb32a0afa4fc47837262ff61
+62c63ca91890ce6f78a59c0bdb1e7bab
+1eda4bb0259a939548ec4ceb39facde4
+c4f37a2c450f2a23322513b372e668a5
+cab8f06436c5ad45f982490215836f4e
+3a43bc720714a2a42a73a76085542f86
+03f2f4033b258e6eb1e101f1ed4c24b4
+2ceb33cec5ecad4a50f6bd3a831ae77c
+dd808f695d28f93562cfcb164bc3cce4
+01c6d7a87e94bf685205ec8d7c5196af
+ef0e93e8928f8bae1b216da8e661fc9b
+c8da55117d7d4b7ee8ddc8dc4ba73aa6
+bbfc64583c6d4c2ef4b0358464d4d028
+3bb5864481f2e66387419dd1a168aadc
+0d725d3a1d3d97d7b5ea8293bbbf32ba
+915eb22a15f7673f983672b6c353b6c8
+13b51da3e8a1422bfd58b79c4e19de64
+e69d6c03102464f22c395f9fa27108de
+132fa4cbedaa7bd965b0b5900211be48
+e37ff5d9f14249f327a19dd5296e6c7e
+4881a65cf107b1d034ff3ecd64ab9cb4
+547e92d01c0b699cfdf43f91714cfe2d
+aa2b3a055b56845f19109f21d3c783f4
+eb1f01cc647ece73b2192537200bb8b9
+1db274ef41b1ad71f713df2b05207e1a
+d8b4ec343b4310345efc6da9cee8a2ec
+082ee3b2be7910f7350368e395a63d90
+d247c4070ae1de106bcb438a2dacac23
+f8cbc4f3af45befc792679f2b113f1cb
+9031006a437019c5dcd987a31731ebd9
+a6b62759ee3883258fbdeeb8b56e6283
+4933898605b4a1b970b674a2dde92292
+f0684ca20de4607232f3e158e81a37f2
+c0b3fdecb3bb7b4ff0c936f378ccb027
+50652123b5e0e51bb5bc3fdde3c6a750
+ed4526ba8226d969f47edbb27b2f1144
+80e6f61dff9da8673fa16dbbdb14d03d
+1d52744bf1450d7c5cfdf1f0bbf967c1
+3438a953124960bcc44611923a8844ee
+b2f341296dd7aabbd4fd8e011be68a7d
+322dba69658a92e9a9ace4d7177fb97d
+b94a434a98efa493fbbc989360671bb9
+cd9ce9a01ed810af70999d8ce4c63811
+4c639abb75a0ae0f22c3384cb9c68441
+fe31ffcced1717988c854c2f3492466e
+b56d81337f9bbf0d838df831e9b40216
+0be9161adfeb2dd1c3f20338bfb3ec4b
+be7b7c9fa1ab09d6578a3f2a82bfafe3
+f6bdc04b4611ddf0aa8403bcb04292f7
+1c7146a10f3c76b0c1dd4af354b14982
+0d3d987f94aee65f84436696bcf33ea4
+1a5c9ac3ee859361ad5477ea792506a3
+e827d60f27e35d8e5b05af748ba897dd
+5b7899bf7a6267d9b3b8c82f241a1d7b
+6dc9fe740cf4a4b93cb0953a3c2a6026
+27adf814806fd4a51c1ffc84122c5c8a
+f74e94ab992c8f27de264993a09ab429
+5eee0f1591d10c159763749ec86b9ecb
+46898964a3889615d9f7c22a81e0a0e7
+8fb58d6770971b0f12e40b31ad65b4a9
+eb4ce130268dc13731dcd16ff492d0a9
+23532a54e8005860ad5e77f4e3392827
+07fedc4dc4891d1a90c501a781a666f2
+83e8341035b37dd70a92a6eed5406927
+6c9f7b3b25734d58f21f5050642874a5
+ef661042e6624f4052ce86d8f233d780
+efe794cdfad5cb86656e29854a1f5c92
+e5f19a0045481443bae165f03598a9ba
+b8fe8691321edbf308a9d60bb817c6af
+f31fdd0f1aef106005e6d29b72229fa1
+239ed45c3cb734db446adfbbe3dab8a1
+2c2303411c7d25617a54106aca18070d
+de179c41aca8bcdc388964024948ff8e
+ca335b74d59bd50832267d3bf28f81df
+dabda7a1cbaa8ea5104c57c8950b703a
+076352a22ecea5ebc876812f62c1cb8d
+ee0a2bdec712a9413623d8a920714b96
+a927c3a99f2843de4133377c690db9b7
+1fa98cff485549d49799dc8cf987a8af
+74013a076a786a26c7e04217bb51031d
+a44ca9661e967bb2e98af65277dac72f
+d30897726b635548dbfa5cebffd9cd63
+4ad04a250b8029c9a7bf6529ee8793c3
+de41e337d96fd23619121ea709861e1a
+18e070fd32cf732b9f37a0083320eec2
+7dd4b27ca8906182f684d0ee4ddb98c4
+70a440a8bd06ff40f6e9135946eb174d
+b8d052366e752ce7c803abd24854e934
+8ab9dfff746ce3e62c6e04feb7b48528
+ecfca8b371616efe78e9916dbf825f5b
+5f76da828c37fc4edb4557953539c92a
+ecad54f76ce3bc233e02fc6fd7f94628
+e8a1cc06bfec7f677f36a693e1342400
+9ad0fe040e44a8e7146c3dd8582b6752
+4e56f978f94cf72158fd4311831b4f9f
+3b95686fe49f50006607d5978aaa3efc
+fa354daecc45f14b82b0e7e567d24282
+b7c30cf902e74c10e3d5c3af7e854f6b
+e9369a7ec98e63186bdae77025cb5519
+57b441e2f3397d2628657e636cd2fc80
+8ae3a1e880ffb884260ec26e8fcd71a5
+eb7d8f9199945e8a1e5c3708da45e08b
+d7dd1997c20a1029f9bd0fd1e2d2ed92
+a986ef62ef378583985cf0d0a34d17d0
+ad5bef0d6ad3434f871983ed09aaa43c
+326f662a5c18a14d26c3d35131ea4b4e
+ea4bf919aebf4add0024d91ee6f640d0
+9cc49e156084d2c757bd6d502bae8309
+9c18d4c75cc02337c277532ecea4b9fa
+4159a65b7db275742e998fb855e7b9f3
+df34d37f6b4ef078bd9570efdd8fd2e2
+84d2c12c4f0c28d288464d33a23f227c
+17b55bbd4222066960e54182e1e95f0b
+75eb69b22793852bc892ce264c421a1e
+de4abe78e28e2718200c76237f2ed42f
+1149c8fc988799f43f6e5069355e108b
+4129891ff13ddd62820f6f3cdbfa95da
+c8758df3c9ad4d311516ea39fe734052
+360ddf0b658fd764ef5ae9bf7a8a1a12
+ad054e0e84e2b8e2b02ce4dee7688226
+cb434f8c5fad9793ed142805afa861a0
+83a3d5436f96cb2cb31d929794425f31
+34dde0f0fe7d4fdb359df1fccbf5fcde
+7b77219e9549fad49e97c380f7e1f362
+053f4e89ae2355c5cb259d21e85eb9cd
+fc45c5118f642cc479e6a550756f1a4e
+0138351089a87a2ddc2d98255ce6b8cc
+1f3e42daa4b315f2a0e6a530e0cc6976
+aec4974f238a6e04dcb07e20ad861230
+7a27fedaeec41b5832bda3169d76cd05
+154bd1371ae66ad3ab9a9ee6b1324e36
+a4594c9e974eed1fc159cc306dd7378a
+431acd1a4a4d6036057c9906da8add5e
+f6afe47bdedf075c7e188b2640152cf7
+8bc3bd8625778f64ed7c29698025f292
+51f6bb4db8e6e61cc4333450c6035139
+0baff1c675866bf259d3ac9417a33464
+6e8a56a9a005c6c6239ccbdf48f59aa8
+6565bceb49f962f797f49084f3f819a1
+2267037a7f3e753c653218fcf67ce9c7
+aca1ae6237f498986991565b0307f0da
+785bb09a5f25730a3aed4de12da4d9ea
+4eb5472f4e5243fcd4a76533789e829a
+7d725ae9a8e569f49c56194226b64dee
+7396f5d4491e79ec1ac0ce7a105bb233
+aa64644a4877da34e2197c5f2dc375c5
+2165718fc24bf21f1c4e0623c8e8d811
+e1f45852024724f00ced7935e297983a
+deac06cde1f6b18a53a2cf0b03998da2
+8371f0970efbc6099c50afbbd4f0e477
+985d909280bc20607f4cb4941ae535f2
+abcdd18a791546544b52c0587dbd6107
+23e8b5a657c962a3e77979859ae1400e
+cc4fab29cc180ffa888be396ce6aa6f5
+b553506daedf701ccdc437fbf3e6bbe4
+d707ae093ab94607010ddda09fc8a5a8
+76bdae04521ba996636c4dc431040031
+556c14fd0f3ff7bd6b435bd630e48811
+b500501957d4b8b412ea0102c842dd5e
+d18506a74c66e4d8537269c10c783923
+c9b4b691f4d88b7d2b4d5b770b05c8bf
+ba915c678f944fe5a480364ddc3382a8
+78134c91a1ffb2e21594daa2c2a932fc
+6fc6c8790dfc301ee38b8b63e18def5c

Skills/@be/be/node_modules/crypto-browserify/test/vectors/byte-hashes.sha1

@@ -0,0 +1,196 @@
+da39a3ee5e6b4b0d3255bfef95601890afd80709
+3cdf2936da2fc556bfa533ab1eb59ce710ac80e5
+19c1e2048fa7393cfbf2d310ad8209ec11d996e5
+ca775d8c80faa6f87fa62beca6ca6089d63b56e5
+71ac973d0e4b50ae9e5043ff4d615381120a25a0
+a6b5b9f854cfb76701c3bddbf374b3094ea49cba
+d87a0ee74e4b9ad72e6847c87bdeeb3d07844380
+1976b8dd509fe66bf09c9a8d33534d4ef4f63bfd
+5a78f439b6db845bb8a558e4ceb106cd7b7ff783
+f871bce62436c1e280357416695ee2ef9b83695c
+62b243d1b780e1d31cf1ba2de3f01c72aeea0e47
+1698994a273404848e56e7fda4457b5900de1342
+056f4cdc02791da7ed1eb2303314f7667518deef
+9fe2da967bd8441eea1c32df68ddaa9dc1fc8e4b
+73a31777b4ace9384efa8bbead45c51a71aba6dd
+3f9d7c4e2384eddabff5dd8a31e23de3d03f42ac
+4814908f72b93ffd011135bee347de9a08da838f
+0978374b67a412a3102c5aa0b10e1a6596fc68eb
+44ad6cb618bd935460d46d3f921d87b99ab91c1e
+02dc989af265b09cf8485640842128dcf95e9f39
+67507b8d497b35d6e99fc01976d73f54aeca75cf
+1eae0373c1317cb60c36a42a867b716039d441f5
+9c3834589e5bffac9f50950e0199b3ec2620bec8
+209f7abc7f3b878ee46cdf3a1fbb9c21c3474f32
+05fc054b00d97753a9b3e2da8fbba3ee808cef22
+0c4980ea3a46c757dfbfc5baa38ac6c8e72ddce7
+96a460d2972d276928b69864445bea353bdcffd2
+f3ef04d8fa8c6fa9850f394a4554c080956fa64b
+f2a31d875d1d7b30874d416c4d2ea6baf0ffbafe
+f4942d3b9e9588dcfdc6312a84df75d05f111c20
+310207df35b014e4676d30806fa34424813734dd
+4da1955b2fa7c7e74e3f47d7360ce530bbf57ca3
+74c4bc5b26fb4a08602d40ccec6c6161b6c11478
+0b103ce297338dfc7395f7715ee47539b556ddb6
+efc72d99e3d2311ce14190c0b726bdc68f4b0821
+660edac0a8f4ce33da0d8dbae597650e97687250
+fe0a55a988b3b93946a63eb36b23785a5e6efc3e
+0cbdf2a5781c59f907513147a0de3cc774b54bf3
+663e40fee5a44bfcb1c99ea5935a6b5bc9f583b0
+00162134256952dd9ae6b51efb159b35c3c138c7
+ceb88e4736e354416e2010fc1061b3b53b81664b
+a6a2c4b6bcc41ddc67278f3df4d8d0b9dd7784ef
+c23d083cd8820b57800a869f5f261d45e02dc55d
+e8ac31927b78ddec41a31ca7a44eb7177165e7ab
+e864ec5dbab0f9ff6984ab6ad43a8c9b81cc9f9c
+cfed6269069417a84d6de2347220f4b858bcd530
+d9217bfb46c96348722c3783d29d4b1a3feda38c
+dec24e5554f79697218d317315fa986229ce3350
+83a099df7071437ba5495a5b0bfbfefe1c0ef7f3
+aa3198e30891a83e33ce3bfa0587d86a197d4f80
+9b6acbeb4989cbee7015c7d515a75672ffde3442
+b021eb08a436b02658eaa7ba3c88d49f1219c035
+cae36dab8aea29f62e0855d9cb3cd8e7d39094b1
+02de8ba699f3c1b0cb5ad89a01f2346e630459d7
+88021458847dd39b4495368f7254941859fad44b
+91a165295c666fe85c2adbc5a10329daf0cb81a0
+4b31312eaf8b506811151a9dbd162961f7548c4b
+3fe70971b20558f7e9bac303ed2bc14bde659a62
+93fb769d5bf49d6c563685954e2aecc024dc02d6
+bc8827c3e614d515e83dea503989dea4fda6ea13
+e83868dbe4a389ab48e61cfc4ed894f32ae112ac
+55c95459cde4b33791b4b2bcaaf840930af3f3bd
+36bb0e2ba438a3e03214d9ed2b28a4d5c578fcaa
+3acbf874199763eba20f3789dfc59572aca4cf33
+86be037c4d509c9202020767d860dab039cadace
+51b57d7080a87394eec3eb2e0b242e553f2827c9
+1efbfa78866315ce6a71e457f3a750a38facab41
+57d6cb41aeec20236f365b3a490c61d0cfa39611
+c532cb64b4ba826372bccf2b4b5793d5b88bb715
+15833b5631032663e783686a209c6a2b47a1080e
+d04f2043c96e10cd83b574b1e1c217052cd4a6b2
+e8882627c64db743f7db8b4413dd033fc63beb20
+cd2d32286b8867bc124a0af2236fc74be3622199
+019b70d745375091ed5c7b218445ec986d0f5a82
+e5ff5fec1dadbaed02bf2dad4026be6a96b3f2af
+6f4e23b3f2e2c068d13921fe4e5e053ffed4e146
+25e179602a575c915067566fba6da930e97f8678
+67ded0e68e235c8a523e051e86108eeb757efbfd
+af78536ea83c822796745556d62a3ee82c7be098
+64d7ac52e47834be72455f6c64325f9c358b610d
+9d4866baa3639c13e541f250ffa3d8bc157a491f
+2e258811961d3eb876f30e7019241a01f9517bec
+8e0ebc487146f83bc9077a1630e0fb3ab3c89e63
+ce8953741fff3425d2311fbbf4ab481b669def70
+789d1d2dab52086bd90c0e137e2515ed9c6b59b5
+b76ce7472700dd68d6328b7aa8437fb051d15745
+f218669b596c5ffb0b1c14bd03c467fc873230a0
+1ff3bdbe0d504cb0cdfab17e6c37aba6b3cffded
+2f3cbacbb14405a4652ed52793c1814fd8c4fce0
+982c8ab6ce164f481915af59aaed9fff2a391752
+5cd92012d488a07ece0e47901d0e083b6bd93e3f
+69603fec02920851d4b3b8782e07b92bb2963009
+3e90f76437b1ea44cf98a08d83ea24cecf6e6191
+34c09f107c42d990eb4881d4bf2dddcab01563ae
+474be0e5892eb2382109bfc5e3c8249a9283b03d
+a04b4f75051786682483252438f6a75bf4705ec6
+be88a6716083eb50ed9416719d6a247661299383
+c67e38717fee1a5f65ec6c7c7c42afc00cd37f04
+959ac4082388e19e9be5de571c047ef10c174a8d
+baa7aa7b7753fa0abdc4a541842b5d238d949f0a
+351394dcebc08155d100fcd488578e6ae71d0e9c
+ab8be94c5af60d9477ef1252d604e58e27b2a9ee
+3429ec74a695fdd3228f152564952308afe0680a
+907fa46c029bc67eaa8e4f46e3c2a232f85bd122
+2644c87d1fbbbc0fc8d65f64bca2492da15baae4
+110a3eeb408756e2e81abaf4c5dcd4d4c6afcf6d
+cd4fdc35fac7e1adb5de40f47f256ef74d584959
+8e6e273208ac256f9eccf296f3f5a37bc8a0f9f7
+fe0606100bdbc268db39b503e0fdfe3766185828
+6c63c3e58047bcdb35a17f74eeba4e9b14420809
+bcc2bd305f0bcda8cf2d478ef9fe080486cb265f
+ce5223fd3dd920a3b666481d5625b16457dcb5e8
+948886776e42e4f5fae1b2d0c906ac3759e3f8b0
+4c12a51fcfe242f832e3d7329304b11b75161efb
+c54bdd2050504d92f551d378ad5fc72c9ed03932
+8f53e8fa79ea09fd1b682af5ed1515eca965604c
+2d7e17f6294524ce78b33eab72cdd08e5ff6e313
+64582b4b57f782c9302bfe7d07f74aa176627a3a
+6d88795b71d3e386bbd1eb830fb9f161ba98869f
+86ad34a6463f12cee6de9596aba72f0df1397fd1
+7eb46685a57c0d466152dc339c8122548c757ed1
+e7a98fb0692684054407cc221abc60c199d6f52a
+34df1306662206fd0a5fc2969a4beec4eb0197f7
+56cf7ebf08d10f0cb9fe7ee3b63a5c3a02bcb450
+3bae5cb8226642088da760a6f78b0cf8eddea9f1
+6475df681e061fa506672c27cbabfa9aa6ddff62
+79d81991fa4e4957c8062753439dbfd47bbb277d
+bae224477b20302e881f5249f52ec6c34da8ecef
+ede4deb4293cfe4138c2c056b7c46ff821cc0acc
+a771fa5c812bd0c9596d869ec99e4f4ac988b13f
+e99d566212bbbceee903946f6100c9c96039a8f4
+b48ce6b1d13903e3925ae0c88cb931388c013f9c
+e647d5baf670d4bf3afc0a6b72a2424b0c64f194
+65c1cd932a06b05cd0b43afb3bc7891f6bcef45c
+70ffae353a5cd0f8a65a8b2746d0f16281b25ec7
+cc8221f2b829b8cf39646bf46888317c3eb378ea
+26accc2d6d51ff7bf3e5895588907765111bb69b
+01072915b8e868d9b28e759cf2bc1aea4bb92165
+3016115711d74236adf0c371e47992f87a428598
+bf30417999c1368f008c1f19feca4d18a5e1c3c9
+62ba49087185f2742c26e1c1f4844112178bf673
+e1f6b9536f384dd3098285bbfd495a474140dc5a
+b522dae1d67726eba7c4136d4e2f6d6d645ac43e
+e9a021c3eb0b9f2c710554d4bf21b19f78e09478
+df13573188f3bf705e697a3e1f580145f2183377
+188835cfe52ecfa0c4135c2825f245dc29973970
+41b615a34ee2cec9d84a91b141cfab115821950b
+ab3dd6221d2afe6613b815da1c389eec74aa0337
+0706d414b4aa7fb4a9051aa70d6856a7264054fb
+3cbf8151f3a00b1d5a809cbb8c4f3135055a6bd1
+da5d6a0319272bbccea63acfa6799756ffda6840
+fb4429c95f6277b346d3b389413758dfffeedc98
+2c6e30d9c895b42dcccfc84c906ec88c09b20de1
+3de3189a5e19f225cdce254dff23dacd22c61363
+93530a9bc9a817f6922518a73a1505c411d05da2
+e31354345f832d31e05c1b842d405d4bd4588ec8
+3ff76957e80b60cf74d015ad431fca147b3af232
+34ae3b806be143a84dce82e4b830eb7d3d2bac69
+d7447e53d66bb5e4c26e8b41f83efd107bf4adda
+77dd2a4482705bc2e9dc96ec0a13395771ac850c
+eaa1465db1f59de3f25eb8629602b568e693bb57
+9329d5b40e0dc43aa25fed69a0fa9c211a948411
+e94c0b6aa62aa08c625faf817ddf8f51ec645273
+7ff02b909d82ad668e31e547e0fb66cb8e213771
+5bb3570858fa1744123bac2873b0bb9810f53fa1
+905f43940b3591ce39d1145acb1eca80ab5e43cd
+336c79fbd82f33e490c577e3f791c3cbfe842aff
+5c6d07a6b44f7a75a64f6ce592f3bae91e022210
+7e0d3e9d33127f4a30eb8d9c134a58409fa8695b
+9a5f50dfcfb19286206c229019f0abf25283028c
+dca737e269f9d8626d488988c996e06b352c0708
+b8ffc1d4972fce63241e0e77850ac46dde75dbfa
+e9c9bf41c8549354151b977003ce1d830be667db
+0942908960b54f96cb43452e583f4f9cb66e398a
+fce34051c34d4b81b85ddc4b543cde8007e284b3
+61e8916532503627f4024d13884640a46f1d61d4
+f008d5d7853b6a17b7466cd9e18bd135e520faf4
+bd8d2e873cf659b5c77aac1616827ef8a3b1a3b3
+b25a04dd425302ed211a1c2412d2410fa10c63b6
+a404e21588123e0893718b4b44e91414a785b91f
+a1e13bc55bf6dad83cf3aabda3287ad68681ea64
+d5fd35ffabed6733c92365929df0fb4cae864d15
+c12e9c280ee9c079e0506ff89f9b20536e0a83ef
+e22769dc00748a9bbd6c05bbc8e81f2cd1dc4e2d
+f29835a93475740e888e8c14318f3ca45a3c8606
+1a1d77c6d0f97c4b620faa90f3f8644408e4b13d
+4ec84870e9bdd25f523c6dfb6edd605052ca4eaa
+d689513fed08b80c39b67371959bc4e3fecb0537
+c4fed58f209fc3c34ad19f86a6dacadc86c04d33
+051888c6d00029c176de792b84dece2dc1c74b00
+1a3540bee05518505827954f58b751c475aeece0
+dfa19180359d5a7a38e842f172359caf4208fc05
+7b0fa84ebbcff7d7f4500f73d79660c4a3431b67
+9e886081c9acaad0f97b10810d1de6fcdce6b5f4
+a4d46e4ba0ae4b012f75b1b50d0534d578ae9cb6
+6342b199ee64c7b2c9cbcd4f2dcb65acef51516f

Skills/@be/be/node_modules/crypto-browserify/test/vectors/byte-hashes.sha256

@@ -0,0 +1,196 @@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Skills/@be/be/node_modules/crypto-browserify/test/vectors/byte0001.dat

@@ -0,0 +1 @@
+$

Skills/@be/be/node_modules/crypto-browserify/test/vectors/byte0002.dat

@@ -0,0 +1 @@
+p<EFBFBD>

Skills/@be/be/node_modules/crypto-browserify/test/vectors/byte0003.dat

@@ -0,0 +1 @@
+<1E>

Skills/@be/be/node_modules/crypto-browserify/test/vectors/byte0004.dat

@@ -0,0 +1 @@
+8x<38>

Skills/@be/be/node_modules/crypto-browserify/test/vectors/byte0005.dat

@@ -0,0 +1 @@
+><08>

Skills/@be/be/node_modules/crypto-browserify/test/vectors/byte0006.dat

@@ -0,0 +1 @@
+هاُ

Skills/@be/be/node_modules/crypto-browserify/test/vectors/byte0007.dat

@@ -0,0 +1 @@
+瓔q<EFBFBD>ﾁ<EFBFBD>

Skills/@be/be/node_modules/crypto-browserify/test/vectors/byte0008.dat

@@ -0,0 +1 @@
+<EFBFBD>|`<€<>

Skills/@be/be/node_modules/crypto-browserify/test/vectors/byte0009.dat

@@ -0,0 +1 @@
+р?И`Ѓю
ш

Skills/@be/be/node_modules/crypto-browserify/test/vectors/byte0012.dat

@@ -0,0 +1 @@
+

Àø0óùÿ

Skills/@be/be/node_modules/crypto-browserify/test/vectors/byte0013.dat

@@ -0,0 +1 @@
+Äüř
ŔđA˙

Skills/@be/be/node_modules/crypto-browserify/test/vectors/byte0014.dat

@@ -0,0 +1 @@
+ÿ€GüÀ`0à<ÿ