orcaq 1.1.1 → 1.1.2

package/.output/server/node_modules/@redis/client/dist/lib/sentinel/module.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands_1 = __importDefault(require("./commands"));
+exports.default = {
+    sentinel: commands_1.default
+};
+//# sourceMappingURL=module.js.map

package/.output/server/node_modules/@redis/client/dist/lib/sentinel/multi-commands.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands_1 = require("../commands");
+const multi_command_1 = __importDefault(require("../multi-command"));
+const commander_1 = require("../commander");
+const parser_1 = require("../client/parser");
+class RedisSentinelMultiCommand {
+    static _createCommand(command, resp) {
+        const transformReply = (0, commander_1.getTransformReply)(command, resp);
+        return function (...args) {
+            const parser = new parser_1.BasicCommandParser();
+            command.parseCommand(parser, ...args);
+            const redisArgs = parser.redisArgs;
+            redisArgs.preserve = parser.preserve;
+            return this.addCommand(command.IS_READ_ONLY, redisArgs, transformReply);
+        };
+    }
+    static _createModuleCommand(command, resp) {
+        const transformReply = (0, commander_1.getTransformReply)(command, resp);
+        return function (...args) {
+            const parser = new parser_1.BasicCommandParser();
+            command.parseCommand(parser, ...args);
+            const redisArgs = parser.redisArgs;
+            redisArgs.preserve = parser.preserve;
+            return this._self.addCommand(command.IS_READ_ONLY, redisArgs, transformReply);
+        };
+    }
+    static _createFunctionCommand(name, fn, resp) {
+        const prefix = (0, commander_1.functionArgumentsPrefix)(name, fn);
+        const transformReply = (0, commander_1.getTransformReply)(fn, resp);
+        return function (...args) {
+            const parser = new parser_1.BasicCommandParser();
+            parser.push(...prefix);
+            fn.parseCommand(parser, ...args);
+            const redisArgs = parser.redisArgs;
+            redisArgs.preserve = parser.preserve;
+            return this._self.addCommand(fn.IS_READ_ONLY, redisArgs, transformReply);
+        };
+    }
+    static _createScriptCommand(script, resp) {
+        const transformReply = (0, commander_1.getTransformReply)(script, resp);
+        return function (...args) {
+            const parser = new parser_1.BasicCommandParser();
+            script.parseCommand(parser, ...args);
+            const scriptArgs = parser.redisArgs;
+            scriptArgs.preserve = parser.preserve;
+            return this.#addScript(script.IS_READ_ONLY, script, scriptArgs, transformReply);
+        };
+    }
+    static extend(config) {
+        return (0, commander_1.attachConfig)({
+            BaseClass: RedisSentinelMultiCommand,
+            commands: commands_1.NON_STICKY_COMMANDS,
+            createCommand: RedisSentinelMultiCommand._createCommand,
+            createModuleCommand: RedisSentinelMultiCommand._createModuleCommand,
+            createFunctionCommand: RedisSentinelMultiCommand._createFunctionCommand,
+            createScriptCommand: RedisSentinelMultiCommand._createScriptCommand,
+            config
+        });
+    }
+    #multi = new multi_command_1.default();
+    #sentinel;
+    #isReadonly = true;
+    constructor(sentinel, typeMapping) {
+        this.#multi = new multi_command_1.default(typeMapping);
+        this.#sentinel = sentinel;
+    }
+    #setState(isReadonly) {
+        this.#isReadonly &&= isReadonly;
+    }
+    addCommand(isReadonly, args, transformReply) {
+        this.#setState(isReadonly);
+        this.#multi.addCommand(args, transformReply);
+        return this;
+    }
+    #addScript(isReadonly, script, args, transformReply) {
+        this.#setState(isReadonly);
+        this.#multi.addScript(script, args, transformReply);
+        return this;
+    }
+    async exec(execAsPipeline = false) {
+        if (execAsPipeline)
+            return this.execAsPipeline();
+        return this.#multi.transformReplies(await this.#sentinel._executeMulti(this.#isReadonly, this.#multi.queue));
+    }
+    EXEC = this.exec;
+    execTyped(execAsPipeline = false) {
+        return this.exec(execAsPipeline);
+    }
+    async execAsPipeline() {
+        if (this.#multi.queue.length === 0)
+            return [];
+        return this.#multi.transformReplies(await this.#sentinel._executePipeline(this.#isReadonly, this.#multi.queue));
+    }
+    execAsPipelineTyped() {
+        return this.execAsPipeline();
+    }
+    /**
+     * Adds a raw command to the multi/pipeline queue.
+     *
+     * Note: Using this method breaks the type inference for `execTyped` and
+     * `execAsPipelineTyped`. This is a known limitation and will be addressed
+     * in the future.
+     */
+    sendCommand(args, options) {
+        const redisArgs = args.slice();
+        this.addCommand(options?.isReadonly, redisArgs);
+        return this;
+    }
+}
+exports.default = RedisSentinelMultiCommand;
+//# sourceMappingURL=multi-commands.js.map

package/.output/server/node_modules/@redis/client/dist/lib/sentinel/pub-sub-proxy.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PubSubProxy = void 0;
+const node_events_1 = __importDefault(require("node:events"));
+const pub_sub_1 = require("../client/pub-sub");
+const client_1 = __importDefault(require("../client"));
+class PubSubProxy extends node_events_1.default {
+    #clientOptions;
+    #onError;
+    #node;
+    #state;
+    #subscriptions;
+    constructor(clientOptions, onError) {
+        super();
+        this.#clientOptions = clientOptions;
+        this.#onError = onError;
+    }
+    #createClient() {
+        if (this.#node === undefined) {
+            throw new Error("pubSubProxy: didn't define node to do pubsub against");
+        }
+        return new client_1.default({
+            ...this.#clientOptions,
+            socket: {
+                ...this.#clientOptions.socket,
+                host: this.#node.host,
+                port: this.#node.port
+            }
+        });
+    }
+    async #initiatePubSubClient(withSubscriptions = false) {
+        const client = this.#createClient()
+            .on('error', this.#onError);
+        const connectPromise = client.connect()
+            .then(async (client) => {
+            if (this.#state?.client !== client) {
+                // if pubsub was deactivated while connecting (`this.#pubSubClient === undefined`)
+                // or if the node changed (`this.#pubSubClient.client !== client`)
+                client.destroy();
+                return this.#state?.connectPromise;
+            }
+            if (withSubscriptions && this.#subscriptions) {
+                await Promise.all([
+                    client.extendPubSubListeners(pub_sub_1.PUBSUB_TYPE.CHANNELS, this.#subscriptions[pub_sub_1.PUBSUB_TYPE.CHANNELS]),
+                    client.extendPubSubListeners(pub_sub_1.PUBSUB_TYPE.PATTERNS, this.#subscriptions[pub_sub_1.PUBSUB_TYPE.PATTERNS]),
+                    client.extendPubSubListeners(pub_sub_1.PUBSUB_TYPE.SHARDED, this.#subscriptions[pub_sub_1.PUBSUB_TYPE.SHARDED])
+                ]);
+            }
+            if (this.#state.client !== client) {
+                // if the node changed (`this.#pubSubClient.client !== client`)
+                client.destroy();
+                return this.#state?.connectPromise;
+            }
+            this.#state.connectPromise = undefined;
+            return client;
+        })
+            .catch(err => {
+            this.#state = undefined;
+            throw err;
+        });
+        this.#state = {
+            client,
+            connectPromise
+        };
+        return connectPromise;
+    }
+    #getPubSubClient() {
+        if (!this.#state)
+            return this.#initiatePubSubClient();
+        return (this.#state.connectPromise ??
+            this.#state.client);
+    }
+    async changeNode(node) {
+        this.#node = node;
+        if (!this.#state)
+            return;
+        // if `connectPromise` is undefined, `this.#subscriptions` is already set
+        // and `this.#state.client` might not have the listeners set yet
+        if (this.#state.connectPromise === undefined) {
+            this.#subscriptions = {
+                [pub_sub_1.PUBSUB_TYPE.CHANNELS]: this.#state.client.getPubSubListeners(pub_sub_1.PUBSUB_TYPE.CHANNELS),
+                [pub_sub_1.PUBSUB_TYPE.PATTERNS]: this.#state.client.getPubSubListeners(pub_sub_1.PUBSUB_TYPE.PATTERNS),
+                [pub_sub_1.PUBSUB_TYPE.SHARDED]: this.#state.client.getPubSubListeners(pub_sub_1.PUBSUB_TYPE.SHARDED)
+            };
+            this.#state.client.destroy();
+        }
+        await this.#initiatePubSubClient(true);
+    }
+    #executeCommand(fn) {
+        const client = this.#getPubSubClient();
+        if (client instanceof client_1.default) {
+            return fn(client);
+        }
+        return client.then(client => {
+            // if pubsub was deactivated while connecting
+            if (client === undefined)
+                return;
+            return fn(client);
+        }).catch(err => {
+            if (this.#state?.client.isPubSubActive) {
+                this.#state.client.destroy();
+                this.#state = undefined;
+            }
+            throw err;
+        });
+    }
+    subscribe(channels, listener, bufferMode) {
+        return this.#executeCommand(client => client.SUBSCRIBE(channels, listener, bufferMode));
+    }
+    #unsubscribe(fn) {
+        return this.#executeCommand(async (client) => {
+            const reply = await fn(client);
+            if (!client.isPubSubActive) {
+                client.destroy();
+                this.#state = undefined;
+            }
+            return reply;
+        });
+    }
+    async unsubscribe(channels, listener, bufferMode) {
+        return this.#unsubscribe(client => client.UNSUBSCRIBE(channels, listener, bufferMode));
+    }
+    async pSubscribe(patterns, listener, bufferMode) {
+        return this.#executeCommand(client => client.PSUBSCRIBE(patterns, listener, bufferMode));
+    }
+    async pUnsubscribe(patterns, listener, bufferMode) {
+        return this.#unsubscribe(client => client.PUNSUBSCRIBE(patterns, listener, bufferMode));
+    }
+    sSubscribe(channels, listener, bufferMode) {
+        return this.#executeCommand(client => client.SSUBSCRIBE(channels, listener, bufferMode));
+    }
+    async sUnsubscribe(channels, listener, bufferMode) {
+        return this.#unsubscribe(client => client.SUNSUBSCRIBE(channels, listener, bufferMode));
+    }
+    destroy() {
+        this.#subscriptions = undefined;
+        if (this.#state === undefined)
+            return;
+        // `connectPromise` already handles the case of `this.#pubSubState = undefined`
+        if (!this.#state.connectPromise) {
+            this.#state.client.destroy();
+        }
+        this.#state = undefined;
+    }
+}
+exports.PubSubProxy = PubSubProxy;
+//# sourceMappingURL=pub-sub-proxy.js.map

package/.output/server/node_modules/@redis/client/dist/lib/sentinel/utils.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMappedNode = exports.createScriptCommand = exports.createModuleCommand = exports.createFunctionCommand = exports.createCommand = exports.clientSocketToNode = exports.createNodeList = exports.parseNode = void 0;
+const parser_1 = require("../client/parser");
+const commander_1 = require("../commander");
+/* TODO: should use map interface, would need a transform reply probably? as resp2 is list form, which this depends on */
+function parseNode(node) {
+    if (node.flags.includes("s_down") || node.flags.includes("disconnected") || node.flags.includes("failover_in_progress")) {
+        return undefined;
+    }
+    return { host: node.ip, port: Number(node.port) };
+}
+exports.parseNode = parseNode;
+function createNodeList(nodes) {
+    var nodeList = [];
+    for (const nodeData of nodes) {
+        const node = parseNode(nodeData);
+        if (node === undefined) {
+            continue;
+        }
+        nodeList.push(node);
+    }
+    return nodeList;
+}
+exports.createNodeList = createNodeList;
+function clientSocketToNode(socket) {
+    const s = socket;
+    return {
+        host: s.host,
+        port: s.port
+    };
+}
+exports.clientSocketToNode = clientSocketToNode;
+function createCommand(command, resp) {
+    const transformReply = (0, commander_1.getTransformReply)(command, resp);
+    return async function (...args) {
+        const parser = new parser_1.BasicCommandParser();
+        command.parseCommand(parser, ...args);
+        return this._self._execute(command.IS_READ_ONLY, client => client._executeCommand(command, parser, this.commandOptions, transformReply));
+    };
+}
+exports.createCommand = createCommand;
+function createFunctionCommand(name, fn, resp) {
+    const prefix = (0, commander_1.functionArgumentsPrefix)(name, fn);
+    const transformReply = (0, commander_1.getTransformReply)(fn, resp);
+    return async function (...args) {
+        const parser = new parser_1.BasicCommandParser();
+        parser.push(...prefix);
+        fn.parseCommand(parser, ...args);
+        return this._self._execute(fn.IS_READ_ONLY, client => client._executeCommand(fn, parser, this._self.commandOptions, transformReply));
+    };
+}
+exports.createFunctionCommand = createFunctionCommand;
+;
+function createModuleCommand(command, resp) {
+    const transformReply = (0, commander_1.getTransformReply)(command, resp);
+    return async function (...args) {
+        const parser = new parser_1.BasicCommandParser();
+        command.parseCommand(parser, ...args);
+        return this._self._execute(command.IS_READ_ONLY, client => client._executeCommand(command, parser, this._self.commandOptions, transformReply));
+    };
+}
+exports.createModuleCommand = createModuleCommand;
+;
+function createScriptCommand(script, resp) {
+    const prefix = (0, commander_1.scriptArgumentsPrefix)(script);
+    const transformReply = (0, commander_1.getTransformReply)(script, resp);
+    return async function (...args) {
+        const parser = new parser_1.BasicCommandParser();
+        parser.push(...prefix);
+        script.parseCommand(parser, ...args);
+        return this._self._execute(script.IS_READ_ONLY, client => client._executeScript(script, parser, this.commandOptions, transformReply));
+    };
+}
+exports.createScriptCommand = createScriptCommand;
+/**
+ * Returns the mapped node address for the given host and port using the nodeAddressMap.
+ * If no mapping exists, returns the original host and port.
+ *
+ * @param host The original host
+ * @param port The original port
+ * @param nodeAddressMap The node address map (object or function)
+ * @returns The mapped node or the original node if no mapping exists
+ */
+function getMappedNode(host, port, nodeAddressMap) {
+    if (nodeAddressMap === undefined) {
+        return { host, port };
+    }
+    const address = `${host}:${port}`;
+    switch (typeof nodeAddressMap) {
+        case 'object':
+            return nodeAddressMap[address] ?? { host, port };
+        case 'function':
+            return nodeAddressMap(address) ?? { host, port };
+    }
+}
+exports.getMappedNode = getMappedNode;
+//# sourceMappingURL=utils.js.map

package/.output/server/node_modules/@redis/client/dist/lib/sentinel/wait-queue.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaitQueue = void 0;
+const linked_list_1 = require("../client/linked-list");
+class WaitQueue {
+    #list = new linked_list_1.SinglyLinkedList();
+    #queue = new linked_list_1.SinglyLinkedList();
+    push(value) {
+        const resolve = this.#queue.shift();
+        if (resolve !== undefined) {
+            resolve(value);
+            return;
+        }
+        this.#list.push(value);
+    }
+    shift() {
+        return this.#list.shift();
+    }
+    wait() {
+        return new Promise(resolve => this.#queue.push(resolve));
+    }
+}
+exports.WaitQueue = WaitQueue;
+//# sourceMappingURL=wait-queue.js.map

package/.output/server/node_modules/@redis/client/dist/lib/single-entry-cache.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class SingleEntryCache {
+    #cached;
+    #serializedKey;
+    /**
+     * Retrieves an instance from the cache based on the provided key object.
+     *
+     * @param keyObj - The key object to look up in the cache.
+     * @returns The cached instance if found, undefined otherwise.
+     *
+     * @remarks
+     * This method uses JSON.stringify for comparison, which may not work correctly
+     * if the properties in the key object are rearranged or reordered.
+     */
+    get(keyObj) {
+        return JSON.stringify(keyObj, makeCircularReplacer()) === this.#serializedKey ? this.#cached : undefined;
+    }
+    set(keyObj, obj) {
+        this.#cached = obj;
+        this.#serializedKey = JSON.stringify(keyObj, makeCircularReplacer());
+    }
+}
+exports.default = SingleEntryCache;
+function makeCircularReplacer() {
+    const seen = new WeakSet();
+    return function serialize(_, value) {
+        if (value && typeof value === 'object') {
+            if (seen.has(value)) {
+                return 'circular';
+            }
+            seen.add(value);
+            return value;
+        }
+        return value;
+    };
+}
+//# sourceMappingURL=single-entry-cache.js.map

package/.output/server/node_modules/@redis/client/dist/lib/utils/digest.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.digest = void 0;
+let xxh3Cache = null;
+async function getXxh3() {
+    if (!xxh3Cache) {
+        try {
+            const module = await import('@node-rs/xxhash');
+            xxh3Cache = module.xxh3;
+        }
+        catch {
+            throw new Error('The "digest" function requires the "@node-rs/xxhash" package, but it was not found.');
+        }
+    }
+    return xxh3Cache;
+}
+/**
+ * Computes a deterministic 64-bit XXH3 digest of the input.
+ *
+ * This produces the same digest that Redis computes internally via the `DIGEST` command,
+ * allowing you to use it with conditional SET and DELEX operations (`IFDEQ`, `IFDNE`).
+ *
+ * @param value - The value to compute the digest for (string or Buffer)
+ * @returns A 16-character lowercase hexadecimal digest
+ * @throws If the `@node-rs/xxhash` package is not found
+ */
+async function digest(value) {
+    const xxh3 = await getXxh3();
+    const data = typeof value === 'string' ? value : new Uint8Array(value);
+    const hash = xxh3.xxh64(data);
+    return hash.toString(16).padStart(16, '0');
+}
+exports.digest = digest;
+//# sourceMappingURL=digest.js.map

package/.output/server/node_modules/@redis/client/dist/package.json

@@ -0,0 +1,52 @@
+{
+    "name": "@redis/client",
+    "version": "5.12.1",
+    "license": "MIT",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "files": [
+        "dist/",
+        "!dist/tsconfig.tsbuildinfo"
+    ],
+    "scripts": {
+        "test": "nyc -r text-summary -r lcov mocha -r tsx --reporter mocha-multi-reporters --reporter-options configFile=mocha-multi-reporter-config.json --exit './lib/**/*.spec.ts'",
+        "release": "release-it"
+    },
+    "dependencies": {
+        "cluster-key-slot": "1.1.2"
+    },
+    "devDependencies": {
+        "@node-rs/xxhash": "1.7.6",
+        "@opentelemetry/api": "^1.9.0",
+        "@opentelemetry/sdk-metrics": "^2.2.0",
+        "@redis/test-utils": "*",
+        "@types/sinon": "^17.0.3",
+        "sinon": "^17.0.1"
+    },
+    "peerDependencies": {
+        "@opentelemetry/api": ">=1 <2",
+        "@node-rs/xxhash": "^1.1.0"
+    },
+    "peerDependenciesMeta": {
+        "@opentelemetry/api": {
+            "optional": true
+        },
+        "@node-rs/xxhash": {
+            "optional": true
+        }
+    },
+    "engines": {
+        "node": ">= 18.19.0"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git://github.com/redis/node-redis.git"
+    },
+    "bugs": {
+        "url": "https://github.com/redis/node-redis/issues"
+    },
+    "homepage": "https://github.com/redis/node-redis/tree/master/packages/client",
+    "keywords": [
+        "redis"
+    ]
+}

package/.output/server/node_modules/@redis/client/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@redis/client",
+  "version": "5.12.1",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/",
+    "!dist/tsconfig.tsbuildinfo"
+  ],
+  "scripts": {
+    "test": "nyc -r text-summary -r lcov mocha -r tsx --reporter mocha-multi-reporters --reporter-options configFile=mocha-multi-reporter-config.json --exit './lib/**/*.spec.ts'",
+    "release": "release-it"
+  },
+  "dependencies": {
+    "cluster-key-slot": "1.1.2"
+  },
+  "devDependencies": {
+    "@node-rs/xxhash": "1.7.6",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/sdk-metrics": "^2.2.0",
+    "@redis/test-utils": "*",
+    "@types/sinon": "^17.0.3",
+    "sinon": "^17.0.1"
+  },
+  "peerDependencies": {
+    "@opentelemetry/api": ">=1 <2",
+    "@node-rs/xxhash": "^1.1.0"
+  },
+  "peerDependenciesMeta": {
+    "@opentelemetry/api": {
+      "optional": true
+    },
+    "@node-rs/xxhash": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">= 18.19.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/redis/node-redis.git"
+  },
+  "bugs": {
+    "url": "https://github.com/redis/node-redis/issues"
+  },
+  "homepage": "https://github.com/redis/node-redis/tree/master/packages/client",
+  "keywords": [
+    "redis"
+  ]
+}

package/.output/server/node_modules/@redis/json/dist/lib/commands/ARRAPPEND.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+exports.default = {
+    IS_READ_ONLY: false,
+    /**
+     * Appends one or more values to the end of an array in a JSON document.
+     * Returns the new array length after append, or null if the path does not exist.
+     *
+     * @param parser - The Redis command parser
+     * @param key - The key to append to
+     * @param path - Path to the array in the JSON document
+     * @param json - The first value to append
+     * @param jsons - Additional values to append
+     */
+    parseCommand(parser, key, path, json, ...jsons) {
+        parser.push('JSON.ARRAPPEND');
+        parser.pushKey(key);
+        parser.push(path, (0, generic_transformers_1.transformRedisJsonArgument)(json));
+        for (let i = 0; i < jsons.length; i++) {
+            parser.push((0, generic_transformers_1.transformRedisJsonArgument)(jsons[i]));
+        }
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=ARRAPPEND.js.map

package/.output/server/node_modules/@redis/json/dist/lib/commands/ARRINDEX.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+exports.default = {
+    IS_READ_ONLY: true,
+    /**
+     * Returns the index of the first occurrence of a value in a JSON array.
+     * If the specified value is not found, it returns -1, or null if the path does not exist.
+     *
+     * @param parser - The Redis command parser
+     * @param key - The key containing the array
+     * @param path - Path to the array in the JSON document
+     * @param json - The value to search for
+     * @param options - Optional range parameters for the search
+     * @param options.range.start - Starting index for the search
+     * @param options.range.stop - Optional ending index for the search
+     */
+    parseCommand(parser, key, path, json, options) {
+        parser.push('JSON.ARRINDEX');
+        parser.pushKey(key);
+        parser.push(path, (0, generic_transformers_1.transformRedisJsonArgument)(json));
+        if (options?.range) {
+            parser.push(options.range.start.toString());
+            if (options.range.stop !== undefined) {
+                parser.push(options.range.stop.toString());
+            }
+        }
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=ARRINDEX.js.map

package/.output/server/node_modules/@redis/json/dist/lib/commands/ARRINSERT.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+exports.default = {
+    IS_READ_ONLY: false,
+    /**
+     * Inserts one or more values into an array at the specified index.
+     * Returns the new array length after insert, or null if the path does not exist.
+     *
+     * @param parser - The Redis command parser
+     * @param key - The key containing the array
+     * @param path - Path to the array in the JSON document
+     * @param index - The position where to insert the values
+     * @param json - The first value to insert
+     * @param jsons - Additional values to insert
+     */
+    parseCommand(parser, key, path, index, json, ...jsons) {
+        parser.push('JSON.ARRINSERT');
+        parser.pushKey(key);
+        parser.push(path, index.toString(), (0, generic_transformers_1.transformRedisJsonArgument)(json));
+        for (let i = 0; i < jsons.length; i++) {
+            parser.push((0, generic_transformers_1.transformRedisJsonArgument)(jsons[i]));
+        }
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=ARRINSERT.js.map