@valkey/valkey-glide-darwin-arm64 1.3.1 → 1.3.3-rc0

package/rust-client/node_modules/async/log.js

@@ -1,41 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-
-var _consoleFunc = require('./internal/consoleFunc.js');
-
-var _consoleFunc2 = _interopRequireDefault(_consoleFunc);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Logs the result of an `async` function to the `console`. Only works in
- * Node.js or in browsers that support `console.log` and `console.error` (such
- * as FF and Chrome). If multiple arguments are returned from the async
- * function, `console.log` is called on each argument in order.
- *
- * @name log
- * @static
- * @memberOf module:Utils
- * @method
- * @category Util
- * @param {AsyncFunction} function - The function you want to eventually apply
- * all arguments to.
- * @param {...*} arguments... - Any number of arguments to apply to the function.
- * @example
- *
- * // in a module
- * var hello = function(name, callback) {
- *     setTimeout(function() {
- *         callback(null, 'hello ' + name);
- *     }, 1000);
- * };
- *
- * // in the node repl
- * node> async.log(hello, 'world');
- * 'hello world'
- */
-exports.default = (0, _consoleFunc2.default)('log');
-module.exports = exports.default;

package/rust-client/node_modules/async/map.js

@@ -1,142 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-
-var _map2 = require('./internal/map.js');
-
-var _map3 = _interopRequireDefault(_map2);
-
-var _eachOf = require('./eachOf.js');
-
-var _eachOf2 = _interopRequireDefault(_eachOf);
-
-var _awaitify = require('./internal/awaitify.js');
-
-var _awaitify2 = _interopRequireDefault(_awaitify);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Produces a new collection of values by mapping each value in `coll` through
- * the `iteratee` function. The `iteratee` is called with an item from `coll`
- * and a callback for when it has finished processing. Each of these callbacks
- * takes 2 arguments: an `error`, and the transformed item from `coll`. If
- * `iteratee` passes an error to its callback, the main `callback` (for the
- * `map` function) is immediately called with the error.
- *
- * Note, that since this function applies the `iteratee` to each item in
- * parallel, there is no guarantee that the `iteratee` functions will complete
- * in order. However, the results array will be in the same order as the
- * original `coll`.
- *
- * If `map` is passed an Object, the results will be an Array.  The results
- * will roughly be in the order of the original Objects' keys (but this can
- * vary across JavaScript engines).
- *
- * @name map
- * @static
- * @memberOf module:Collections
- * @method
- * @category Collection
- * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
- * @param {AsyncFunction} iteratee - An async function to apply to each item in
- * `coll`.
- * The iteratee should complete with the transformed item.
- * Invoked with (item, callback).
- * @param {Function} [callback] - A callback which is called when all `iteratee`
- * functions have finished, or an error occurs. Results is an Array of the
- * transformed items from the `coll`. Invoked with (err, results).
- * @returns {Promise} a promise, if no callback is passed
- * @example
- *
- * // file1.txt is a file that is 1000 bytes in size
- * // file2.txt is a file that is 2000 bytes in size
- * // file3.txt is a file that is 3000 bytes in size
- * // file4.txt does not exist
- *
- * const fileList = ['file1.txt','file2.txt','file3.txt'];
- * const withMissingFileList = ['file1.txt','file2.txt','file4.txt'];
- *
- * // asynchronous function that returns the file size in bytes
- * function getFileSizeInBytes(file, callback) {
- *     fs.stat(file, function(err, stat) {
- *         if (err) {
- *             return callback(err);
- *         }
- *         callback(null, stat.size);
- *     });
- * }
- *
- * // Using callbacks
- * async.map(fileList, getFileSizeInBytes, function(err, results) {
- *     if (err) {
- *         console.log(err);
- *     } else {
- *         console.log(results);
- *         // results is now an array of the file size in bytes for each file, e.g.
- *         // [ 1000, 2000, 3000]
- *     }
- * });
- *
- * // Error Handling
- * async.map(withMissingFileList, getFileSizeInBytes, function(err, results) {
- *     if (err) {
- *         console.log(err);
- *         // [ Error: ENOENT: no such file or directory ]
- *     } else {
- *         console.log(results);
- *     }
- * });
- *
- * // Using Promises
- * async.map(fileList, getFileSizeInBytes)
- * .then( results => {
- *     console.log(results);
- *     // results is now an array of the file size in bytes for each file, e.g.
- *     // [ 1000, 2000, 3000]
- * }).catch( err => {
- *     console.log(err);
- * });
- *
- * // Error Handling
- * async.map(withMissingFileList, getFileSizeInBytes)
- * .then( results => {
- *     console.log(results);
- * }).catch( err => {
- *     console.log(err);
- *     // [ Error: ENOENT: no such file or directory ]
- * });
- *
- * // Using async/await
- * async () => {
- *     try {
- *         let results = await async.map(fileList, getFileSizeInBytes);
- *         console.log(results);
- *         // results is now an array of the file size in bytes for each file, e.g.
- *         // [ 1000, 2000, 3000]
- *     }
- *     catch (err) {
- *         console.log(err);
- *     }
- * }
- *
- * // Error Handling
- * async () => {
- *     try {
- *         let results = await async.map(withMissingFileList, getFileSizeInBytes);
- *         console.log(results);
- *     }
- *     catch (err) {
- *         console.log(err);
- *         // [ Error: ENOENT: no such file or directory ]
- *     }
- * }
- *
- */
-function map(coll, iteratee, callback) {
-    return (0, _map3.default)(_eachOf2.default, coll, iteratee, callback);
-}
-exports.default = (0, _awaitify2.default)(map, 3);
-module.exports = exports.default;

package/rust-client/node_modules/async/mapLimit.js

@@ -1,45 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-
-var _map2 = require('./internal/map.js');
-
-var _map3 = _interopRequireDefault(_map2);
-
-var _eachOfLimit = require('./internal/eachOfLimit.js');
-
-var _eachOfLimit2 = _interopRequireDefault(_eachOfLimit);
-
-var _awaitify = require('./internal/awaitify.js');
-
-var _awaitify2 = _interopRequireDefault(_awaitify);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * The same as [`map`]{@link module:Collections.map} but runs a maximum of `limit` async operations at a time.
- *
- * @name mapLimit
- * @static
- * @memberOf module:Collections
- * @method
- * @see [async.map]{@link module:Collections.map}
- * @category Collection
- * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
- * @param {number} limit - The maximum number of async operations at a time.
- * @param {AsyncFunction} iteratee - An async function to apply to each item in
- * `coll`.
- * The iteratee should complete with the transformed item.
- * Invoked with (item, callback).
- * @param {Function} [callback] - A callback which is called when all `iteratee`
- * functions have finished, or an error occurs. Results is an array of the
- * transformed items from the `coll`. Invoked with (err, results).
- * @returns {Promise} a promise, if no callback is passed
- */
-function mapLimit(coll, limit, iteratee, callback) {
-    return (0, _map3.default)((0, _eachOfLimit2.default)(limit), coll, iteratee, callback);
-}
-exports.default = (0, _awaitify2.default)(mapLimit, 4);
-module.exports = exports.default;

package/rust-client/node_modules/async/mapSeries.js

@@ -1,44 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-
-var _map2 = require('./internal/map.js');
-
-var _map3 = _interopRequireDefault(_map2);
-
-var _eachOfSeries = require('./eachOfSeries.js');
-
-var _eachOfSeries2 = _interopRequireDefault(_eachOfSeries);
-
-var _awaitify = require('./internal/awaitify.js');
-
-var _awaitify2 = _interopRequireDefault(_awaitify);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * The same as [`map`]{@link module:Collections.map} but runs only a single async operation at a time.
- *
- * @name mapSeries
- * @static
- * @memberOf module:Collections
- * @method
- * @see [async.map]{@link module:Collections.map}
- * @category Collection
- * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.
- * @param {AsyncFunction} iteratee - An async function to apply to each item in
- * `coll`.
- * The iteratee should complete with the transformed item.
- * Invoked with (item, callback).
- * @param {Function} [callback] - A callback which is called when all `iteratee`
- * functions have finished, or an error occurs. Results is an array of the
- * transformed items from the `coll`. Invoked with (err, results).
- * @returns {Promise} a promise, if no callback is passed
- */
-function mapSeries(coll, iteratee, callback) {
-    return (0, _map3.default)(_eachOfSeries2.default, coll, iteratee, callback);
-}
-exports.default = (0, _awaitify2.default)(mapSeries, 3);
-module.exports = exports.default;

package/rust-client/node_modules/async/mapValues.js

@@ -1,152 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = mapValues;
-
-var _mapValuesLimit = require('./mapValuesLimit.js');
-
-var _mapValuesLimit2 = _interopRequireDefault(_mapValuesLimit);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * A relative of [`map`]{@link module:Collections.map}, designed for use with objects.
- *
- * Produces a new Object by mapping each value of `obj` through the `iteratee`
- * function. The `iteratee` is called each `value` and `key` from `obj` and a
- * callback for when it has finished processing. Each of these callbacks takes
- * two arguments: an `error`, and the transformed item from `obj`. If `iteratee`
- * passes an error to its callback, the main `callback` (for the `mapValues`
- * function) is immediately called with the error.
- *
- * Note, the order of the keys in the result is not guaranteed.  The keys will
- * be roughly in the order they complete, (but this is very engine-specific)
- *
- * @name mapValues
- * @static
- * @memberOf module:Collections
- * @method
- * @category Collection
- * @param {Object} obj - A collection to iterate over.
- * @param {AsyncFunction} iteratee - A function to apply to each value and key
- * in `coll`.
- * The iteratee should complete with the transformed value as its result.
- * Invoked with (value, key, callback).
- * @param {Function} [callback] - A callback which is called when all `iteratee`
- * functions have finished, or an error occurs. `result` is a new object consisting
- * of each key from `obj`, with each transformed value on the right-hand side.
- * Invoked with (err, result).
- * @returns {Promise} a promise, if no callback is passed
- * @example
- *
- * // file1.txt is a file that is 1000 bytes in size
- * // file2.txt is a file that is 2000 bytes in size
- * // file3.txt is a file that is 3000 bytes in size
- * // file4.txt does not exist
- *
- * const fileMap = {
- *     f1: 'file1.txt',
- *     f2: 'file2.txt',
- *     f3: 'file3.txt'
- * };
- *
- * const withMissingFileMap = {
- *     f1: 'file1.txt',
- *     f2: 'file2.txt',
- *     f3: 'file4.txt'
- * };
- *
- * // asynchronous function that returns the file size in bytes
- * function getFileSizeInBytes(file, key, callback) {
- *     fs.stat(file, function(err, stat) {
- *         if (err) {
- *             return callback(err);
- *         }
- *         callback(null, stat.size);
- *     });
- * }
- *
- * // Using callbacks
- * async.mapValues(fileMap, getFileSizeInBytes, function(err, result) {
- *     if (err) {
- *         console.log(err);
- *     } else {
- *         console.log(result);
- *         // result is now a map of file size in bytes for each file, e.g.
- *         // {
- *         //     f1: 1000,
- *         //     f2: 2000,
- *         //     f3: 3000
- *         // }
- *     }
- * });
- *
- * // Error handling
- * async.mapValues(withMissingFileMap, getFileSizeInBytes, function(err, result) {
- *     if (err) {
- *         console.log(err);
- *         // [ Error: ENOENT: no such file or directory ]
- *     } else {
- *         console.log(result);
- *     }
- * });
- *
- * // Using Promises
- * async.mapValues(fileMap, getFileSizeInBytes)
- * .then( result => {
- *     console.log(result);
- *     // result is now a map of file size in bytes for each file, e.g.
- *     // {
- *     //     f1: 1000,
- *     //     f2: 2000,
- *     //     f3: 3000
- *     // }
- * }).catch (err => {
- *     console.log(err);
- * });
- *
- * // Error Handling
- * async.mapValues(withMissingFileMap, getFileSizeInBytes)
- * .then( result => {
- *     console.log(result);
- * }).catch (err => {
- *     console.log(err);
- *     // [ Error: ENOENT: no such file or directory ]
- * });
- *
- * // Using async/await
- * async () => {
- *     try {
- *         let result = await async.mapValues(fileMap, getFileSizeInBytes);
- *         console.log(result);
- *         // result is now a map of file size in bytes for each file, e.g.
- *         // {
- *         //     f1: 1000,
- *         //     f2: 2000,
- *         //     f3: 3000
- *         // }
- *     }
- *     catch (err) {
- *         console.log(err);
- *     }
- * }
- *
- * // Error Handling
- * async () => {
- *     try {
- *         let result = await async.mapValues(withMissingFileMap, getFileSizeInBytes);
- *         console.log(result);
- *     }
- *     catch (err) {
- *         console.log(err);
- *         // [ Error: ENOENT: no such file or directory ]
- *     }
- * }
- *
- */
-function mapValues(obj, iteratee, callback) {
-    return (0, _mapValuesLimit2.default)(obj, Infinity, iteratee, callback);
-}
-module.exports = exports.default;

package/rust-client/node_modules/async/mapValuesLimit.js

@@ -1,61 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-
-var _eachOfLimit = require('./internal/eachOfLimit.js');
-
-var _eachOfLimit2 = _interopRequireDefault(_eachOfLimit);
-
-var _awaitify = require('./internal/awaitify.js');
-
-var _awaitify2 = _interopRequireDefault(_awaitify);
-
-var _once = require('./internal/once.js');
-
-var _once2 = _interopRequireDefault(_once);
-
-var _wrapAsync = require('./internal/wrapAsync.js');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * The same as [`mapValues`]{@link module:Collections.mapValues} but runs a maximum of `limit` async operations at a
- * time.
- *
- * @name mapValuesLimit
- * @static
- * @memberOf module:Collections
- * @method
- * @see [async.mapValues]{@link module:Collections.mapValues}
- * @category Collection
- * @param {Object} obj - A collection to iterate over.
- * @param {number} limit - The maximum number of async operations at a time.
- * @param {AsyncFunction} iteratee - A function to apply to each value and key
- * in `coll`.
- * The iteratee should complete with the transformed value as its result.
- * Invoked with (value, key, callback).
- * @param {Function} [callback] - A callback which is called when all `iteratee`
- * functions have finished, or an error occurs. `result` is a new object consisting
- * of each key from `obj`, with each transformed value on the right-hand side.
- * Invoked with (err, result).
- * @returns {Promise} a promise, if no callback is passed
- */
-function mapValuesLimit(obj, limit, iteratee, callback) {
-    callback = (0, _once2.default)(callback);
-    var newObj = {};
-    var _iteratee = (0, _wrapAsync2.default)(iteratee);
-    return (0, _eachOfLimit2.default)(limit)(obj, (val, key, next) => {
-        _iteratee(val, key, (err, result) => {
-            if (err) return next(err);
-            newObj[key] = result;
-            next(err);
-        });
-    }, err => callback(err, newObj));
-}
-
-exports.default = (0, _awaitify2.default)(mapValuesLimit, 4);
-module.exports = exports.default;

package/rust-client/node_modules/async/mapValuesSeries.js

@@ -1,37 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = mapValuesSeries;
-
-var _mapValuesLimit = require('./mapValuesLimit.js');
-
-var _mapValuesLimit2 = _interopRequireDefault(_mapValuesLimit);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * The same as [`mapValues`]{@link module:Collections.mapValues} but runs only a single async operation at a time.
- *
- * @name mapValuesSeries
- * @static
- * @memberOf module:Collections
- * @method
- * @see [async.mapValues]{@link module:Collections.mapValues}
- * @category Collection
- * @param {Object} obj - A collection to iterate over.
- * @param {AsyncFunction} iteratee - A function to apply to each value and key
- * in `coll`.
- * The iteratee should complete with the transformed value as its result.
- * Invoked with (value, key, callback).
- * @param {Function} [callback] - A callback which is called when all `iteratee`
- * functions have finished, or an error occurs. `result` is a new object consisting
- * of each key from `obj`, with each transformed value on the right-hand side.
- * Invoked with (err, result).
- * @returns {Promise} a promise, if no callback is passed
- */
-function mapValuesSeries(obj, iteratee, callback) {
-    return (0, _mapValuesLimit2.default)(obj, 1, iteratee, callback);
-}
-module.exports = exports.default;

package/rust-client/node_modules/async/memoize.js

@@ -1,91 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = memoize;
-
-var _setImmediate = require('./internal/setImmediate.js');
-
-var _setImmediate2 = _interopRequireDefault(_setImmediate);
-
-var _initialParams = require('./internal/initialParams.js');
-
-var _initialParams2 = _interopRequireDefault(_initialParams);
-
-var _wrapAsync = require('./internal/wrapAsync.js');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Caches the results of an async function. When creating a hash to store
- * function results against, the callback is omitted from the hash and an
- * optional hash function can be used.
- *
- * **Note: if the async function errs, the result will not be cached and
- * subsequent calls will call the wrapped function.**
- *
- * If no hash function is specified, the first argument is used as a hash key,
- * which may work reasonably if it is a string or a data type that converts to a
- * distinct string. Note that objects and arrays will not behave reasonably.
- * Neither will cases where the other arguments are significant. In such cases,
- * specify your own hash function.
- *
- * The cache of results is exposed as the `memo` property of the function
- * returned by `memoize`.
- *
- * @name memoize
- * @static
- * @memberOf module:Utils
- * @method
- * @category Util
- * @param {AsyncFunction} fn - The async function to proxy and cache results from.
- * @param {Function} hasher - An optional function for generating a custom hash
- * for storing results. It has all the arguments applied to it apart from the
- * callback, and must be synchronous.
- * @returns {AsyncFunction} a memoized version of `fn`
- * @example
- *
- * var slow_fn = function(name, callback) {
- *     // do something
- *     callback(null, result);
- * };
- * var fn = async.memoize(slow_fn);
- *
- * // fn can now be used as if it were slow_fn
- * fn('some name', function() {
- *     // callback
- * });
- */
-function memoize(fn, hasher = v => v) {
-    var memo = Object.create(null);
-    var queues = Object.create(null);
-    var _fn = (0, _wrapAsync2.default)(fn);
-    var memoized = (0, _initialParams2.default)((args, callback) => {
-        var key = hasher(...args);
-        if (key in memo) {
-            (0, _setImmediate2.default)(() => callback(null, ...memo[key]));
-        } else if (key in queues) {
-            queues[key].push(callback);
-        } else {
-            queues[key] = [callback];
-            _fn(...args, (err, ...resultArgs) => {
-                // #1465 don't memoize if an error occurred
-                if (!err) {
-                    memo[key] = resultArgs;
-                }
-                var q = queues[key];
-                delete queues[key];
-                for (var i = 0, l = q.length; i < l; i++) {
-                    q[i](err, ...resultArgs);
-                }
-            });
-        }
-    });
-    memoized.memo = memo;
-    memoized.unmemoized = fn;
-    return memoized;
-}
-module.exports = exports.default;

package/rust-client/node_modules/async/nextTick.js

@@ -1,52 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-
-var _setImmediate = require('./internal/setImmediate.js');
-
-/**
- * Calls `callback` on a later loop around the event loop. In Node.js this just
- * calls `process.nextTick`.  In the browser it will use `setImmediate` if
- * available, otherwise `setTimeout(callback, 0)`, which means other higher
- * priority events may precede the execution of `callback`.
- *
- * This is used internally for browser-compatibility purposes.
- *
- * @name nextTick
- * @static
- * @memberOf module:Utils
- * @method
- * @see [async.setImmediate]{@link module:Utils.setImmediate}
- * @category Util
- * @param {Function} callback - The function to call on a later loop around
- * the event loop. Invoked with (args...).
- * @param {...*} args... - any number of additional arguments to pass to the
- * callback on the next tick.
- * @example
- *
- * var call_order = [];
- * async.nextTick(function() {
- *     call_order.push('two');
- *     // call_order now equals ['one','two']
- * });
- * call_order.push('one');
- *
- * async.setImmediate(function (a, b, c) {
- *     // a, b, and c equal 1, 2, and 3
- * }, 1, 2, 3);
- */
-var _defer; /* istanbul ignore file */
-
-
-if (_setImmediate.hasNextTick) {
-    _defer = process.nextTick;
-} else if (_setImmediate.hasSetImmediate) {
-    _defer = setImmediate;
-} else {
-    _defer = _setImmediate.fallback;
-}
-
-exports.default = (0, _setImmediate.wrap)(_defer);
-module.exports = exports.default;