orcaq 1.0.20

package/.output/server/node_modules/@ioredis/commands/built/index.js

@@ -0,0 +1,208 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKeyIndexes = exports.hasFlag = exports.exists = exports.list = void 0;
+const commands_json_1 = __importDefault(require("./commands.json"));
+/**
+ * Redis command list
+ *
+ * All commands are lowercased.
+ */
+exports.list = Object.keys(commands_json_1.default);
+const flags = {};
+exports.list.forEach((commandName) => {
+    flags[commandName] = commands_json_1.default[commandName].flags.reduce(function (flags, flag) {
+        flags[flag] = true;
+        return flags;
+    }, {});
+});
+/**
+ * Check if the command exists
+ */
+function exists(commandName) {
+    return Boolean(commands_json_1.default[commandName]);
+}
+exports.exists = exists;
+/**
+ * Check if the command has the flag
+ *
+ * Some of possible flags: readonly, noscript, loading
+ */
+function hasFlag(commandName, flag) {
+    if (!flags[commandName]) {
+        throw new Error("Unknown command " + commandName);
+    }
+    return Boolean(flags[commandName][flag]);
+}
+exports.hasFlag = hasFlag;
+/**
+ * Get indexes of keys in the command arguments
+ *
+ * @example
+ * ```javascript
+ * getKeyIndexes('set', ['key', 'value']) // [0]
+ * getKeyIndexes('mget', ['key1', 'key2']) // [0, 1]
+ * ```
+ */
+function getKeyIndexes(commandName, args, options) {
+    const command = commands_json_1.default[commandName];
+    if (!command) {
+        throw new Error("Unknown command " + commandName);
+    }
+    if (!Array.isArray(args)) {
+        throw new Error("Expect args to be an array");
+    }
+    const keys = [];
+    const parseExternalKey = Boolean(options && options.parseExternalKey);
+    const takeDynamicKeys = (args, startIndex) => {
+        const keys = [];
+        const keyStop = Number(args[startIndex]);
+        for (let i = 0; i < keyStop; i++) {
+            keys.push(i + startIndex + 1);
+        }
+        return keys;
+    };
+    const takeKeyAfterToken = (args, startIndex, token) => {
+        for (let i = startIndex; i < args.length - 1; i += 1) {
+            if (String(args[i]).toLowerCase() === token.toLowerCase()) {
+                return i + 1;
+            }
+        }
+        return null;
+    };
+    switch (commandName) {
+        case "zunionstore":
+        case "zinterstore":
+        case "zdiffstore":
+            keys.push(0, ...takeDynamicKeys(args, 1));
+            break;
+        case "eval":
+        case "evalsha":
+        case "eval_ro":
+        case "evalsha_ro":
+        case "fcall":
+        case "fcall_ro":
+        case "blmpop":
+        case "bzmpop":
+            keys.push(...takeDynamicKeys(args, 1));
+            break;
+        case "sintercard":
+        case "lmpop":
+        case "zunion":
+        case "zinter":
+        case "zmpop":
+        case "zintercard":
+        case "zdiff": {
+            keys.push(...takeDynamicKeys(args, 0));
+            break;
+        }
+        case "georadius": {
+            keys.push(0);
+            const storeKey = takeKeyAfterToken(args, 5, "STORE");
+            if (storeKey)
+                keys.push(storeKey);
+            const distKey = takeKeyAfterToken(args, 5, "STOREDIST");
+            if (distKey)
+                keys.push(distKey);
+            break;
+        }
+        case "georadiusbymember": {
+            keys.push(0);
+            const storeKey = takeKeyAfterToken(args, 4, "STORE");
+            if (storeKey)
+                keys.push(storeKey);
+            const distKey = takeKeyAfterToken(args, 4, "STOREDIST");
+            if (distKey)
+                keys.push(distKey);
+            break;
+        }
+        case "sort":
+        case "sort_ro":
+            keys.push(0);
+            for (let i = 1; i < args.length - 1; i++) {
+                let arg = args[i];
+                if (typeof arg !== "string") {
+                    continue;
+                }
+                const directive = arg.toUpperCase();
+                if (directive === "GET") {
+                    i += 1;
+                    arg = args[i];
+                    if (arg !== "#") {
+                        if (parseExternalKey) {
+                            keys.push([i, getExternalKeyNameLength(arg)]);
+                        }
+                        else {
+                            keys.push(i);
+                        }
+                    }
+                }
+                else if (directive === "BY") {
+                    i += 1;
+                    if (parseExternalKey) {
+                        keys.push([i, getExternalKeyNameLength(args[i])]);
+                    }
+                    else {
+                        keys.push(i);
+                    }
+                }
+                else if (directive === "STORE") {
+                    i += 1;
+                    keys.push(i);
+                }
+            }
+            break;
+        case "migrate":
+            if (args[2] === "") {
+                for (let i = 5; i < args.length - 1; i++) {
+                    const arg = args[i];
+                    if (typeof arg === "string" && arg.toUpperCase() === "KEYS") {
+                        for (let j = i + 1; j < args.length; j++) {
+                            keys.push(j);
+                        }
+                        break;
+                    }
+                }
+            }
+            else {
+                keys.push(2);
+            }
+            break;
+        case "xreadgroup":
+        case "xread":
+            // Keys are 1st half of the args after STREAMS argument.
+            for (let i = commandName === "xread" ? 0 : 3; i < args.length - 1; i++) {
+                if (String(args[i]).toUpperCase() === "STREAMS") {
+                    for (let j = i + 1; j <= i + (args.length - 1 - i) / 2; j++) {
+                        keys.push(j);
+                    }
+                    break;
+                }
+            }
+            break;
+        default:
+            // Step has to be at least one in this case, otherwise the command does
+            // not contain a key.
+            if (command.step > 0) {
+                const keyStart = command.keyStart - 1;
+                const keyStop = command.keyStop > 0
+                    ? command.keyStop
+                    : args.length + command.keyStop + 1;
+                for (let i = keyStart; i < keyStop; i += command.step) {
+                    keys.push(i);
+                }
+            }
+            break;
+    }
+    return keys;
+}
+exports.getKeyIndexes = getKeyIndexes;
+function getExternalKeyNameLength(key) {
+    if (typeof key !== "string") {
+        key = String(key);
+    }
+    const hashPos = key.indexOf("->");
+    return hashPos === -1 ? key.length : hashPos;
+}

package/.output/server/node_modules/@ioredis/commands/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@ioredis/commands",
+  "version": "1.2.0",
+  "description": "Redis commands",
+  "main": "built/index.js",
+  "files": [
+    "built/",
+    "commands.json"
+  ],
+  "scripts": {
+    "pretest": "npm run lint",
+    "test": "mocha",
+    "build": "rm -rf built && tsc",
+    "gen": "node tools/build",
+    "lint": "standard --fix --verbose | snazzy",
+    "release": "release-it"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ioredis/commands.git"
+  },
+  "keywords": [
+    "redis",
+    "commands",
+    "prefix"
+  ],
+  "author": "Zihua Li <i@zihua.li> (http://zihua.li)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ioredis/commands/issues"
+  },
+  "homepage": "https://github.com/ioredis/commands",
+  "devDependencies": {
+    "@release-it/conventional-changelog": "^4.2.0",
+    "@semantic-release/changelog": "^6.0.1",
+    "@semantic-release/commit-analyzer": "^9.0.2",
+    "@semantic-release/git": "^10.0.1",
+    "chai": "^4.3.6",
+    "ioredis": "^5.0.6",
+    "mocha": "^9.2.1",
+    "release-it": "^14.12.5",
+    "safe-stable-stringify": "^2.3.1",
+    "semantic-release": "^19.0.2",
+    "snazzy": "^9.0.0",
+    "standard": "^16.0.4",
+    "typescript": "^4.6.2"
+  }
+}

package/.output/server/node_modules/@opentelemetry/api/build/src/api/context.js

@@ -0,0 +1,81 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextAPI = void 0;
+const NoopContextManager_1 = require("../context/NoopContextManager");
+const global_utils_1 = require("../internal/global-utils");
+const diag_1 = require("./diag");
+const API_NAME = 'context';
+const NOOP_CONTEXT_MANAGER = new NoopContextManager_1.NoopContextManager();
+/**
+ * Singleton object which represents the entry point to the OpenTelemetry Context API
+ */
+class ContextAPI {
+    /** Empty private constructor prevents end users from constructing a new instance of the API */
+    constructor() { }
+    /** Get the singleton instance of the Context API */
+    static getInstance() {
+        if (!this._instance) {
+            this._instance = new ContextAPI();
+        }
+        return this._instance;
+    }
+    /**
+     * Set the current context manager.
+     *
+     * @returns true if the context manager was successfully registered, else false
+     */
+    setGlobalContextManager(contextManager) {
+        return (0, global_utils_1.registerGlobal)(API_NAME, contextManager, diag_1.DiagAPI.instance());
+    }
+    /**
+     * Get the currently active context
+     */
+    active() {
+        return this._getContextManager().active();
+    }
+    /**
+     * Execute a function with an active context
+     *
+     * @param context context to be active during function execution
+     * @param fn function to execute in a context
+     * @param thisArg optional receiver to be used for calling fn
+     * @param args optional arguments forwarded to fn
+     */
+    with(context, fn, thisArg, ...args) {
+        return this._getContextManager().with(context, fn, thisArg, ...args);
+    }
+    /**
+     * Bind a context to a target function or event emitter
+     *
+     * @param context context to bind to the event emitter or function. Defaults to the currently active context
+     * @param target function or event emitter to bind
+     */
+    bind(context, target) {
+        return this._getContextManager().bind(context, target);
+    }
+    _getContextManager() {
+        return (0, global_utils_1.getGlobal)(API_NAME) || NOOP_CONTEXT_MANAGER;
+    }
+    /** Disable and remove the global context manager */
+    disable() {
+        this._getContextManager().disable();
+        (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
+    }
+}
+exports.ContextAPI = ContextAPI;
+//# sourceMappingURL=context.js.map

package/.output/server/node_modules/@opentelemetry/api/build/src/api/diag.js

@@ -0,0 +1,93 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiagAPI = void 0;
+const ComponentLogger_1 = require("../diag/ComponentLogger");
+const logLevelLogger_1 = require("../diag/internal/logLevelLogger");
+const types_1 = require("../diag/types");
+const global_utils_1 = require("../internal/global-utils");
+const API_NAME = 'diag';
+/**
+ * Singleton object which represents the entry point to the OpenTelemetry internal
+ * diagnostic API
+ */
+class DiagAPI {
+    /**
+     * Private internal constructor
+     * @private
+     */
+    constructor() {
+        function _logProxy(funcName) {
+            return function (...args) {
+                const logger = (0, global_utils_1.getGlobal)('diag');
+                // shortcut if logger not set
+                if (!logger)
+                    return;
+                return logger[funcName](...args);
+            };
+        }
+        // Using self local variable for minification purposes as 'this' cannot be minified
+        const self = this;
+        // DiagAPI specific functions
+        const setLogger = (logger, optionsOrLogLevel = { logLevel: types_1.DiagLogLevel.INFO }) => {
+            var _a, _b, _c;
+            if (logger === self) {
+                // There isn't much we can do here.
+                // Logging to the console might break the user application.
+                // Try to log to self. If a logger was previously registered it will receive the log.
+                const err = new Error('Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation');
+                self.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
+                return false;
+            }
+            if (typeof optionsOrLogLevel === 'number') {
+                optionsOrLogLevel = {
+                    logLevel: optionsOrLogLevel,
+                };
+            }
+            const oldLogger = (0, global_utils_1.getGlobal)('diag');
+            const newLogger = (0, logLevelLogger_1.createLogLevelDiagLogger)((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : types_1.DiagLogLevel.INFO, logger);
+            // There already is an logger registered. We'll let it know before overwriting it.
+            if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
+                const stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : '<failed to generate stacktrace>';
+                oldLogger.warn(`Current logger will be overwritten from ${stack}`);
+                newLogger.warn(`Current logger will overwrite one already registered from ${stack}`);
+            }
+            return (0, global_utils_1.registerGlobal)('diag', newLogger, self, true);
+        };
+        self.setLogger = setLogger;
+        self.disable = () => {
+            (0, global_utils_1.unregisterGlobal)(API_NAME, self);
+        };
+        self.createComponentLogger = (options) => {
+            return new ComponentLogger_1.DiagComponentLogger(options);
+        };
+        self.verbose = _logProxy('verbose');
+        self.debug = _logProxy('debug');
+        self.info = _logProxy('info');
+        self.warn = _logProxy('warn');
+        self.error = _logProxy('error');
+    }
+    /** Get the singleton instance of the DiagAPI API */
+    static instance() {
+        if (!this._instance) {
+            this._instance = new DiagAPI();
+        }
+        return this._instance;
+    }
+}
+exports.DiagAPI = DiagAPI;
+//# sourceMappingURL=diag.js.map

package/.output/server/node_modules/@opentelemetry/api/build/src/api/metrics.js

@@ -0,0 +1,61 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsAPI = void 0;
+const NoopMeterProvider_1 = require("../metrics/NoopMeterProvider");
+const global_utils_1 = require("../internal/global-utils");
+const diag_1 = require("./diag");
+const API_NAME = 'metrics';
+/**
+ * Singleton object which represents the entry point to the OpenTelemetry Metrics API
+ */
+class MetricsAPI {
+    /** Empty private constructor prevents end users from constructing a new instance of the API */
+    constructor() { }
+    /** Get the singleton instance of the Metrics API */
+    static getInstance() {
+        if (!this._instance) {
+            this._instance = new MetricsAPI();
+        }
+        return this._instance;
+    }
+    /**
+     * Set the current global meter provider.
+     * Returns true if the meter provider was successfully registered, else false.
+     */
+    setGlobalMeterProvider(provider) {
+        return (0, global_utils_1.registerGlobal)(API_NAME, provider, diag_1.DiagAPI.instance());
+    }
+    /**
+     * Returns the global meter provider.
+     */
+    getMeterProvider() {
+        return (0, global_utils_1.getGlobal)(API_NAME) || NoopMeterProvider_1.NOOP_METER_PROVIDER;
+    }
+    /**
+     * Returns a meter from the global meter provider.
+     */
+    getMeter(name, version, options) {
+        return this.getMeterProvider().getMeter(name, version, options);
+    }
+    /** Remove the global meter provider */
+    disable() {
+        (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
+    }
+}
+exports.MetricsAPI = MetricsAPI;
+//# sourceMappingURL=metrics.js.map

package/.output/server/node_modules/@opentelemetry/api/build/src/api/propagation.js

@@ -0,0 +1,89 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropagationAPI = void 0;
+const global_utils_1 = require("../internal/global-utils");
+const NoopTextMapPropagator_1 = require("../propagation/NoopTextMapPropagator");
+const TextMapPropagator_1 = require("../propagation/TextMapPropagator");
+const context_helpers_1 = require("../baggage/context-helpers");
+const utils_1 = require("../baggage/utils");
+const diag_1 = require("./diag");
+const API_NAME = 'propagation';
+const NOOP_TEXT_MAP_PROPAGATOR = new NoopTextMapPropagator_1.NoopTextMapPropagator();
+/**
+ * Singleton object which represents the entry point to the OpenTelemetry Propagation API
+ */
+class PropagationAPI {
+    /** Empty private constructor prevents end users from constructing a new instance of the API */
+    constructor() {
+        this.createBaggage = utils_1.createBaggage;
+        this.getBaggage = context_helpers_1.getBaggage;
+        this.getActiveBaggage = context_helpers_1.getActiveBaggage;
+        this.setBaggage = context_helpers_1.setBaggage;
+        this.deleteBaggage = context_helpers_1.deleteBaggage;
+    }
+    /** Get the singleton instance of the Propagator API */
+    static getInstance() {
+        if (!this._instance) {
+            this._instance = new PropagationAPI();
+        }
+        return this._instance;
+    }
+    /**
+     * Set the current propagator.
+     *
+     * @returns true if the propagator was successfully registered, else false
+     */
+    setGlobalPropagator(propagator) {
+        return (0, global_utils_1.registerGlobal)(API_NAME, propagator, diag_1.DiagAPI.instance());
+    }
+    /**
+     * Inject context into a carrier to be propagated inter-process
+     *
+     * @param context Context carrying tracing data to inject
+     * @param carrier carrier to inject context into
+     * @param setter Function used to set values on the carrier
+     */
+    inject(context, carrier, setter = TextMapPropagator_1.defaultTextMapSetter) {
+        return this._getGlobalPropagator().inject(context, carrier, setter);
+    }
+    /**
+     * Extract context from a carrier
+     *
+     * @param context Context which the newly created context will inherit from
+     * @param carrier Carrier to extract context from
+     * @param getter Function used to extract keys from a carrier
+     */
+    extract(context, carrier, getter = TextMapPropagator_1.defaultTextMapGetter) {
+        return this._getGlobalPropagator().extract(context, carrier, getter);
+    }
+    /**
+     * Return a list of all fields which may be used by the propagator.
+     */
+    fields() {
+        return this._getGlobalPropagator().fields();
+    }
+    /** Remove the global propagator */
+    disable() {
+        (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
+    }
+    _getGlobalPropagator() {
+        return (0, global_utils_1.getGlobal)(API_NAME) || NOOP_TEXT_MAP_PROPAGATOR;
+    }
+}
+exports.PropagationAPI = PropagationAPI;
+//# sourceMappingURL=propagation.js.map

package/.output/server/node_modules/@opentelemetry/api/build/src/api/trace.js

@@ -0,0 +1,79 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraceAPI = void 0;
+const global_utils_1 = require("../internal/global-utils");
+const ProxyTracerProvider_1 = require("../trace/ProxyTracerProvider");
+const spancontext_utils_1 = require("../trace/spancontext-utils");
+const context_utils_1 = require("../trace/context-utils");
+const diag_1 = require("./diag");
+const API_NAME = 'trace';
+/**
+ * Singleton object which represents the entry point to the OpenTelemetry Tracing API
+ */
+class TraceAPI {
+    /** Empty private constructor prevents end users from constructing a new instance of the API */
+    constructor() {
+        this._proxyTracerProvider = new ProxyTracerProvider_1.ProxyTracerProvider();
+        this.wrapSpanContext = spancontext_utils_1.wrapSpanContext;
+        this.isSpanContextValid = spancontext_utils_1.isSpanContextValid;
+        this.deleteSpan = context_utils_1.deleteSpan;
+        this.getSpan = context_utils_1.getSpan;
+        this.getActiveSpan = context_utils_1.getActiveSpan;
+        this.getSpanContext = context_utils_1.getSpanContext;
+        this.setSpan = context_utils_1.setSpan;
+        this.setSpanContext = context_utils_1.setSpanContext;
+    }
+    /** Get the singleton instance of the Trace API */
+    static getInstance() {
+        if (!this._instance) {
+            this._instance = new TraceAPI();
+        }
+        return this._instance;
+    }
+    /**
+     * Set the current global tracer.
+     *
+     * @returns true if the tracer provider was successfully registered, else false
+     */
+    setGlobalTracerProvider(provider) {
+        const success = (0, global_utils_1.registerGlobal)(API_NAME, this._proxyTracerProvider, diag_1.DiagAPI.instance());
+        if (success) {
+            this._proxyTracerProvider.setDelegate(provider);
+        }
+        return success;
+    }
+    /**
+     * Returns the global tracer provider.
+     */
+    getTracerProvider() {
+        return (0, global_utils_1.getGlobal)(API_NAME) || this._proxyTracerProvider;
+    }
+    /**
+     * Returns a tracer from the global tracer provider.
+     */
+    getTracer(name, version) {
+        return this.getTracerProvider().getTracer(name, version);
+    }
+    /** Remove the global tracer provider */
+    disable() {
+        (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
+        this._proxyTracerProvider = new ProxyTracerProvider_1.ProxyTracerProvider();
+    }
+}
+exports.TraceAPI = TraceAPI;
+//# sourceMappingURL=trace.js.map