@psnext/slingcli 3.0.20260827-1 → 3.3.20260911-1

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

@@ -1,4 +1,32 @@
-declare module "node:punycode" {
+/**
+ * **The version of the punycode module bundled in Node.js is being deprecated. **In a future major version of Node.js this module will be removed. Users
+ * currently depending on the `punycode` module should switch to using the
+ * userland-provided [Punycode.js](https://github.com/bestiejs/punycode.js) module instead. For punycode-based URL
+ * encoding, see `url.domainToASCII` or, more generally, the `WHATWG URL API`.
+ *
+ * The `punycode` module is a bundled version of the [Punycode.js](https://github.com/bestiejs/punycode.js) module. It
+ * can be accessed using:
+ *
+ * ```js
+ * import punycode from 'node:punycode';
+ * ```
+ *
+ * [Punycode](https://tools.ietf.org/html/rfc3492) is a character encoding scheme defined by RFC 3492 that is
+ * primarily intended for use in Internationalized Domain Names. Because host
+ * names in URLs are limited to ASCII characters only, Domain Names that contain
+ * non-ASCII characters must be converted into ASCII using the Punycode scheme.
+ * For instance, the Japanese character that translates into the English word, `'example'` is `'例'`. The Internationalized Domain Name, `'例.com'` (equivalent
+ * to `'example.com'`) is represented by Punycode as the ASCII string `'xn--fsq.com'`.
+ *
+ * The `punycode` module provides a simple implementation of the Punycode standard.
+ *
+ * The `punycode` module is a third-party dependency used by Node.js and
+ * made available to developers as a convenience. Fixes or other modifications to
+ * the module must be directed to the [Punycode.js](https://github.com/bestiejs/punycode.js) project.
+ * @deprecated Since v7.0.0 - Deprecated
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/punycode.js)
+ */
+declare module "punycode" {
     /**
      * The `punycode.decode()` method converts a [Punycode](https://tools.ietf.org/html/rfc3492) string of ASCII-only
      * characters to the equivalent string of Unicode codepoints.
@@ -84,6 +112,6 @@ declare module "node:punycode" {
      */
     const version: string;
 }
-declare module "punycode" {
-    export * from "node:punycode";
+declare module "node:punycode" {
+    export * from "punycode";
 }

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

@@ -1,4 +1,17 @@
-declare module "node:querystring" {
+/**
+ * The `node:querystring` module provides utilities for parsing and formatting URL
+ * query strings. It can be accessed using:
+ *
+ * ```js
+ * import querystring from 'node:querystring';
+ * ```
+ *
+ * `querystring` is more performant than `URLSearchParams` but is not a
+ * standardized API. Use `URLSearchParams` when performance is not critical or
+ * when compatibility with browser code is desirable.
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/querystring.js)
+ */
+declare module "querystring" {
     interface StringifyOptions {
         /**
          * The function to use when converting URL-unsafe characters to percent-encoding in the query string.
@@ -134,6 +147,6 @@ declare module "node:querystring" {
      */
     function unescape(str: string): string;
 }
-declare module "querystring" {
-    export * from "node:querystring";
+declare module "node:querystring" {
+    export * from "querystring";
 }

package/node_modules/@types/node/readline/promises.d.ts

@@ -1,4 +1,7 @@
-declare module "node:readline/promises" {
+/**
+ * @since v17.0.0
+ */
+declare module "readline/promises" {
     import { Abortable } from "node:events";
     import {
         CompleterResult,
@@ -153,6 +156,6 @@ declare module "node:readline/promises" {
     ): Interface;
     function createInterface(options: ReadLineOptions): Interface;
 }
-declare module "readline/promises" {
-    export * from "node:readline/promises";
+declare module "node:readline/promises" {
+    export * from "readline/promises";
 }

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

@@ -1,54 +1,57 @@
-declare module "node:readline" {
-    import { Abortable, EventEmitter, InternalEventEmitter } from "node:events";
-    interface Key {
+/**
+ * The `node:readline` module provides an interface for reading data from a [Readable](https://nodejs.org/docs/latest-v22.x/api/stream.html#readable-streams) stream
+ * (such as [`process.stdin`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstdin)) one line at a time.
+ *
+ * To use the promise-based APIs:
+ *
+ * ```js
+ * import * as readline from 'node:readline/promises';
+ * ```
+ *
+ * To use the callback and sync APIs:
+ *
+ * ```js
+ * import * as readline from 'node:readline';
+ * ```
+ *
+ * The following simple example illustrates the basic use of the `node:readline` module.
+ *
+ * ```js
+ * import * as readline from 'node:readline/promises';
+ * import { stdin as input, stdout as output } from 'node:process';
+ *
+ * const rl = readline.createInterface({ input, output });
+ *
+ * const answer = await rl.question('What do you think of Node.js? ');
+ *
+ * console.log(`Thank you for your valuable feedback: ${answer}`);
+ *
+ * rl.close();
+ * ```
+ *
+ * Once this code is invoked, the Node.js application will not terminate until the `readline.Interface` is closed because the interface waits for data to be
+ * received on the `input` stream.
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/readline.js)
+ */
+declare module "readline" {
+    import { Abortable, EventEmitter } from "node:events";
+    import * as promises from "node:readline/promises";
+    export { promises };
+    export interface Key {
         sequence?: string | undefined;
         name?: string | undefined;
         ctrl?: boolean | undefined;
         meta?: boolean | undefined;
         shift?: boolean | undefined;
     }
-    interface InterfaceEventMap {
-        "close": [];
-        "error": [error: Error];
-        "history": [history: string[]];
-        "line": [input: string];
-        "pause": [];
-        "resume": [];
-        "SIGCONT": [];
-        "SIGINT": [];
-        "SIGTSTP": [];
-    }
     /**
      * Instances of the `readline.Interface` class are constructed using the `readline.createInterface()` method. Every instance is associated with a
-     * single `input` [Readable](https://nodejs.org/docs/latest-v26.x/api/stream.html#readable-streams) stream and a single `output` [Writable](https://nodejs.org/docs/latest-v26.x/api/stream.html#writable-streams) stream.
+     * single `input` [Readable](https://nodejs.org/docs/latest-v22.x/api/stream.html#readable-streams) stream and a single `output` [Writable](https://nodejs.org/docs/latest-v22.x/api/stream.html#writable-streams) stream.
      * The `output` stream is used to print prompts for user input that arrives on,
      * and is read from, the `input` stream.
      * @since v0.1.104
      */
-    class Interface implements EventEmitter, Disposable {
-        /**
-         * NOTE: According to the documentation:
-         *
-         * > Instances of the `readline.Interface` class are constructed using the
-         * > `readline.createInterface()` method.
-         *
-         * @see https://nodejs.org/dist/latest-v26.x/docs/api/readline.html#class-interfaceconstructor
-         */
-        protected constructor(
-            input: NodeJS.ReadableStream,
-            output?: NodeJS.WritableStream,
-            completer?: Completer | AsyncCompleter,
-            terminal?: boolean,
-        );
-        /**
-         * NOTE: According to the documentation:
-         *
-         * > Instances of the `readline.Interface` class are constructed using the
-         * > `readline.createInterface()` method.
-         *
-         * @see https://nodejs.org/dist/latest-v26.x/docs/api/readline.html#class-interfaceconstructor
-         */
-        protected constructor(options: ReadLineOptions);
+    export class Interface extends EventEmitter implements Disposable {
         readonly terminal: boolean;
         /**
          * The current input data being processed by node.
@@ -91,6 +94,29 @@ declare module "node:readline" {
          * @since v0.1.98
          */
         readonly cursor: number;
+        /**
+         * NOTE: According to the documentation:
+         *
+         * > Instances of the `readline.Interface` class are constructed using the
+         * > `readline.createInterface()` method.
+         *
+         * @see https://nodejs.org/dist/latest-v22.x/docs/api/readline.html#class-interfaceconstructor
+         */
+        protected constructor(
+            input: NodeJS.ReadableStream,
+            output?: NodeJS.WritableStream,
+            completer?: Completer | AsyncCompleter,
+            terminal?: boolean,
+        );
+        /**
+         * NOTE: According to the documentation:
+         *
+         * > Instances of the `readline.Interface` class are constructed using the
+         * > `readline.createInterface()` method.
+         *
+         * @see https://nodejs.org/dist/latest-v22.x/docs/api/readline.html#class-interfaceconstructor
+         */
+        protected constructor(options: ReadLineOptions);
         /**
          * The `rl.getPrompt()` method returns the current prompt used by `rl.prompt()`.
          * @since v15.3.0, v14.17.0
@@ -218,22 +244,87 @@ declare module "node:readline" {
          * @since v13.5.0, v12.16.0
          */
         getCursorPos(): CursorPos;
+        /**
+         * events.EventEmitter
+         * 1. close
+         * 2. line
+         * 3. pause
+         * 4. resume
+         * 5. SIGCONT
+         * 6. SIGINT
+         * 7. SIGTSTP
+         * 8. history
+         */
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: "close", listener: () => void): this;
+        addListener(event: "line", listener: (input: string) => void): this;
+        addListener(event: "pause", listener: () => void): this;
+        addListener(event: "resume", listener: () => void): this;
+        addListener(event: "SIGCONT", listener: () => void): this;
+        addListener(event: "SIGINT", listener: () => void): this;
+        addListener(event: "SIGTSTP", listener: () => void): this;
+        addListener(event: "history", listener: (history: string[]) => void): this;
+        emit(event: string | symbol, ...args: any[]): boolean;
+        emit(event: "close"): boolean;
+        emit(event: "line", input: string): boolean;
+        emit(event: "pause"): boolean;
+        emit(event: "resume"): boolean;
+        emit(event: "SIGCONT"): boolean;
+        emit(event: "SIGINT"): boolean;
+        emit(event: "SIGTSTP"): boolean;
+        emit(event: "history", history: string[]): boolean;
+        on(event: string, listener: (...args: any[]) => void): this;
+        on(event: "close", listener: () => void): this;
+        on(event: "line", listener: (input: string) => void): this;
+        on(event: "pause", listener: () => void): this;
+        on(event: "resume", listener: () => void): this;
+        on(event: "SIGCONT", listener: () => void): this;
+        on(event: "SIGINT", listener: () => void): this;
+        on(event: "SIGTSTP", listener: () => void): this;
+        on(event: "history", listener: (history: string[]) => void): this;
+        once(event: string, listener: (...args: any[]) => void): this;
+        once(event: "close", listener: () => void): this;
+        once(event: "line", listener: (input: string) => void): this;
+        once(event: "pause", listener: () => void): this;
+        once(event: "resume", listener: () => void): this;
+        once(event: "SIGCONT", listener: () => void): this;
+        once(event: "SIGINT", listener: () => void): this;
+        once(event: "SIGTSTP", listener: () => void): this;
+        once(event: "history", listener: (history: string[]) => void): this;
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(event: "close", listener: () => void): this;
+        prependListener(event: "line", listener: (input: string) => void): this;
+        prependListener(event: "pause", listener: () => void): this;
+        prependListener(event: "resume", listener: () => void): this;
+        prependListener(event: "SIGCONT", listener: () => void): this;
+        prependListener(event: "SIGINT", listener: () => void): this;
+        prependListener(event: "SIGTSTP", listener: () => void): this;
+        prependListener(event: "history", listener: (history: string[]) => void): this;
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(event: "close", listener: () => void): this;
+        prependOnceListener(event: "line", listener: (input: string) => void): this;
+        prependOnceListener(event: "pause", listener: () => void): this;
+        prependOnceListener(event: "resume", listener: () => void): this;
+        prependOnceListener(event: "SIGCONT", listener: () => void): this;
+        prependOnceListener(event: "SIGINT", listener: () => void): this;
+        prependOnceListener(event: "SIGTSTP", listener: () => void): this;
+        prependOnceListener(event: "history", listener: (history: string[]) => void): this;
         [Symbol.asyncIterator](): NodeJS.AsyncIterator<string>;
     }
-    interface Interface extends InternalEventEmitter<InterfaceEventMap> {}
-    type Completer = (line: string) => CompleterResult;
-    type AsyncCompleter = (
+    export type ReadLine = Interface; // type forwarded for backwards compatibility
+    export type Completer = (line: string) => CompleterResult;
+    export type AsyncCompleter = (
         line: string,
         callback: (err?: null | Error, result?: CompleterResult) => void,
     ) => void;
-    type CompleterResult = [string[], string];
-    interface ReadLineOptions {
+    export type CompleterResult = [string[], string];
+    export interface ReadLineOptions {
         /**
-         * The [`Readable`](https://nodejs.org/docs/latest-v26.x/api/stream.html#readable-streams) stream to listen to
+         * The [`Readable`](https://nodejs.org/docs/latest-v22.x/api/stream.html#readable-streams) stream to listen to
          */
         input: NodeJS.ReadableStream;
         /**
-         * The [`Writable`](https://nodejs.org/docs/latest-v26.x/api/stream.html#writable-streams) stream to write readline data to.
+         * The [`Writable`](https://nodejs.org/docs/latest-v22.x/api/stream.html#writable-streams) stream to write readline data to.
          */
         output?: NodeJS.WritableStream | undefined;
         /**
@@ -278,7 +369,7 @@ declare module "node:readline" {
          * `crlfDelay` will be coerced to a number no less than `100`.
          * It can be set to `Infinity`, in which case
          * `\r` followed by `\n` will always be considered a single newline
-         * (which may be reasonable for [reading files](https://nodejs.org/docs/latest-v26.x/api/readline.html#example-read-file-stream-line-by-line) with `\r\n` line delimiter).
+         * (which may be reasonable for [reading files](https://nodejs.org/docs/latest-v22.x/api/readline.html#example-read-file-stream-line-by-line) with `\r\n` line delimiter).
          * @default 100
          */
         crlfDelay?: number | undefined;
@@ -331,13 +422,13 @@ declare module "node:readline" {
      * waiting for user input, call `process.stdin.unref()`.
      * @since v0.1.98
      */
-    function createInterface(
+    export function createInterface(
         input: NodeJS.ReadableStream,
         output?: NodeJS.WritableStream,
         completer?: Completer | AsyncCompleter,
         terminal?: boolean,
     ): Interface;
-    function createInterface(options: ReadLineOptions): Interface;
+    export function createInterface(options: ReadLineOptions): Interface;
     /**
      * The `readline.emitKeypressEvents()` method causes the given `Readable` stream to begin emitting `'keypress'` events corresponding to received input.
      *
@@ -459,50 +550,45 @@ declare module "node:readline" {
      * ```
      * @since v0.7.7
      */
-    function emitKeypressEvents(stream: NodeJS.ReadableStream, readlineInterface?: Interface): void;
-    type Direction = -1 | 0 | 1;
-    interface CursorPos {
+    export function emitKeypressEvents(stream: NodeJS.ReadableStream, readlineInterface?: Interface): void;
+    export type Direction = -1 | 0 | 1;
+    export interface CursorPos {
         rows: number;
         cols: number;
     }
     /**
-     * The `readline.clearLine()` method clears current line of given [TTY](https://nodejs.org/docs/latest-v26.x/api/tty.html) stream
+     * The `readline.clearLine()` method clears current line of given [TTY](https://nodejs.org/docs/latest-v22.x/api/tty.html) stream
      * in a specified direction identified by `dir`.
      * @since v0.7.7
      * @param callback Invoked once the operation completes.
      * @return `false` if `stream` wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
      */
-    function clearLine(stream: NodeJS.WritableStream, dir: Direction, callback?: () => void): boolean;
+    export function clearLine(stream: NodeJS.WritableStream, dir: Direction, callback?: () => void): boolean;
     /**
-     * The `readline.clearScreenDown()` method clears the given [TTY](https://nodejs.org/docs/latest-v26.x/api/tty.html) stream from
+     * The `readline.clearScreenDown()` method clears the given [TTY](https://nodejs.org/docs/latest-v22.x/api/tty.html) stream from
      * the current position of the cursor down.
      * @since v0.7.7
      * @param callback Invoked once the operation completes.
      * @return `false` if `stream` wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
      */
-    function clearScreenDown(stream: NodeJS.WritableStream, callback?: () => void): boolean;
+    export function clearScreenDown(stream: NodeJS.WritableStream, callback?: () => void): boolean;
     /**
      * The `readline.cursorTo()` method moves cursor to the specified position in a
-     * given [TTY](https://nodejs.org/docs/latest-v26.x/api/tty.html) `stream`.
+     * given [TTY](https://nodejs.org/docs/latest-v22.x/api/tty.html) `stream`.
      * @since v0.7.7
      * @param callback Invoked once the operation completes.
      * @return `false` if `stream` wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
      */
-    function cursorTo(stream: NodeJS.WritableStream, x: number, y?: number, callback?: () => void): boolean;
+    export function cursorTo(stream: NodeJS.WritableStream, x: number, y?: number, callback?: () => void): boolean;
     /**
      * The `readline.moveCursor()` method moves the cursor _relative_ to its current
-     * position in a given [TTY](https://nodejs.org/docs/latest-v26.x/api/tty.html) `stream`.
+     * position in a given [TTY](https://nodejs.org/docs/latest-v22.x/api/tty.html) `stream`.
      * @since v0.7.7
      * @param callback Invoked once the operation completes.
      * @return `false` if `stream` wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
      */
-    function moveCursor(stream: NodeJS.WritableStream, dx: number, dy: number, callback?: () => void): boolean;
-    /** @deprecated This alias will be removed in a future version. Use `import { Interface } from 'node:readline'` instead. */
-    type ReadLine = Interface;
+    export function moveCursor(stream: NodeJS.WritableStream, dx: number, dy: number, callback?: () => void): boolean;
 }
 declare module "node:readline" {
-    export * as promises from "node:readline/promises";
-}
-declare module "readline" {
-    export * from "node:readline";
+    export * from "readline";
 }