@psnext/slingcli 3.3.20260911-1 → 3.3.20260914-1

package/node_modules/undici-types/errors.d.ts

@@ -1,24 +1,24 @@
-import { IncomingHttpHeaders } from "./header";
+import { IncomingHttpHeaders } from './header'
 import Client from './client'
 
 export default Errors
 
 declare namespace Errors {
   export class UndiciError extends Error {
-    name: string;
-    code: string;
+    name: string
+    code: string
   }
 
   /** Connect timeout error. */
   export class ConnectTimeoutError extends UndiciError {
-    name: 'ConnectTimeoutError';
-    code: 'UND_ERR_CONNECT_TIMEOUT';
+    name: 'ConnectTimeoutError'
+    code: 'UND_ERR_CONNECT_TIMEOUT'
   }
 
   /** A header exceeds the `headersTimeout` option. */
   export class HeadersTimeoutError extends UndiciError {
-    name: 'HeadersTimeoutError';
-    code: 'UND_ERR_HEADERS_TIMEOUT';
+    name: 'HeadersTimeoutError'
+    code: 'UND_ERR_HEADERS_TIMEOUT'
   }
 
   /** Headers overflow error. */
@@ -29,101 +29,102 @@ declare namespace Errors {
 
   /** A body exceeds the `bodyTimeout` option. */
   export class BodyTimeoutError extends UndiciError {
-    name: 'BodyTimeoutError';
-    code: 'UND_ERR_BODY_TIMEOUT';
+    name: 'BodyTimeoutError'
+    code: 'UND_ERR_BODY_TIMEOUT'
   }
 
-  export class ResponseStatusCodeError extends UndiciError {
+  export class ResponseError extends UndiciError {
     constructor (
-      message?: string,
-      statusCode?: number,
-      headers?: IncomingHttpHeaders | string[] | null,
-      body?: null | Record<string, any> | string
-    );
-    name: 'ResponseStatusCodeError';
-    code: 'UND_ERR_RESPONSE_STATUS_CODE';
-    body: null | Record<string, any> | string
-    status: number
+      message: string,
+      code: number,
+      options: {
+        headers?: IncomingHttpHeaders | string[] | null,
+        body?: null | Record<string, any> | string
+      }
+    )
+    name: 'ResponseError'
+    code: 'UND_ERR_RESPONSE'
     statusCode: number
-    headers: IncomingHttpHeaders | string[] | null;
+    body: null | Record<string, any> | string
+    headers: IncomingHttpHeaders | string[] | null
   }
 
   /** Passed an invalid argument. */
   export class InvalidArgumentError extends UndiciError {
-    name: 'InvalidArgumentError';
-    code: 'UND_ERR_INVALID_ARG';
+    name: 'InvalidArgumentError'
+    code: 'UND_ERR_INVALID_ARG'
   }
 
   /** Returned an invalid value. */
   export class InvalidReturnValueError extends UndiciError {
-    name: 'InvalidReturnValueError';
-    code: 'UND_ERR_INVALID_RETURN_VALUE';
+    name: 'InvalidReturnValueError'
+    code: 'UND_ERR_INVALID_RETURN_VALUE'
   }
 
   /** The request has been aborted by the user. */
   export class RequestAbortedError extends UndiciError {
-    name: 'AbortError';
-    code: 'UND_ERR_ABORTED';
+    name: 'AbortError'
+    code: 'UND_ERR_ABORTED'
   }
 
   /** Expected error with reason. */
   export class InformationalError extends UndiciError {
-    name: 'InformationalError';
-    code: 'UND_ERR_INFO';
+    name: 'InformationalError'
+    code: 'UND_ERR_INFO'
   }
 
   /** Request body length does not match content-length header. */
   export class RequestContentLengthMismatchError extends UndiciError {
-    name: 'RequestContentLengthMismatchError';
-    code: 'UND_ERR_REQ_CONTENT_LENGTH_MISMATCH';
+    name: 'RequestContentLengthMismatchError'
+    code: 'UND_ERR_REQ_CONTENT_LENGTH_MISMATCH'
   }
 
   /** Response body length does not match content-length header. */
   export class ResponseContentLengthMismatchError extends UndiciError {
-    name: 'ResponseContentLengthMismatchError';
-    code: 'UND_ERR_RES_CONTENT_LENGTH_MISMATCH';
+    name: 'ResponseContentLengthMismatchError'
+    code: 'UND_ERR_RES_CONTENT_LENGTH_MISMATCH'
   }
 
   /** Trying to use a destroyed client. */
   export class ClientDestroyedError extends UndiciError {
-    name: 'ClientDestroyedError';
-    code: 'UND_ERR_DESTROYED';
+    name: 'ClientDestroyedError'
+    code: 'UND_ERR_DESTROYED'
   }
 
   /** Trying to use a closed client. */
   export class ClientClosedError extends UndiciError {
-    name: 'ClientClosedError';
-    code: 'UND_ERR_CLOSED';
+    name: 'ClientClosedError'
+    code: 'UND_ERR_CLOSED'
   }
 
   /** There is an error with the socket. */
   export class SocketError extends UndiciError {
-    name: 'SocketError';
-    code: 'UND_ERR_SOCKET';
+    name: 'SocketError'
+    code: 'UND_ERR_SOCKET'
     socket: Client.SocketInfo | null
   }
 
   /** Encountered unsupported functionality. */
   export class NotSupportedError extends UndiciError {
-    name: 'NotSupportedError';
-    code: 'UND_ERR_NOT_SUPPORTED';
+    name: 'NotSupportedError'
+    code: 'UND_ERR_NOT_SUPPORTED'
   }
 
   /** No upstream has been added to the BalancedPool. */
   export class BalancedPoolMissingUpstreamError extends UndiciError {
-    name: 'MissingUpstreamError';
-    code: 'UND_ERR_BPL_MISSING_UPSTREAM';
+    name: 'MissingUpstreamError'
+    code: 'UND_ERR_BPL_MISSING_UPSTREAM'
   }
 
   export class HTTPParserError extends UndiciError {
-    name: 'HTTPParserError';
-    code: string;
+    name: 'HTTPParserError'
+    code: string
   }
 
   /** The response exceed the length allowed. */
   export class ResponseExceededMaxSizeError extends UndiciError {
-    name: 'ResponseExceededMaxSizeError';
-    code: 'UND_ERR_RES_EXCEEDED_MAX_SIZE';
+    name: 'ResponseExceededMaxSizeError'
+    code: 'UND_ERR_RES_EXCEEDED_MAX_SIZE'
   }
 
   export class RequestRetryError extends UndiciError {
@@ -132,18 +133,55 @@ declare namespace Errors {
       statusCode: number,
       headers?: IncomingHttpHeaders | string[] | null,
       body?: null | Record<string, any> | string
-    );
-    name: 'RequestRetryError';
-    code: 'UND_ERR_REQ_RETRY';
-    statusCode: number;
+    )
+    name: 'RequestRetryError'
+    code: 'UND_ERR_REQ_RETRY'
+    statusCode: number
     data: {
       count: number;
-    };
-    headers: Record<string, string | string[]>;
+    }
+
+    headers: Record<string, string | string[]>
   }
 
   export class SecureProxyConnectionError extends UndiciError {
-    name: 'SecureProxyConnectionError';
-    code: 'UND_ERR_PRX_TLS';
+    constructor (
+      cause?: Error,
+      message?: string,
+      options?: Record<any, any>
+    )
+    name: 'SecureProxyConnectionError'
+    code: 'UND_ERR_PRX_TLS'
+  }
+
+  export class ProxyConnectionError extends UndiciError {
+    constructor (
+      cause?: Error,
+      message?: string,
+      options?: Record<any, any>
+    )
+    name: 'ProxyConnectionError'
+    code: 'UND_ERR_PRX_CONN'
+  }
+
+  export class MaxOriginsReachedError extends UndiciError {
+    name: 'MaxOriginsReachedError'
+    code: 'UND_ERR_MAX_ORIGINS_REACHED'
+  }
+
+  /** SOCKS5 proxy related error. */
+  export class Socks5ProxyError extends UndiciError {
+    constructor (
+      message?: string,
+      code?: string
+    )
+    name: 'Socks5ProxyError'
+    code: string
+  }
+
+  /** WebSocket decompressed message exceeded maximum size. */
+  export class MessageSizeExceededError extends UndiciError {
+    name: 'MessageSizeExceededError'
+    code: 'UND_ERR_WS_MESSAGE_SIZE_EXCEEDED'
   }
 }

package/node_modules/undici-types/eventsource.d.ts

@@ -18,9 +18,9 @@ interface EventSource extends EventTarget {
   readonly CLOSED: 2
   readonly CONNECTING: 0
   readonly OPEN: 1
-  onerror: (this: EventSource, ev: ErrorEvent) => any
-  onmessage: (this: EventSource, ev: MessageEvent) => any
-  onopen: (this: EventSource, ev: Event) => any
+  onerror: ((this: EventSource, ev: ErrorEvent) => any) | null
+  onmessage: ((this: EventSource, ev: MessageEvent) => any) | null
+  onopen: ((this: EventSource, ev: Event) => any) | null
   readonly readyState: 0 | 1 | 2
   readonly url: string
   readonly withCredentials: boolean
@@ -56,6 +56,11 @@ export declare const EventSource: {
 }
 
 interface EventSourceInit {
-  withCredentials?: boolean,
+  withCredentials?: boolean
+  // @deprecated use `node.dispatcher` instead
   dispatcher?: Dispatcher
+  node?: {
+    dispatcher?: Dispatcher
+    reconnectionTime?: number
+  }
 }

package/node_modules/undici-types/fetch.d.ts

@@ -2,11 +2,11 @@
 // and https://github.com/node-fetch/node-fetch/blob/914ce6be5ec67a8bab63d68510aabf07cb818b6d/index.d.ts (MIT license)
 /// <reference types="node" />
 
-import { Blob } from 'buffer'
-import { URL, URLSearchParams } from 'url'
-import { ReadableStream } from 'stream/web'
+import { Blob } from 'node:buffer'
+import { URL, URLSearchParams } from 'node:url'
+import { ReadableStream } from 'node:stream/web'
 import { FormData } from './formdata'
-
+import { HeaderRecord } from './header'
 import Dispatcher from './dispatcher'
 
 export type RequestInfo = string | URL | Request
@@ -33,41 +33,66 @@ export class BodyMixin {
 
   readonly arrayBuffer: () => Promise<ArrayBuffer>
   readonly blob: () => Promise<Blob>
+  readonly bytes: () => Promise<Uint8Array>
   /**
    * @deprecated This method is not recommended for parsing multipart/form-data bodies in server environments.
-   * It is recommended to use a library such as [@fastify/busboy](https://www.npmjs.com/package/@fastify/busboy) as follows:
-   * 
+   * Calling body.formData() buffers and parses the entire body. Since this is dictated by the spec,
+   * this method must only be called on responses from trusted servers.
+   * For responses from untrusted or user-controlled servers, use a dedicated streaming parser such as
+   * [@fastify/busboy](https://www.npmjs.com/package/@fastify/busboy) and apply application-specific limits as follows:
+   *
    * @example
    * ```js
    * import { Busboy } from '@fastify/busboy'
    * import { Readable } from 'node:stream'
-   * 
+   *
    * const response = await fetch('...')
    * const busboy = new Busboy({ headers: { 'content-type': response.headers.get('content-type') } })
-   * 
+   *
    * // handle events emitted from `busboy`
-   * 
+   *
    * Readable.fromWeb(response.body).pipe(busboy)
    * ```
    */
   readonly formData: () => Promise<FormData>
   readonly json: () => Promise<unknown>
   readonly text: () => Promise<string>
+  readonly textStream: () => ReadableStream<string>
 }
 
 export interface SpecIterator<T, TReturn = any, TNext = undefined> {
   next(...args: [] | [TNext]): IteratorResult<T, TReturn>;
 }
 
-export interface SpecIterableIterator<T> extends SpecIterator<T> {
+export interface SpecIteratorObject<T, TReturn = undefined, TNext = unknown> extends SpecIterator<T, TReturn, TNext> {
+  [Symbol.iterator](): SpecIteratorObject<T, TReturn, TNext>;
+  map<U>(callbackfn: (value: T, index: number) => U): SpecIteratorObject<U>;
+  filter<S extends T>(predicate: (value: T, index: number) => value is S): SpecIteratorObject<S>;
+  filter(predicate: (value: T, index: number) => unknown): SpecIteratorObject<T>;
+  take(limit: number): SpecIteratorObject<T>;
+  drop(count: number): SpecIteratorObject<T>;
+  flatMap<U>(callbackfn: (value: T, index: number) => Iterator<U> | Iterable<U>): SpecIteratorObject<U>;
+  reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number) => T): T;
+  reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number) => T, initialValue: T): T;
+  reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number) => U, initialValue: U): U;
+  toArray(): T[];
+  forEach(callbackfn: (value: T, index: number) => void): void;
+  some(predicate: (value: T, index: number) => unknown): boolean;
+  every(predicate: (value: T, index: number) => unknown): boolean;
+  find<S extends T>(predicate: (value: T, index: number) => value is S): S | undefined;
+  find(predicate: (value: T, index: number) => unknown): T | undefined;
+  readonly [Symbol.toStringTag]: string;
+}
+
+export interface SpecIterableIterator<T> extends SpecIteratorObject<T> {
   [Symbol.iterator](): SpecIterableIterator<T>;
 }
 
 export interface SpecIterable<T> {
-  [Symbol.iterator](): SpecIterator<T>;
+  [Symbol.iterator](): SpecIterableIterator<T>;
 }
 
-export type HeadersInit = string[][] | Record<string, string | ReadonlyArray<string>> | Headers
+export type HeadersInit = [string, string][] | HeaderRecord | Headers
 
 export declare class Headers implements SpecIterable<[string, string]> {
   constructor (init?: HeadersInit)
@@ -119,20 +144,21 @@ type RequestDestination =
   | 'xslt'
 
 export interface RequestInit {
-  method?: string
-  keepalive?: boolean
-  headers?: HeadersInit
   body?: BodyInit | null
-  redirect?: RequestRedirect
-  integrity?: string
-  signal?: AbortSignal | null
+  cache?: RequestCache
   credentials?: RequestCredentials
+  dispatcher?: Dispatcher
+  duplex?: RequestDuplex
+  headers?: HeadersInit
+  integrity?: string
+  keepalive?: boolean
+  method?: string
   mode?: RequestMode
+  redirect?: RequestRedirect
   referrer?: string
   referrerPolicy?: ReferrerPolicy
+  signal?: AbortSignal | null
   window?: null
-  dispatcher?: Dispatcher
-  duplex?: RequestDuplex
 }
 
 export type ReferrerPolicy =
@@ -144,7 +170,7 @@ export type ReferrerPolicy =
   | 'same-origin'
   | 'strict-origin'
   | 'strict-origin-when-cross-origin'
-  | 'unsafe-url';
+  | 'unsafe-url'
 
 export type RequestMode = 'cors' | 'navigate' | 'no-cors' | 'same-origin'
 
@@ -171,7 +197,7 @@ export declare class Request extends BodyMixin {
   readonly signal: AbortSignal
   readonly duplex: RequestDuplex
 
-  readonly clone: () => Request
+  public clone (): Request
 }
 
 export interface ResponseInit {
@@ -201,9 +227,9 @@ export declare class Response extends BodyMixin {
   readonly url: string
   readonly redirected: boolean
 
-  readonly clone: () => Response
+  public clone (): Response
 
   static error (): Response
-  static json(data: any, init?: ResponseInit): Response
-  static redirect (url: string | URL, status: ResponseRedirectStatus): Response
+  static json (data: any, init?: ResponseInit): Response
+  static redirect (url: string | URL, status?: ResponseRedirectStatus): Response
 }

package/node_modules/undici-types/formdata.d.ts

@@ -1,7 +1,7 @@
 // Based on https://github.com/octet-stream/form-data/blob/2d0f0dc371517444ce1f22cdde13f51995d0953a/lib/FormData.ts (MIT)
 /// <reference types="node" />
 
-import { File } from './file'
+import { File } from 'node:buffer'
 import { SpecIterableIterator } from './fetch'
 
 /**
@@ -24,7 +24,7 @@ export declare class FormData {
     or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File). If none of these are specified the value is converted to a string.
    * @param fileName The filename reported to the server, when a Blob or File is passed as the second parameter. The default filename for Blob objects is "blob". The default filename for File objects is the file's filename.
    */
-  append(name: string, value: unknown, fileName?: string): void
+  append (name: string, value: unknown, fileName?: string): void
 
   /**
    * Set a new value for an existing key inside FormData,
@@ -36,7 +36,7 @@ export declare class FormData {
    * @param fileName The filename reported to the server, when a Blob or File is passed as the second parameter. The default filename for Blob objects is "blob". The default filename for File objects is the file's filename.
    *
    */
-  set(name: string, value: unknown, fileName?: string): void
+  set (name: string, value: unknown, fileName?: string): void
 
   /**
    * Returns the first value associated with a given key from within a `FormData` object.
@@ -46,7 +46,7 @@ export declare class FormData {
    *
    * @returns A `FormDataEntryValue` containing the value. If the key doesn't exist, the method returns null.
    */
-  get(name: string): FormDataEntryValue | null
+  get (name: string): FormDataEntryValue | null
 
   /**
    * Returns all the values associated with a given key from within a `FormData` object.
@@ -55,7 +55,7 @@ export declare class FormData {
    *
    * @returns An array of `FormDataEntryValue` whose key matches the value passed in the `name` parameter. If the key doesn't exist, the method returns an empty list.
    */
-  getAll(name: string): FormDataEntryValue[]
+  getAll (name: string): FormDataEntryValue[]
 
   /**
    * Returns a boolean stating whether a `FormData` object contains a certain key.
@@ -64,14 +64,14 @@ export declare class FormData {
    *
    * @return A boolean value.
    */
-  has(name: string): boolean
+  has (name: string): boolean
 
   /**
    * Deletes a key and its value(s) from a `FormData` object.
    *
    * @param name The name of the key you want to delete.
    */
-  delete(name: string): void
+  delete (name: string): void
 
   /**
    * Executes given callback function for each field of the FormData instance

package/node_modules/undici-types/global-dispatcher.d.ts

@@ -1,9 +1,9 @@
-import Dispatcher from "./dispatcher";
+import Dispatcher from './dispatcher'
+
+declare function setGlobalDispatcher<DispatcherImplementation extends Dispatcher> (dispatcher: DispatcherImplementation): void
+declare function getGlobalDispatcher (): Dispatcher
 
 export {
   getGlobalDispatcher,
   setGlobalDispatcher
 }
-
-declare function setGlobalDispatcher<DispatcherImplementation extends Dispatcher>(dispatcher: DispatcherImplementation): void;
-declare function getGlobalDispatcher(): Dispatcher;

package/node_modules/undici-types/global-origin.d.ts

@@ -1,7 +1,7 @@
+declare function setGlobalOrigin (origin: string | URL | undefined): void
+declare function getGlobalOrigin (): URL | undefined
+
 export {
-	setGlobalOrigin,
-	getGlobalOrigin
+  setGlobalOrigin,
+  getGlobalOrigin
 }
-  
-declare function setGlobalOrigin(origin: string | URL | undefined): void;
-declare function getGlobalOrigin(): URL | undefined;

package/node_modules/undici-types/h2c-client.d.ts

@@ -0,0 +1,73 @@
+import { URL } from 'node:url'
+import Dispatcher from './dispatcher'
+import buildConnector from './connector'
+
+type H2ClientOptions = Omit<Dispatcher.ConnectOptions, 'origin'>
+
+/**
+ * A basic H2C client, mapped on top a single TCP connection. Pipelining is disabled by default.
+ */
+export class H2CClient extends Dispatcher {
+  constructor (url: string | URL, options?: H2CClient.Options)
+  /** Property to get and set the pipelining factor. */
+  pipelining: number
+  /** `true` after `client.close()` has been called. */
+  closed: boolean
+  /** `true` after `client.destroyed()` has been called or `client.close()` has been called and the client shutdown has completed. */
+  destroyed: boolean
+
+  // Override dispatcher APIs.
+  override connect (
+    options: H2ClientOptions
+  ): Promise<Dispatcher.ConnectData>
+  override connect (
+    options: H2ClientOptions,
+    callback: (err: Error | null, data: Dispatcher.ConnectData) => void
+  ): void
+}
+
+export declare namespace H2CClient {
+  export interface Options {
+    /** The maximum length of request headers in bytes. Default: Node.js' `--max-http-header-size` or `16384` (16KiB). */
+    maxHeaderSize?: number;
+    /** The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers (Node 14 and above only). Default: `300e3` milliseconds (300s). */
+    headersTimeout?: number;
+    /** The timeout for establishing a socket connection, in milliseconds. Use `0` to disable it entirely. Default: `10e3` milliseconds (10s). */
+    connectTimeout?: number;
+    /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use `0` to disable it entirely. Default: `300e3` milliseconds (300s). */
+    bodyTimeout?: number;
+    /** the timeout, in milliseconds, after which a socket without active requests will time out. Monitors time between activity on a connected socket. This value may be overridden by *keep-alive* hints from the server. Default: `4e3` milliseconds (4s). */
+    keepAliveTimeout?: number;
+    /** the maximum allowed `idleTimeout`, in milliseconds, when overridden by *keep-alive* hints from the server. Default: `600e3` milliseconds (10min). */
+    keepAliveMaxTimeout?: number;
+    /** A number of milliseconds subtracted from server *keep-alive* hints when overriding `idleTimeout` to account for timing inaccuracies caused by e.g. transport latency. Default: `1e3` milliseconds (1s). */
+    keepAliveTimeoutThreshold?: number;
+    /** An IPC endpoint, either a Unix domain socket or Windows named pipe. Default: `null`. */
+    socketPath?: string;
+    /** The amount of concurrent requests to be sent over the single TCP/TLS connection according to [RFC7230](https://tools.ietf.org/html/rfc7230#section-6.3.2). Default: `1`. */
+    pipelining?: number;
+    /** If `true`, an error is thrown when the request content-length header doesn't match the length of the request body. Default: `true`. */
+    strictContentLength?: boolean;
+    /** Maximum number of TLS cached sessions used by the built-in connector. Use `0` to disable TLS session caching. Default: `100`. */
+    maxCachedSessions?: number;
+    /** Connector options passed to `buildConnector`, or a custom connector function. Default: `null`. */
+    connect?: Omit<Partial<buildConnector.BuildOptions>, 'allowH2'> | buildConnector.connector;
+    /** The maximum number of requests to send over a single connection before it is reset. Use `0` to disable this limit. Default: `null`. */
+    maxRequestsPerClient?: number;
+    /** Local IP address the socket should connect from. */
+    localAddress?: string;
+    /** Max response body size in bytes, -1 is disabled */
+    maxResponseSize?: number;
+    /** Enables a family autodetection algorithm that loosely implements section 5 of RFC 8305. */
+    autoSelectFamily?: boolean;
+    /** The amount of time in milliseconds to wait for a connection attempt to finish before trying the next address when using the `autoSelectFamily` option. */
+    autoSelectFamilyAttemptTimeout?: number;
+    /**
+     * @description Dictates the maximum number of concurrent streams for a single H2 session. It can be overridden by a SETTINGS remote frame.
+     * @default 100
+    */
+    maxConcurrentStreams?: number
+  }
+}
+
+export default H2CClient

package/node_modules/undici-types/handlers.d.ts

@@ -1,15 +1,16 @@
-import Dispatcher from "./dispatcher";
+import Dispatcher from './dispatcher'
 
-export declare class RedirectHandler implements Dispatcher.DispatchHandlers {
-  constructor(
-    dispatch: Dispatcher,
+export declare class RedirectHandler implements Dispatcher.DispatchHandler {
+  static buildDispatch (dispatcher: Dispatcher, maxRedirections: number): Dispatcher.Dispatch
+
+  constructor (
+    dispatch: Dispatcher.Dispatch,
     maxRedirections: number,
     opts: Dispatcher.DispatchOptions,
-    handler: Dispatcher.DispatchHandlers,
-    redirectionLimitReached: boolean
-  );
+    handler: Dispatcher.DispatchHandler
+  )
 }
 
-export declare class DecoratorHandler implements Dispatcher.DispatchHandlers {
-  constructor(handler: Dispatcher.DispatchHandlers);
+export declare class DecoratorHandler implements Dispatcher.DispatchHandler {
+  constructor (handler: Dispatcher.DispatchHandler)
 }