@chorus-aidlc/chorus 0.6.4 → 0.6.5

package/.next/standalone/node_modules/bcrypt/bcrypt.js

@@ -1,242 +0,0 @@
-const path = require('path');
-const bindings = require('node-gyp-build')(path.resolve(__dirname));
-
-const crypto = require('crypto');
-
-const promises = require('./promises');
-
-/// generate a salt (sync)
-/// @param {Number} [rounds] number of rounds (default 10)
-/// @return {String} salt
-function genSaltSync(rounds, minor) {
-    // default 10 rounds
-    if (!rounds) {
-        rounds = 10;
-    } else if (typeof rounds !== 'number') {
-        throw new Error('rounds must be a number');
-    }
-
-    if (!minor) {
-        minor = 'b';
-    } else if (minor !== 'b' && minor !== 'a') {
-        throw new Error('minor must be either "a" or "b"');
-    }
-
-    return bindings.gen_salt_sync(minor, rounds, crypto.randomBytes(16));
-}
-
-/// generate a salt
-/// @param {Number} [rounds] number of rounds (default 10)
-/// @param {Function} cb callback(err, salt)
-function genSalt(rounds, minor, cb) {
-    let error;
-
-    // if callback is first argument, then use defaults for others
-    if (typeof arguments[0] === 'function') {
-        // have to set callback first otherwise arguments are overridden
-        cb = arguments[0];
-        rounds = 10;
-        minor = 'b';
-        // callback is second argument
-    } else if (typeof arguments[1] === 'function') {
-        // have to set callback first otherwise arguments are overridden
-        cb = arguments[1];
-        minor = 'b';
-    }
-
-    if (!cb) {
-        return promises.promise(genSalt, this, [rounds, minor]);
-    }
-
-    // default 10 rounds
-    if (!rounds) {
-        rounds = 10;
-    } else if (typeof rounds !== 'number') {
-        // callback error asynchronously
-        error = new Error('rounds must be a number');
-        return process.nextTick(function () {
-            cb(error);
-        });
-    }
-
-    if (!minor) {
-        minor = 'b'
-    } else if (minor !== 'b' && minor !== 'a') {
-        error = new Error('minor must be either "a" or "b"');
-        return process.nextTick(function () {
-            cb(error);
-        });
-    }
-
-    crypto.randomBytes(16, function (error, randomBytes) {
-        if (error) {
-            cb(error);
-            return;
-        }
-
-        bindings.gen_salt(minor, rounds, randomBytes, cb);
-    });
-}
-
-/// hash data using a salt
-/// @param {String|Buffer} data the data to encrypt
-/// @param {String} salt the salt to use when hashing
-/// @return {String} hash
-function hashSync(data, salt) {
-    if (data == null || salt == null) {
-        throw new Error('data and salt arguments required');
-    }
-
-    if (!(typeof data === 'string' || data instanceof Buffer) || (typeof salt !== 'string' && typeof salt !== 'number')) {
-        throw new Error('data must be a string or Buffer and salt must either be a salt string or a number of rounds');
-    }
-
-    if (typeof salt === 'number') {
-        salt = module.exports.genSaltSync(salt);
-    }
-
-    return bindings.encrypt_sync(data, salt);
-}
-
-/// hash data using a salt
-/// @param {String|Buffer} data the data to encrypt
-/// @param {String} salt the salt to use when hashing
-/// @param {Function} cb callback(err, hash)
-function hash(data, salt, cb) {
-    let error;
-
-    if (typeof data === 'function') {
-        error = new Error('data must be a string or Buffer and salt must either be a salt string or a number of rounds');
-        return process.nextTick(function () {
-            data(error);
-        });
-    }
-
-    if (typeof salt === 'function') {
-        error = new Error('data must be a string or Buffer and salt must either be a salt string or a number of rounds');
-        return process.nextTick(function () {
-            salt(error);
-        });
-    }
-
-    // cb exists but is not a function
-    // return a rejecting promise
-    if (cb && typeof cb !== 'function') {
-        return promises.reject(new Error('cb must be a function or null to return a Promise'));
-    }
-
-    if (!cb) {
-        return promises.promise(hash, this, [data, salt]);
-    }
-
-    if (data == null || salt == null) {
-        error = new Error('data and salt arguments required');
-        return process.nextTick(function () {
-            cb(error);
-        });
-    }
-
-    if (!(typeof data === 'string' || data instanceof Buffer) || (typeof salt !== 'string' && typeof salt !== 'number')) {
-        error = new Error('data must be a string or Buffer and salt must either be a salt string or a number of rounds');
-        return process.nextTick(function () {
-            cb(error);
-        });
-    }
-
-
-    if (typeof salt === 'number') {
-        return module.exports.genSalt(salt, function (err, salt) {
-            return bindings.encrypt(data, salt, cb);
-        });
-    }
-
-    return bindings.encrypt(data, salt, cb);
-}
-
-/// compare raw data to hash
-/// @param {String|Buffer} data the data to hash and compare
-/// @param {String} hash expected hash
-/// @return {bool} true if hashed data matches hash
-function compareSync(data, hash) {
-    if (data == null || hash == null) {
-        throw new Error('data and hash arguments required');
-    }
-
-    if (!(typeof data === 'string' || data instanceof Buffer) || typeof hash !== 'string') {
-        throw new Error('data must be a string or Buffer and hash must be a string');
-    }
-
-    return bindings.compare_sync(data, hash);
-}
-
-/// compare raw data to hash
-/// @param {String|Buffer} data the data to hash and compare
-/// @param {String} hash expected hash
-/// @param {Function} cb callback(err, matched) - matched is true if hashed data matches hash
-function compare(data, hash, cb) {
-    let error;
-
-    if (typeof data === 'function') {
-        error = new Error('data and hash arguments required');
-        return process.nextTick(function () {
-            data(error);
-        });
-    }
-
-    if (typeof hash === 'function') {
-        error = new Error('data and hash arguments required');
-        return process.nextTick(function () {
-            hash(error);
-        });
-    }
-
-    // cb exists but is not a function
-    // return a rejecting promise
-    if (cb && typeof cb !== 'function') {
-        return promises.reject(new Error('cb must be a function or null to return a Promise'));
-    }
-
-    if (!cb) {
-        return promises.promise(compare, this, [data, hash]);
-    }
-
-    if (data == null || hash == null) {
-        error = new Error('data and hash arguments required');
-        return process.nextTick(function () {
-            cb(error);
-        });
-    }
-
-    if (!(typeof data === 'string' || data instanceof Buffer) || typeof hash !== 'string') {
-        error = new Error('data and hash must be strings');
-        return process.nextTick(function () {
-            cb(error);
-        });
-    }
-
-    return bindings.compare(data, hash, cb);
-}
-
-/// @param {String} hash extract rounds from this hash
-/// @return {Number} the number of rounds used to encrypt a given hash
-function getRounds(hash) {
-    if (hash == null) {
-        throw new Error('hash argument required');
-    }
-
-    if (typeof hash !== 'string') {
-        throw new Error('hash must be a string');
-    }
-
-    return bindings.get_rounds(hash);
-}
-
-module.exports = {
-    genSaltSync,
-    genSalt,
-    hashSync,
-    hash,
-    compareSync,
-    compare,
-    getRounds,
-}

package/.next/standalone/node_modules/bcrypt/package.json

@@ -1,62 +0,0 @@
-{
-  "name": "bcrypt",
-  "description": "A bcrypt library for NodeJS.",
-  "keywords": [
-    "bcrypt",
-    "password",
-    "auth",
-    "authentication",
-    "encryption",
-    "crypt",
-    "crypto"
-  ],
-  "main": "./bcrypt",
-  "version": "6.0.0",
-  "author": "Nick Campbell (https://github.com/ncb000gt)",
-  "engines": {
-    "node": ">= 18"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/kelektiv/node.bcrypt.js.git"
-  },
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/kelektiv/node.bcrypt.js/issues"
-  },
-  "scripts": {
-    "test": "jest",
-    "install": "node-gyp-build",
-    "build": "prebuildify --napi --tag-libc --strip"
-  },
-  "dependencies": {
-    "node-addon-api": "^8.3.0",
-    "node-gyp-build": "^4.8.4"
-  },
-  "devDependencies": {
-    "jest": "^29.7.0",
-    "prebuildify": "^6.0.1"
-  },
-  "contributors": [
-    "Antonio Salazar Cardozo <savedfastcool@gmail.com> (https://github.com/Shadowfiend)",
-    "Van Nguyen <the.gol.effect@gmail.com> (https://github.com/thegoleffect)",
-    "David Trejo <david@dtrejo.com> (https://github.com/dtrejo)",
-    "Ben Glow <glen.low@pixelglow.com> (https://github.com/pixelglow)",
-    "NewITFarmer.com <> (https://github.com/newitfarmer)",
-    "Alfred Westerveld <alfredwesterveld@gmail.com> (https://github.com/alfredwesterveld)",
-    "Vincent Côté-Roy <vincentcr@gmail.com> (https://github.com/vincentcr)",
-    "Lloyd Hilaiel <lloyd@hilaiel.com> (https://github.com/lloyd)",
-    "Roman Shtylman <shtylman@gmail.com> (https://github.com/shtylman)",
-    "Vadim Graboys <dimva13@gmail.com> (https://github.com/vadimg)",
-    "Ben Noorduis <> (https://github.com/bnoordhuis)",
-    "Nate Rajlich <nathan@tootallnate.net> (https://github.com/tootallnate)",
-    "Sean McArthur <sean.monstar@gmail.com> (https://github.com/seanmonstar)",
-    "Fanie Oosthuysen <fanie.oosthuysen@gmail.com> (https://github.com/weareu)",
-    "Amitosh Swain Mahapatra <amitosh.swain@gmail.com> (https://github.com/Agathver)",
-    "Corbin Crutchley <crutchcorn@gmail.com> (https://github.com/crutchcorn)",
-    "Nicola Del Gobbo <nicoladelgobbo@gmail.com> (https://github.com/NickNaso)"
-  ],
-  "binary": {
-    "module_name": "bcrypt_lib"
-  }
-}

package/.next/standalone/node_modules/bcrypt/promises.js

@@ -1,45 +0,0 @@
-let Promise = global.Promise;
-
-/// encapsulate a method with a node-style callback in a Promise
-/// @param {object} 'this' of the encapsulated function
-/// @param {function} function to be encapsulated
-/// @param {Array-like} args to be passed to the called function
-/// @return {Promise} a Promise encapsulating the function
-function promise(fn, context, args) {
-    if (!Array.isArray(args)) {
-        args = Array.prototype.slice.call(args);
-    }
-
-    if (typeof fn !== 'function') {
-        return Promise.reject(new Error('fn must be a function'));
-    }
-
-    return new Promise((resolve, reject) => {
-        args.push((err, data) => {
-            if (err) {
-                reject(err);
-            } else {
-                resolve(data);
-            }
-        });
-
-        fn.apply(context, args);
-    });
-}
-
-/// @param {err} the error to be thrown
-function reject(err) {
-    return Promise.reject(err);
-}
-
-/// changes the promise implementation that bcrypt uses
-/// @param {Promise} the implementation to use
-function use(promise) {
-    Promise = promise;
-}
-
-module.exports = {
-    promise,
-    reject,
-    use
-}