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

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

@@ -1,333 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = auto;
-
-var _once = require('./internal/once.js');
-
-var _once2 = _interopRequireDefault(_once);
-
-var _onlyOnce = require('./internal/onlyOnce.js');
-
-var _onlyOnce2 = _interopRequireDefault(_onlyOnce);
-
-var _wrapAsync = require('./internal/wrapAsync.js');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-var _promiseCallback = require('./internal/promiseCallback.js');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Determines the best order for running the {@link AsyncFunction}s in `tasks`, based on
- * their requirements. Each function can optionally depend on other functions
- * being completed first, and each function is run as soon as its requirements
- * are satisfied.
- *
- * If any of the {@link AsyncFunction}s pass an error to their callback, the `auto` sequence
- * will stop. Further tasks will not execute (so any other functions depending
- * on it will not run), and the main `callback` is immediately called with the
- * error.
- *
- * {@link AsyncFunction}s also receive an object containing the results of functions which
- * have completed so far as the first argument, if they have dependencies. If a
- * task function has no dependencies, it will only be passed a callback.
- *
- * @name auto
- * @static
- * @memberOf module:ControlFlow
- * @method
- * @category Control Flow
- * @param {Object} tasks - An object. Each of its properties is either a
- * function or an array of requirements, with the {@link AsyncFunction} itself the last item
- * in the array. The object's key of a property serves as the name of the task
- * defined by that property, i.e. can be used when specifying requirements for
- * other tasks. The function receives one or two arguments:
- * * a `results` object, containing the results of the previously executed
- *   functions, only passed if the task has any dependencies,
- * * a `callback(err, result)` function, which must be called when finished,
- *   passing an `error` (which can be `null`) and the result of the function's
- *   execution.
- * @param {number} [concurrency=Infinity] - An optional `integer` for
- * determining the maximum number of tasks that can be run in parallel. By
- * default, as many as possible.
- * @param {Function} [callback] - An optional callback which is called when all
- * the tasks have been completed. It receives the `err` argument if any `tasks`
- * pass an error to their callback. Results are always returned; however, if an
- * error occurs, no further `tasks` will be performed, and the results object
- * will only contain partial results. Invoked with (err, results).
- * @returns {Promise} a promise, if a callback is not passed
- * @example
- *
- * //Using Callbacks
- * async.auto({
- *     get_data: function(callback) {
- *         // async code to get some data
- *         callback(null, 'data', 'converted to array');
- *     },
- *     make_folder: function(callback) {
- *         // async code to create a directory to store a file in
- *         // this is run at the same time as getting the data
- *         callback(null, 'folder');
- *     },
- *     write_file: ['get_data', 'make_folder', function(results, callback) {
- *         // once there is some data and the directory exists,
- *         // write the data to a file in the directory
- *         callback(null, 'filename');
- *     }],
- *     email_link: ['write_file', function(results, callback) {
- *         // once the file is written let's email a link to it...
- *         callback(null, {'file':results.write_file, 'email':'user@example.com'});
- *     }]
- * }, function(err, results) {
- *     if (err) {
- *         console.log('err = ', err);
- *     }
- *     console.log('results = ', results);
- *     // results = {
- *     //     get_data: ['data', 'converted to array']
- *     //     make_folder; 'folder',
- *     //     write_file: 'filename'
- *     //     email_link: { file: 'filename', email: 'user@example.com' }
- *     // }
- * });
- *
- * //Using Promises
- * async.auto({
- *     get_data: function(callback) {
- *         console.log('in get_data');
- *         // async code to get some data
- *         callback(null, 'data', 'converted to array');
- *     },
- *     make_folder: function(callback) {
- *         console.log('in make_folder');
- *         // async code to create a directory to store a file in
- *         // this is run at the same time as getting the data
- *         callback(null, 'folder');
- *     },
- *     write_file: ['get_data', 'make_folder', function(results, callback) {
- *         // once there is some data and the directory exists,
- *         // write the data to a file in the directory
- *         callback(null, 'filename');
- *     }],
- *     email_link: ['write_file', function(results, callback) {
- *         // once the file is written let's email a link to it...
- *         callback(null, {'file':results.write_file, 'email':'user@example.com'});
- *     }]
- * }).then(results => {
- *     console.log('results = ', results);
- *     // results = {
- *     //     get_data: ['data', 'converted to array']
- *     //     make_folder; 'folder',
- *     //     write_file: 'filename'
- *     //     email_link: { file: 'filename', email: 'user@example.com' }
- *     // }
- * }).catch(err => {
- *     console.log('err = ', err);
- * });
- *
- * //Using async/await
- * async () => {
- *     try {
- *         let results = await async.auto({
- *             get_data: function(callback) {
- *                 // async code to get some data
- *                 callback(null, 'data', 'converted to array');
- *             },
- *             make_folder: function(callback) {
- *                 // async code to create a directory to store a file in
- *                 // this is run at the same time as getting the data
- *                 callback(null, 'folder');
- *             },
- *             write_file: ['get_data', 'make_folder', function(results, callback) {
- *                 // once there is some data and the directory exists,
- *                 // write the data to a file in the directory
- *                 callback(null, 'filename');
- *             }],
- *             email_link: ['write_file', function(results, callback) {
- *                 // once the file is written let's email a link to it...
- *                 callback(null, {'file':results.write_file, 'email':'user@example.com'});
- *             }]
- *         });
- *         console.log('results = ', results);
- *         // results = {
- *         //     get_data: ['data', 'converted to array']
- *         //     make_folder; 'folder',
- *         //     write_file: 'filename'
- *         //     email_link: { file: 'filename', email: 'user@example.com' }
- *         // }
- *     }
- *     catch (err) {
- *         console.log(err);
- *     }
- * }
- *
- */
-function auto(tasks, concurrency, callback) {
-    if (typeof concurrency !== 'number') {
-        // concurrency is optional, shift the args.
-        callback = concurrency;
-        concurrency = null;
-    }
-    callback = (0, _once2.default)(callback || (0, _promiseCallback.promiseCallback)());
-    var numTasks = Object.keys(tasks).length;
-    if (!numTasks) {
-        return callback(null);
-    }
-    if (!concurrency) {
-        concurrency = numTasks;
-    }
-
-    var results = {};
-    var runningTasks = 0;
-    var canceled = false;
-    var hasError = false;
-
-    var listeners = Object.create(null);
-
-    var readyTasks = [];
-
-    // for cycle detection:
-    var readyToCheck = []; // tasks that have been identified as reachable
-    // without the possibility of returning to an ancestor task
-    var uncheckedDependencies = {};
-
-    Object.keys(tasks).forEach(key => {
-        var task = tasks[key];
-        if (!Array.isArray(task)) {
-            // no dependencies
-            enqueueTask(key, [task]);
-            readyToCheck.push(key);
-            return;
-        }
-
-        var dependencies = task.slice(0, task.length - 1);
-        var remainingDependencies = dependencies.length;
-        if (remainingDependencies === 0) {
-            enqueueTask(key, task);
-            readyToCheck.push(key);
-            return;
-        }
-        uncheckedDependencies[key] = remainingDependencies;
-
-        dependencies.forEach(dependencyName => {
-            if (!tasks[dependencyName]) {
-                throw new Error('async.auto task `' + key + '` has a non-existent dependency `' + dependencyName + '` in ' + dependencies.join(', '));
-            }
-            addListener(dependencyName, () => {
-                remainingDependencies--;
-                if (remainingDependencies === 0) {
-                    enqueueTask(key, task);
-                }
-            });
-        });
-    });
-
-    checkForDeadlocks();
-    processQueue();
-
-    function enqueueTask(key, task) {
-        readyTasks.push(() => runTask(key, task));
-    }
-
-    function processQueue() {
-        if (canceled) return;
-        if (readyTasks.length === 0 && runningTasks === 0) {
-            return callback(null, results);
-        }
-        while (readyTasks.length && runningTasks < concurrency) {
-            var run = readyTasks.shift();
-            run();
-        }
-    }
-
-    function addListener(taskName, fn) {
-        var taskListeners = listeners[taskName];
-        if (!taskListeners) {
-            taskListeners = listeners[taskName] = [];
-        }
-
-        taskListeners.push(fn);
-    }
-
-    function taskComplete(taskName) {
-        var taskListeners = listeners[taskName] || [];
-        taskListeners.forEach(fn => fn());
-        processQueue();
-    }
-
-    function runTask(key, task) {
-        if (hasError) return;
-
-        var taskCallback = (0, _onlyOnce2.default)((err, ...result) => {
-            runningTasks--;
-            if (err === false) {
-                canceled = true;
-                return;
-            }
-            if (result.length < 2) {
-                [result] = result;
-            }
-            if (err) {
-                var safeResults = {};
-                Object.keys(results).forEach(rkey => {
-                    safeResults[rkey] = results[rkey];
-                });
-                safeResults[key] = result;
-                hasError = true;
-                listeners = Object.create(null);
-                if (canceled) return;
-                callback(err, safeResults);
-            } else {
-                results[key] = result;
-                taskComplete(key);
-            }
-        });
-
-        runningTasks++;
-        var taskFn = (0, _wrapAsync2.default)(task[task.length - 1]);
-        if (task.length > 1) {
-            taskFn(results, taskCallback);
-        } else {
-            taskFn(taskCallback);
-        }
-    }
-
-    function checkForDeadlocks() {
-        // Kahn's algorithm
-        // https://en.wikipedia.org/wiki/Topological_sorting#Kahn.27s_algorithm
-        // http://connalle.blogspot.com/2013/10/topological-sortingkahn-algorithm.html
-        var currentTask;
-        var counter = 0;
-        while (readyToCheck.length) {
-            currentTask = readyToCheck.pop();
-            counter++;
-            getDependents(currentTask).forEach(dependent => {
-                if (--uncheckedDependencies[dependent] === 0) {
-                    readyToCheck.push(dependent);
-                }
-            });
-        }
-
-        if (counter !== numTasks) {
-            throw new Error('async.auto cannot execute tasks due to a recursive dependency');
-        }
-    }
-
-    function getDependents(taskName) {
-        var result = [];
-        Object.keys(tasks).forEach(key => {
-            const task = tasks[key];
-            if (Array.isArray(task) && task.indexOf(taskName) >= 0) {
-                result.push(key);
-            }
-        });
-        return result;
-    }
-
-    return callback[_promiseCallback.PROMISE_SYMBOL];
-}
-module.exports = exports.default;

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

@@ -1,182 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = autoInject;
-
-var _auto = require('./auto.js');
-
-var _auto2 = _interopRequireDefault(_auto);
-
-var _wrapAsync = require('./internal/wrapAsync.js');
-
-var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-var FN_ARGS = /^(?:async\s)?(?:function)?\s*(?:\w+\s*)?\(([^)]+)\)(?:\s*{)/;
-var ARROW_FN_ARGS = /^(?:async\s)?\s*(?:\(\s*)?((?:[^)=\s]\s*)*)(?:\)\s*)?=>/;
-var FN_ARG_SPLIT = /,/;
-var FN_ARG = /(=.+)?(\s*)$/;
-
-function stripComments(string) {
-    let stripped = '';
-    let index = 0;
-    let endBlockComment = string.indexOf('*/');
-    while (index < string.length) {
-        if (string[index] === '/' && string[index + 1] === '/') {
-            // inline comment
-            let endIndex = string.indexOf('\n', index);
-            index = endIndex === -1 ? string.length : endIndex;
-        } else if (endBlockComment !== -1 && string[index] === '/' && string[index + 1] === '*') {
-            // block comment
-            let endIndex = string.indexOf('*/', index);
-            if (endIndex !== -1) {
-                index = endIndex + 2;
-                endBlockComment = string.indexOf('*/', index);
-            } else {
-                stripped += string[index];
-                index++;
-            }
-        } else {
-            stripped += string[index];
-            index++;
-        }
-    }
-    return stripped;
-}
-
-function parseParams(func) {
-    const src = stripComments(func.toString());
-    let match = src.match(FN_ARGS);
-    if (!match) {
-        match = src.match(ARROW_FN_ARGS);
-    }
-    if (!match) throw new Error('could not parse args in autoInject\nSource:\n' + src);
-    let [, args] = match;
-    return args.replace(/\s/g, '').split(FN_ARG_SPLIT).map(arg => arg.replace(FN_ARG, '').trim());
-}
-
-/**
- * A dependency-injected version of the [async.auto]{@link module:ControlFlow.auto} function. Dependent
- * tasks are specified as parameters to the function, after the usual callback
- * parameter, with the parameter names matching the names of the tasks it
- * depends on. This can provide even more readable task graphs which can be
- * easier to maintain.
- *
- * If a final callback is specified, the task results are similarly injected,
- * specified as named parameters after the initial error parameter.
- *
- * The autoInject function is purely syntactic sugar and its semantics are
- * otherwise equivalent to [async.auto]{@link module:ControlFlow.auto}.
- *
- * @name autoInject
- * @static
- * @memberOf module:ControlFlow
- * @method
- * @see [async.auto]{@link module:ControlFlow.auto}
- * @category Control Flow
- * @param {Object} tasks - An object, each of whose properties is an {@link AsyncFunction} of
- * the form 'func([dependencies...], callback). The object's key of a property
- * serves as the name of the task defined by that property, i.e. can be used
- * when specifying requirements for other tasks.
- * * The `callback` parameter is a `callback(err, result)` which must be called
- *   when finished, passing an `error` (which can be `null`) and the result of
- *   the function's execution. The remaining parameters name other tasks on
- *   which the task is dependent, and the results from those tasks are the
- *   arguments of those parameters.
- * @param {Function} [callback] - An optional callback which is called when all
- * the tasks have been completed. It receives the `err` argument if any `tasks`
- * pass an error to their callback, and a `results` object with any completed
- * task results, similar to `auto`.
- * @returns {Promise} a promise, if no callback is passed
- * @example
- *
- * //  The example from `auto` can be rewritten as follows:
- * async.autoInject({
- *     get_data: function(callback) {
- *         // async code to get some data
- *         callback(null, 'data', 'converted to array');
- *     },
- *     make_folder: function(callback) {
- *         // async code to create a directory to store a file in
- *         // this is run at the same time as getting the data
- *         callback(null, 'folder');
- *     },
- *     write_file: function(get_data, make_folder, callback) {
- *         // once there is some data and the directory exists,
- *         // write the data to a file in the directory
- *         callback(null, 'filename');
- *     },
- *     email_link: function(write_file, callback) {
- *         // once the file is written let's email a link to it...
- *         // write_file contains the filename returned by write_file.
- *         callback(null, {'file':write_file, 'email':'user@example.com'});
- *     }
- * }, function(err, results) {
- *     console.log('err = ', err);
- *     console.log('email_link = ', results.email_link);
- * });
- *
- * // If you are using a JS minifier that mangles parameter names, `autoInject`
- * // will not work with plain functions, since the parameter names will be
- * // collapsed to a single letter identifier.  To work around this, you can
- * // explicitly specify the names of the parameters your task function needs
- * // in an array, similar to Angular.js dependency injection.
- *
- * // This still has an advantage over plain `auto`, since the results a task
- * // depends on are still spread into arguments.
- * async.autoInject({
- *     //...
- *     write_file: ['get_data', 'make_folder', function(get_data, make_folder, callback) {
- *         callback(null, 'filename');
- *     }],
- *     email_link: ['write_file', function(write_file, callback) {
- *         callback(null, {'file':write_file, 'email':'user@example.com'});
- *     }]
- *     //...
- * }, function(err, results) {
- *     console.log('err = ', err);
- *     console.log('email_link = ', results.email_link);
- * });
- */
-function autoInject(tasks, callback) {
-    var newTasks = {};
-
-    Object.keys(tasks).forEach(key => {
-        var taskFn = tasks[key];
-        var params;
-        var fnIsAsync = (0, _wrapAsync.isAsync)(taskFn);
-        var hasNoDeps = !fnIsAsync && taskFn.length === 1 || fnIsAsync && taskFn.length === 0;
-
-        if (Array.isArray(taskFn)) {
-            params = [...taskFn];
-            taskFn = params.pop();
-
-            newTasks[key] = params.concat(params.length > 0 ? newTask : taskFn);
-        } else if (hasNoDeps) {
-            // no dependencies, use the function as-is
-            newTasks[key] = taskFn;
-        } else {
-            params = parseParams(taskFn);
-            if (taskFn.length === 0 && !fnIsAsync && params.length === 0) {
-                throw new Error("autoInject task functions require explicit parameters.");
-            }
-
-            // remove callback param
-            if (!fnIsAsync) params.pop();
-
-            newTasks[key] = params.concat(newTask);
-        }
-
-        function newTask(results, taskCb) {
-            var newArgs = params.map(name => results[name]);
-            newArgs.push(taskCb);
-            (0, _wrapAsync2.default)(taskFn)(...newArgs);
-        }
-    });
-
-    return (0, _auto2.default)(newTasks, callback);
-}
-module.exports = exports.default;

package/rust-client/node_modules/async/bower.json

@@ -1,17 +0,0 @@
-{
-  "name": "async",
-  "main": "dist/async.js",
-  "ignore": [
-    "bower_components",
-    "lib",
-    "test",
-    "node_modules",
-    "perf",
-    "support",
-    "**/.*",
-    "*.config.js",
-    "*.json",
-    "index.js",
-    "Makefile"
-  ]
-}

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

@@ -1,63 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = cargo;
-
-var _queue = require('./internal/queue.js');
-
-var _queue2 = _interopRequireDefault(_queue);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Creates a `cargo` object with the specified payload. Tasks added to the
- * cargo will be processed altogether (up to the `payload` limit). If the
- * `worker` is in progress, the task is queued until it becomes available. Once
- * the `worker` has completed some tasks, each callback of those tasks is
- * called. Check out [these](https://camo.githubusercontent.com/6bbd36f4cf5b35a0f11a96dcd2e97711ffc2fb37/68747470733a2f2f662e636c6f75642e6769746875622e636f6d2f6173736574732f313637363837312f36383130382f62626330636662302d356632392d313165322d393734662d3333393763363464633835382e676966) [animations](https://camo.githubusercontent.com/f4810e00e1c5f5f8addbe3e9f49064fd5d102699/68747470733a2f2f662e636c6f75642e6769746875622e636f6d2f6173736574732f313637363837312f36383130312f38346339323036362d356632392d313165322d383134662d3964336430323431336266642e676966)
- * for how `cargo` and `queue` work.
- *
- * While [`queue`]{@link module:ControlFlow.queue} passes only one task to one of a group of workers
- * at a time, cargo passes an array of tasks to a single worker, repeating
- * when the worker is finished.
- *
- * @name cargo
- * @static
- * @memberOf module:ControlFlow
- * @method
- * @see [async.queue]{@link module:ControlFlow.queue}
- * @category Control Flow
- * @param {AsyncFunction} worker - An asynchronous function for processing an array
- * of queued tasks. Invoked with `(tasks, callback)`.
- * @param {number} [payload=Infinity] - An optional `integer` for determining
- * how many tasks should be processed per round; if omitted, the default is
- * unlimited.
- * @returns {module:ControlFlow.QueueObject} A cargo object to manage the tasks. Callbacks can
- * attached as certain properties to listen for specific events during the
- * lifecycle of the cargo and inner queue.
- * @example
- *
- * // create a cargo object with payload 2
- * var cargo = async.cargo(function(tasks, callback) {
- *     for (var i=0; i<tasks.length; i++) {
- *         console.log('hello ' + tasks[i].name);
- *     }
- *     callback();
- * }, 2);
- *
- * // add some items
- * cargo.push({name: 'foo'}, function(err) {
- *     console.log('finished processing foo');
- * });
- * cargo.push({name: 'bar'}, function(err) {
- *     console.log('finished processing bar');
- * });
- * await cargo.push({name: 'baz'});
- * console.log('finished processing baz');
- */
-function cargo(worker, payload) {
-    return (0, _queue2.default)(worker, 1, payload);
-}
-module.exports = exports.default;

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

@@ -1,71 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.default = cargo;
-
-var _queue = require('./internal/queue.js');
-
-var _queue2 = _interopRequireDefault(_queue);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Creates a `cargoQueue` object with the specified payload. Tasks added to the
- * cargoQueue will be processed together (up to the `payload` limit) in `concurrency` parallel workers.
- * If the all `workers` are in progress, the task is queued until one becomes available. Once
- * a `worker` has completed some tasks, each callback of those tasks is
- * called. Check out [these](https://camo.githubusercontent.com/6bbd36f4cf5b35a0f11a96dcd2e97711ffc2fb37/68747470733a2f2f662e636c6f75642e6769746875622e636f6d2f6173736574732f313637363837312f36383130382f62626330636662302d356632392d313165322d393734662d3333393763363464633835382e676966) [animations](https://camo.githubusercontent.com/f4810e00e1c5f5f8addbe3e9f49064fd5d102699/68747470733a2f2f662e636c6f75642e6769746875622e636f6d2f6173736574732f313637363837312f36383130312f38346339323036362d356632392d313165322d383134662d3964336430323431336266642e676966)
- * for how `cargo` and `queue` work.
- *
- * While [`queue`]{@link module:ControlFlow.queue} passes only one task to one of a group of workers
- * at a time, and [`cargo`]{@link module:ControlFlow.cargo} passes an array of tasks to a single worker,
- * the cargoQueue passes an array of tasks to multiple parallel workers.
- *
- * @name cargoQueue
- * @static
- * @memberOf module:ControlFlow
- * @method
- * @see [async.queue]{@link module:ControlFlow.queue}
- * @see [async.cargo]{@link module:ControlFLow.cargo}
- * @category Control Flow
- * @param {AsyncFunction} worker - An asynchronous function for processing an array
- * of queued tasks. Invoked with `(tasks, callback)`.
- * @param {number} [concurrency=1] - An `integer` for determining how many
- * `worker` functions should be run in parallel.  If omitted, the concurrency
- * defaults to `1`.  If the concurrency is `0`, an error is thrown.
- * @param {number} [payload=Infinity] - An optional `integer` for determining
- * how many tasks should be processed per round; if omitted, the default is
- * unlimited.
- * @returns {module:ControlFlow.QueueObject} A cargoQueue object to manage the tasks. Callbacks can
- * attached as certain properties to listen for specific events during the
- * lifecycle of the cargoQueue and inner queue.
- * @example
- *
- * // create a cargoQueue object with payload 2 and concurrency 2
- * var cargoQueue = async.cargoQueue(function(tasks, callback) {
- *     for (var i=0; i<tasks.length; i++) {
- *         console.log('hello ' + tasks[i].name);
- *     }
- *     callback();
- * }, 2, 2);
- *
- * // add some items
- * cargoQueue.push({name: 'foo'}, function(err) {
- *     console.log('finished processing foo');
- * });
- * cargoQueue.push({name: 'bar'}, function(err) {
- *     console.log('finished processing bar');
- * });
- * cargoQueue.push({name: 'baz'}, function(err) {
- *     console.log('finished processing baz');
- * });
- * cargoQueue.push({name: 'boo'}, function(err) {
- *     console.log('finished processing boo');
- * });
- */
-function cargo(worker, concurrency, payload) {
-    return (0, _queue2.default)(worker, concurrency, payload);
-}
-module.exports = exports.default;