@psnext/slingcli 2.4.20260515-1 → 2.4.20260520-1

package/node_modules/@types/node/repl.d.ts

@@ -86,6 +86,21 @@ declare module "node:repl" {
          * @default false
          */
         breakEvalOnSigint?: boolean | undefined;
+        /**
+         * This function customizes error handling in the REPL.
+         * It receives the thrown exception as its first argument and must return one
+         * of the following values synchronously:
+         * * `'print'` to print the error to the output stream (default behavior).
+         * * `'ignore'` to skip all remaining error handling.
+         * * `'unhandled'` to treat the exception as fully unhandled. In this case,
+         *   the error will be passed to process-wide exception handlers, such as
+         *   the `'uncaughtException'` event.
+         *   The `'unhandled'` value may or may not be desirable in situations
+         *   where the `REPLServer` instance has been closed, depending on the particular
+         *   use case.
+         * @since v25.9.0
+         */
+        handleError?: ((err: unknown) => "print" | "ignore" | "unhandled") | undefined;
     }
     type REPLEval = (
         this: REPLServer,

package/node_modules/@types/node/stream/iter.d.ts

@@ -0,0 +1,301 @@
+declare module "node:stream/iter" {
+    // Symbols and custom typedefs
+    const broadcastProtocol: unique symbol;
+    const drainableProtocol: unique symbol;
+    const shareProtocol: unique symbol;
+    const shareSyncProtocol: unique symbol;
+    const toAsyncStreamable: unique symbol;
+    const toStreamable: unique symbol;
+    type Source =
+        | string
+        | ArrayBufferLike
+        | ArrayBufferView
+        | Iterable<SyncSource>
+        | AsyncIterable<Source>
+        | Streamable
+        | AsyncStreamable;
+    type SyncSource = string | ArrayBufferLike | ArrayBufferView | Iterable<SyncSource> | Streamable;
+    type Transform = StatelessTransformFn | StatefulTransform;
+    type SyncTransform = SyncStatelessTransformFn | SyncStatefulTransform;
+    type TransformResult =
+        | string
+        | ArrayBufferLike
+        | ArrayBufferView
+        | Iterable<SyncTransformResult>
+        | AsyncIterable<TransformResult>;
+    type SyncTransformResult = string | ArrayBufferLike | ArrayBufferView | Iterable<SyncTransformResult>;
+    interface AsyncStreamable {
+        [toAsyncStreamable](): Source;
+    }
+    interface Broadcastable {
+        [broadcastProtocol](options: BroadcastOptions): Broadcast;
+    }
+    interface Drainable {
+        [drainableProtocol](): Promise<boolean> | null;
+    }
+    interface Shareable {
+        [shareProtocol](options: ShareOptions): Share;
+    }
+    interface Streamable {
+        [toStreamable](): SyncSource;
+    }
+    interface SyncShareable {
+        [shareSyncProtocol](options: ShareSyncOptions): SyncShare;
+    }
+    // IDL dictionaries, enums, typedefs
+    type BackpressurePolicy = "strict" | "block" | "drop-oldest" | "drop-newest";
+    type ByteReadableStream = AsyncIterable<Uint8Array[]>;
+    type SyncByteReadableStream = Iterable<Uint8Array[]>;
+    interface WriteOptions {
+        signal?: AbortSignal;
+    }
+    interface PushStreamOptions {
+        highWaterMark?: number;
+        backpressure?: BackpressurePolicy;
+        signal?: AbortSignal;
+    }
+    interface PullOptions {
+        signal?: AbortSignal;
+    }
+    interface PipeToOptions {
+        signal?: AbortSignal;
+        preventClose?: boolean;
+        preventFail?: boolean;
+    }
+    interface PipeToSyncOptions {
+        preventClose?: boolean;
+        preventFail?: boolean;
+    }
+    interface ConsumeOptions {
+        signal?: AbortSignal;
+        limit?: number;
+    }
+    interface ConsumeSyncOptions {
+        limit?: number;
+    }
+    interface TextConsumeOptions extends ConsumeOptions {
+        encoding?: string;
+    }
+    interface TextConsumeSyncOptions extends ConsumeSyncOptions {
+        encoding?: string;
+    }
+    interface MergeOptions {
+        signal?: AbortSignal;
+    }
+    interface BroadcastOptions {
+        highWaterMark?: number;
+        backpressure?: BackpressurePolicy;
+        signal?: AbortSignal;
+    }
+    interface ShareOptions {
+        highWaterMark?: number;
+        backpressure?: BackpressurePolicy;
+        signal?: AbortSignal;
+    }
+    interface ShareSyncOptions {
+        highWaterMark?: number;
+        backpressure?: BackpressurePolicy;
+    }
+    interface DuplexDirectionOptions {
+        highWaterMark?: number;
+        backpressure?: BackpressurePolicy;
+    }
+    interface DuplexOptions {
+        highWaterMark?: number;
+        backpressure?: BackpressurePolicy;
+        a?: DuplexDirectionOptions;
+        b?: DuplexDirectionOptions;
+        signal?: AbortSignal;
+    }
+    interface TransformCallbackOptions {
+        signal: AbortSignal;
+    }
+    interface StatelessTransformFn {
+        (
+            chunks: Uint8Array[] | null,
+            options: TransformCallbackOptions,
+        ): Promise<TransformResult | null> | TransformResult | null;
+    }
+    interface SyncStatelessTransformFn {
+        (chunks: Uint8Array[] | null): SyncTransformResult | null;
+    }
+    interface StatefulTransform {
+        transform(
+            source: AsyncIterable<Uint8Array[] | null>,
+            options: TransformCallbackOptions,
+        ): AsyncIterable<TransformResult>;
+    }
+    interface SyncStatefulTransform {
+        transform(source: Iterable<Uint8Array[] | null>): Iterable<SyncTransformResult>;
+    }
+    // IDL interfaces
+    interface PushWriter extends Writer, Drainable {}
+    interface PushStreamResult {
+        writer: PushWriter;
+        readable: ByteReadableStream;
+    }
+    interface BroadcastWriter extends Writer, Drainable {}
+    interface BroadcastResult {
+        writer: BroadcastWriter;
+        broadcast: Broadcast;
+    }
+    interface Writer extends Disposable, AsyncDisposable {
+        readonly desiredSize: number | null;
+        write(chunk: Uint8Array | string, options?: WriteOptions): Promise<void>;
+        writev(chunks: Array<Uint8Array | string>, options?: WriteOptions): Promise<void>;
+        writeSync(chunk: Uint8Array | string): boolean;
+        writevSync(chunks: Array<Uint8Array | string>): boolean;
+        end(options?: WriteOptions): Promise<number>;
+        endSync(): number;
+        fail(reason?: any): void;
+    }
+    interface PartialWriter extends Partial<Writer> {
+        write(chunk: Uint8Array | string, options?: WriteOptions): Promise<void>;
+    }
+    interface SyncWriter extends Disposable {
+        readonly desiredSize: number | null;
+        writeSync(chunk: Uint8Array | string): number;
+        writevSync(chunks: Array<Uint8Array | string>): number;
+        endSync(): number;
+        fail(reason?: any): void;
+    }
+    interface PartialSyncWriter extends Partial<SyncWriter> {
+        writeSync(chunk: Uint8Array | string): number;
+    }
+    interface Broadcast extends Disposable {
+        readonly consumerCount: number;
+        readonly bufferSize: number;
+        push(...args: any[]): ByteReadableStream;
+        cancel(reason?: any): void;
+    }
+    interface Share extends Disposable {
+        readonly consumerCount: number;
+        readonly bufferSize: number;
+        pull(...args: any[]): ByteReadableStream;
+        cancel(reason?: any): void;
+    }
+    interface SyncShare extends Disposable {
+        readonly consumerCount: number;
+        readonly bufferSize: number;
+        pull(...args: any): SyncByteReadableStream;
+        cancel(reason?: any): void;
+    }
+    interface DuplexChannel extends AsyncDisposable {
+        readonly writer: Writer;
+        readonly readable: ByteReadableStream;
+        close(): Promise<void>;
+    }
+    // Push stream creation
+    function push(...transforms: Transform[]): PushStreamResult;
+    function push(...args: [...transforms: Transform[], options: PushStreamOptions]): PushStreamResult;
+    // Stream factories
+    function from(input: Source): ByteReadableStream;
+    function fromSync(input: SyncSource): SyncByteReadableStream;
+    // Pull pipelines
+    function pull(source: Source, ...transforms: Transform[]): ByteReadableStream;
+    function pull(
+        source: Source,
+        ...args: [...transforms: Transform[], options: PullOptions]
+    ): ByteReadableStream;
+    function pullSync(source: SyncSource, ...transforms: SyncTransform[]): SyncByteReadableStream;
+    // Pipe operations
+    function pipeTo(source: Source, writer: PartialWriter, options?: PipeToOptions): Promise<number>;
+    function pipeTo(source: Source, ...args: [...transforms: Transform[], writer: PartialWriter]): Promise<number>;
+    function pipeTo(
+        source: Source,
+        ...args: [...transforms: Transform[], writer: PartialWriter, options: PipeToOptions]
+    ): Promise<number>;
+    function pipeToSync(source: SyncSource, writer: PartialSyncWriter, options?: PipeToSyncOptions): number;
+    function pipeToSync(
+        source: SyncSource,
+        ...args: [...transforms: SyncTransform[], writer: PartialSyncWriter]
+    ): number;
+    function pipeToSync(
+        source: SyncSource,
+        ...args: [...transforms: SyncTransform[], writer: PartialSyncWriter, options: PipeToSyncOptions]
+    ): number;
+    // Consumers
+    function bytes(source: Source, options?: ConsumeOptions): Promise<Uint8Array>;
+    function bytesSync(source: SyncSource, options?: ConsumeSyncOptions): Uint8Array;
+    function text(source: Source, options?: TextConsumeOptions): Promise<string>;
+    function textSync(source: SyncSource, options?: TextConsumeSyncOptions): string;
+    function arrayBuffer(source: Source, options?: ConsumeOptions): Promise<ArrayBuffer>;
+    function arrayBufferSync(source: SyncSource, options?: ConsumeSyncOptions): ArrayBuffer;
+    function array(source: Source, options?: ConsumeOptions): Promise<Uint8Array[]>;
+    function arraySync(source: SyncSource, options?: ConsumeSyncOptions): Uint8Array[];
+    // Utilities
+    function tap(callback: StatelessTransformFn): StatelessTransformFn;
+    function tapSync(callback: SyncStatelessTransformFn): SyncStatelessTransformFn;
+    function merge(...sources: Source[]): ByteReadableStream;
+    function merge(...args: [...sources: Source[], options: MergeOptions]): ByteReadableStream;
+    function ondrain(drainable: any): Promise<boolean> | null;
+    // Multi-consumer
+    function broadcast(options?: BroadcastOptions): BroadcastResult;
+    function share(source: Source, options?: ShareOptions): Share;
+    function shareSync(source: SyncSource, options?: ShareSyncOptions): SyncShare;
+    // Duplex
+    function duplex(options?: DuplexOptions): [DuplexChannel, DuplexChannel];
+    // Node.js-specific extensions
+    namespace Broadcast {
+        /**
+         * Create a `Broadcast` from an existing source. The source is consumed
+         * automatically and pushed to all subscribers.
+         * @since v25.9.0
+         * @param options Same as `broadcast()`.
+         */
+        function from(
+            input: ByteReadableStream | SyncByteReadableStream | Broadcastable,
+            options?: BroadcastOptions,
+        ): BroadcastResult;
+    }
+    namespace Share {
+        /**
+         * Create a `Share` from an existing source.
+         * @since v25.9.0
+         * @param options Same as `share()`.
+         */
+        function from(input: ByteReadableStream | SyncByteReadableStream | Shareable, options?: ShareOptions): Share;
+    }
+    namespace SyncShare {
+        /**
+         * @since v25.9.0
+         */
+        function from(input: SyncByteReadableStream | SyncShareable, options?: ShareSyncOptions): SyncShare;
+    }
+    namespace Stream {
+        export {
+            array,
+            arrayBuffer,
+            arrayBufferSync,
+            arraySync,
+            broadcast,
+            broadcastProtocol,
+            bytes,
+            bytesSync,
+            drainableProtocol,
+            duplex,
+            from,
+            fromSync,
+            merge,
+            ondrain,
+            pipeTo,
+            pipeToSync,
+            pull,
+            pullSync,
+            push,
+            share,
+            shareProtocol,
+            shareSync,
+            shareSyncProtocol,
+            tap,
+            tapSync,
+            text,
+            textSync,
+            toAsyncStreamable,
+            toStreamable,
+        };
+    }
+}
+declare module "stream/iter" {
+    export * from "node:stream/iter";
+}

package/node_modules/@types/node/test.d.ts

@@ -1479,19 +1479,40 @@ declare module "node:test" {
              */
             cache?: boolean | undefined;
             /**
-             * The value to use as the mocked module's default export.
-             *
-             * If this value is not provided, ESM mocks do not include a default export.
-             * If the mock is a CommonJS or builtin module, this setting is used as the value of `module.exports`.
-             * If this value is not provided, CJS and builtin mocks use an empty object as the value of `module.exports`.
+             * Optional mocked exports. The `default` property, if
+             * provided, is used as the mocked module's default export. All other own
+             * enumerable properties are used as named exports.
+             * **This option cannot be used with `defaultExport` or `namedExports`.**
+             * * If the mock is a CommonJS or builtin module, `exports.default` is used as
+             *   the value of `module.exports`.
+             * * If `exports.default` is not provided for a CommonJS or builtin mock,
+             *   `module.exports` defaults to an empty object.
+             * * If named exports are provided with a non-object default export, the mock
+             *   throws an exception when used as a CommonJS or builtin module.
+             */
+            exports?: object | undefined;
+            /**
+             * An optional value used as the mocked module's default
+             * export. If this value is not provided, ESM mocks do not include a default
+             * export. If the mock is a CommonJS or builtin module, this setting is used as
+             * the value of `module.exports`. If this value is not provided, CJS and builtin
+             * mocks use an empty object as the value of `module.exports`.
+             * **This option cannot be used with `options.exports`.**
+             * This option is deprecated and will be removed in a later version.
+             * Prefer `options.exports.default`.
+             * @deprecated
              */
             defaultExport?: any;
             /**
-             * An object whose keys and values are used to create the named exports of the mock module.
-             *
-             * If the mock is a CommonJS or builtin module, these values are copied onto `module.exports`.
-             * Therefore, if a mock is created with both named exports and a non-object default export,
-             * the mock will throw an exception when used as a CJS or builtin module.
+             * An optional object whose keys and values are used to
+             * create the named exports of the mock module. If the mock is a CommonJS or
+             * builtin module, these values are copied onto `module.exports`. Therefore, if a
+             * mock is created with both named exports and a non-object default export, the
+             * mock will throw an exception when used as a CJS or builtin module.
+             * **This option cannot be used with `options.exports`.**
+             * This option is deprecated and will be removed in a later version.
+             * Prefer `options.exports`.
+             * @deprecated
              */
             namedExports?: object | undefined;
         }
@@ -1666,14 +1687,19 @@ declare module "node:test" {
              * [`--experimental-test-module-mocks`](https://nodejs.org/docs/latest-v25.x/api/cli.html#--experimental-test-module-mocks)
              * command-line flag.
              *
+             * **Note**: [module customization hooks](https://nodejs.org/docs/latest-v25.x/api/module.html#customization-hooks) registered via the **synchronous** API effect resolution of
+             * the `specifier` provided to `mock.module`. Customization hooks registered via the **asynchronous**
+             * API are currently ignored (because the test runner's loader is synchronous, and node does not
+             * support multi-chain / cross-chain loading).
+             *
              * The following example demonstrates how a mock is created for a module.
              *
              * ```js
              * test('mocks a builtin module in both module systems', async (t) => {
-             *   // Create a mock of 'node:readline' with a named export named 'fn', which
+             *   // Create a mock of 'node:readline' with a named export named 'foo', which
              *   // does not exist in the original 'node:readline' module.
              *   const mock = t.mock.module('node:readline', {
-             *     namedExports: { fn() { return 42; } },
+             *     exports: { foo: () => 42 },
              *   });
              *
              *   let esmImpl = await import('node:readline');

package/node_modules/@types/node/ts5.6/index.d.ts

@@ -97,6 +97,7 @@
 /// <reference path="../sqlite.d.ts" />
 /// <reference path="../stream.d.ts" />
 /// <reference path="../stream/consumers.d.ts" />
+/// <reference path="../stream/iter.d.ts" />
 /// <reference path="../stream/promises.d.ts" />
 /// <reference path="../stream/web.d.ts" />
 /// <reference path="../string_decoder.d.ts" />
@@ -115,3 +116,4 @@
 /// <reference path="../wasi.d.ts" />
 /// <reference path="../worker_threads.d.ts" />
 /// <reference path="../zlib.d.ts" />
+/// <reference path="../zlib/iter.d.ts" />

package/node_modules/@types/node/ts5.7/index.d.ts

@@ -97,6 +97,7 @@
 /// <reference path="../sqlite.d.ts" />
 /// <reference path="../stream.d.ts" />
 /// <reference path="../stream/consumers.d.ts" />
+/// <reference path="../stream/iter.d.ts" />
 /// <reference path="../stream/promises.d.ts" />
 /// <reference path="../stream/web.d.ts" />
 /// <reference path="../string_decoder.d.ts" />
@@ -115,3 +116,4 @@
 /// <reference path="../wasi.d.ts" />
 /// <reference path="../worker_threads.d.ts" />
 /// <reference path="../zlib.d.ts" />
+/// <reference path="../zlib/iter.d.ts" />

package/node_modules/@types/node/vm.d.ts

@@ -232,11 +232,12 @@ declare module "node:vm" {
          *
          * 1. Creates a new context.
          * 2. If `contextObject` is an object, contextifies it with the new context.
-         *    If  `contextObject` is undefined, creates a new object and contextifies it.
+         *    If `contextObject` is undefined, creates a new object and contextifies it.
          *    If `contextObject` is `vm.constants.DONT_CONTEXTIFY`, don't contextify anything.
-         * 3. Runs the compiled code contained by the `vm.Script` object within the created context. The code
-         *    does not have access to the scope in which this method is called.
-         * 4. Returns the result.
+         * 3. Compiles the code as a `vm.Script`
+         * 4. Runs the compiled code within the created context. The code does not have access to the scope in
+         *    which this method is called.
+         * 5. Returns the result.
          *
          * The following example compiles code that sets a global variable, then executes
          * the code multiple times in different contexts. The globals are set on and

package/node_modules/@types/node/zlib/iter.d.ts

@@ -0,0 +1,131 @@
+declare module "node:zlib/iter" {
+    import { StatefulTransform, SyncStatefulTransform } from "node:stream/iter";
+    interface BrotliOptions {
+        chunkSize?: number | undefined;
+        params?: { [key: number]: number | boolean } | undefined;
+        dictionary?: NodeJS.ArrayBufferView | undefined;
+    }
+    interface ZlibOptions {
+        chunkSize?: number | undefined;
+        windowBits?: number | undefined;
+        dictionary?: NodeJS.ArrayBufferView | undefined;
+    }
+    interface ZlibCompressionOptions extends ZlibOptions {
+        level?: number | undefined;
+        memLevel?: number | undefined;
+        strategy?: number | undefined;
+    }
+    interface ZstdOptions {
+        chunkSize?: number | undefined;
+        params?: { [key: number]: number | boolean } | undefined;
+        dictionary?: NodeJS.ArrayBufferView | undefined;
+    }
+    interface ZstdCompressionOptions extends ZstdOptions {
+        pledgedSrcSize?: number | undefined;
+    }
+    /**
+     * Create a Brotli compression transform. Output is compatible with
+     * `zlib.brotliDecompress()` and `decompressBrotli()`/`decompressBrotliSync()`.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function compressBrotli(options?: BrotliOptions): StatefulTransform;
+    /**
+     * Create a Brotli compression transform. Output is compatible with
+     * `zlib.brotliDecompress()` and `decompressBrotli()`/`decompressBrotliSync()`.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function compressBrotliSync(options?: BrotliOptions): SyncStatefulTransform;
+    /**
+     * Create a deflate compression transform. Output is compatible with
+     * `zlib.inflate()` and `decompressDeflate()`/`decompressDeflateSync()`.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function compressDeflate(options?: ZlibCompressionOptions): StatefulTransform;
+    /**
+     * Create a deflate compression transform. Output is compatible with
+     * `zlib.inflate()` and `decompressDeflate()`/`decompressDeflateSync()`.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function compressDeflateSync(options?: ZlibCompressionOptions): SyncStatefulTransform;
+    /**
+     * Create a gzip compression transform. Output is compatible with `zlib.gunzip()`
+     * and `decompressGzip()`/`decompressGzipSync()`.
+     * @returns A stateful transform.
+     */
+    function compressGzip(options?: ZlibCompressionOptions): StatefulTransform;
+    /**
+     * Create a gzip compression transform. Output is compatible with `zlib.gunzip()`
+     * and `decompressGzip()`/`decompressGzipSync()`.
+     * @returns A stateful transform.
+     */
+    function compressGzipSync(options?: ZlibCompressionOptions): SyncStatefulTransform;
+    /**
+     * Create a Zstandard compression transform. Output is compatible with
+     * `zlib.zstdDecompress()` and `decompressZstd()`/`decompressZstdSync()`.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function compressZstd(options?: ZstdCompressionOptions): StatefulTransform;
+    /**
+     * Create a Zstandard compression transform. Output is compatible with
+     * `zlib.zstdDecompress()` and `decompressZstd()`/`decompressZstdSync()`.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function compressZstdSync(options?: ZstdCompressionOptions): SyncStatefulTransform;
+    /**
+     * Create a Brotli decompression transform.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function decompressBrotli(options?: BrotliOptions): StatefulTransform;
+    /**
+     * Create a Brotli decompression transform.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function decompressBrotliSync(options?: BrotliOptions): SyncStatefulTransform;
+    /**
+     * Create a deflate decompression transform.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function decompressDeflate(options?: ZlibOptions): StatefulTransform;
+    /**
+     * Create a deflate decompression transform.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function decompressDeflateSync(options?: ZlibOptions): SyncStatefulTransform;
+    /**
+     * Create a gzip decompression transform.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function decompressGzip(options?: ZlibOptions): StatefulTransform;
+    /**
+     * Create a gzip decompression transform.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function decompressGzipSync(options?: ZlibOptions): SyncStatefulTransform;
+    /**
+     * Create a Zstandard decompression transform.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function decompressZstd(options?: ZstdOptions): StatefulTransform;
+    /**
+     * Create a Zstandard decompression transform.
+     * @since v25.9.0
+     * @returns A stateful transform.
+     */
+    function decompressZstdSync(options?: ZstdOptions): SyncStatefulTransform;
+}
+declare module "zlib/iter" {
+    export * from "node:zlib/iter";
+}