omegon 0.8.4 → 0.9.0

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

@@ -9,7 +9,7 @@
  * ```
  *
  * Compression and decompression are built around the Node.js
- * [Streams API](https://nodejs.org/docs/latest-v25.x/api/stream.html).
+ * [Streams API](https://nodejs.org/docs/latest-v22.x/api/stream.html).
  *
  * Compressing or decompressing a stream (such as a file) can be accomplished by
  * piping the source stream through a `zlib` `Transform` stream into a destination
@@ -89,9 +89,9 @@
  *   });
  * ```
  * @since v0.5.8
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/zlib.js)
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/zlib.js)
  */
-declare module "node:zlib" {
+declare module "zlib" {
     import { NonSharedBuffer } from "node:buffer";
     import * as stream from "node:stream";
     interface ZlibOptions {
@@ -148,7 +148,7 @@ declare module "node:zlib" {
             }
             | undefined;
         /**
-         * Limits output size when using [convenience methods](https://nodejs.org/docs/latest-v25.x/api/zlib.html#convenience-methods).
+         * Limits output size when using [convenience methods](https://nodejs.org/docs/latest-v22.x/api/zlib.html#convenience-methods).
          * @default buffer.kMaxLength
          */
         maxOutputLength?: number | undefined;
@@ -172,12 +172,12 @@ declare module "node:zlib" {
         chunkSize?: number | undefined;
         /**
          * Key-value object containing indexed
-         * [Zstd parameters](https://nodejs.org/docs/latest-v25.x/api/zlib.html#zstd-constants).
+         * [Zstd parameters](https://nodejs.org/docs/latest-v22.x/api/zlib.html#zstd-constants).
          */
         params?: { [key: number]: number | boolean } | undefined;
         /**
          * Limits output size when using
-         * [convenience methods](https://nodejs.org/docs/latest-v25.x/api/zlib.html#convenience-methods).
+         * [convenience methods](https://nodejs.org/docs/latest-v22.x/api/zlib.html#convenience-methods).
          * @default buffer.kMaxLength
          */
         maxOutputLength?: number | undefined;
@@ -188,11 +188,13 @@ declare module "node:zlib" {
         /**
          * Optional dictionary used to improve compression efficiency when compressing or decompressing data that
          * shares common patterns with the dictionary.
-         * @since v24.6.0
+         * @since v22.19.0
          */
         dictionary?: NodeJS.ArrayBufferView | undefined;
     }
     interface Zlib {
+        /** @deprecated Use bytesWritten instead. */
+        readonly bytesRead: number;
         readonly bytesWritten: number;
         shell?: boolean | string | undefined;
         close(callback?: () => void): void;
@@ -676,7 +678,70 @@ declare module "node:zlib" {
         const Z_SYNC_FLUSH: number;
         const Z_VERSION_ERROR: number;
     }
+    // Allowed flush values.
+    /** @deprecated Use `constants.Z_NO_FLUSH` */
+    const Z_NO_FLUSH: number;
+    /** @deprecated Use `constants.Z_PARTIAL_FLUSH` */
+    const Z_PARTIAL_FLUSH: number;
+    /** @deprecated Use `constants.Z_SYNC_FLUSH` */
+    const Z_SYNC_FLUSH: number;
+    /** @deprecated Use `constants.Z_FULL_FLUSH` */
+    const Z_FULL_FLUSH: number;
+    /** @deprecated Use `constants.Z_FINISH` */
+    const Z_FINISH: number;
+    /** @deprecated Use `constants.Z_BLOCK` */
+    const Z_BLOCK: number;
+    // Return codes for the compression/decompression functions.
+    // Negative values are errors, positive values are used for special but normal events.
+    /** @deprecated Use `constants.Z_OK` */
+    const Z_OK: number;
+    /** @deprecated Use `constants.Z_STREAM_END` */
+    const Z_STREAM_END: number;
+    /** @deprecated Use `constants.Z_NEED_DICT` */
+    const Z_NEED_DICT: number;
+    /** @deprecated Use `constants.Z_ERRNO` */
+    const Z_ERRNO: number;
+    /** @deprecated Use `constants.Z_STREAM_ERROR` */
+    const Z_STREAM_ERROR: number;
+    /** @deprecated Use `constants.Z_DATA_ERROR` */
+    const Z_DATA_ERROR: number;
+    /** @deprecated Use `constants.Z_MEM_ERROR` */
+    const Z_MEM_ERROR: number;
+    /** @deprecated Use `constants.Z_BUF_ERROR` */
+    const Z_BUF_ERROR: number;
+    /** @deprecated Use `constants.Z_VERSION_ERROR` */
+    const Z_VERSION_ERROR: number;
+    // Compression levels.
+    /** @deprecated Use `constants.Z_NO_COMPRESSION` */
+    const Z_NO_COMPRESSION: number;
+    /** @deprecated Use `constants.Z_BEST_SPEED` */
+    const Z_BEST_SPEED: number;
+    /** @deprecated Use `constants.Z_BEST_COMPRESSION` */
+    const Z_BEST_COMPRESSION: number;
+    /** @deprecated Use `constants.Z_DEFAULT_COMPRESSION` */
+    const Z_DEFAULT_COMPRESSION: number;
+    // Compression strategy.
+    /** @deprecated Use `constants.Z_FILTERED` */
+    const Z_FILTERED: number;
+    /** @deprecated Use `constants.Z_HUFFMAN_ONLY` */
+    const Z_HUFFMAN_ONLY: number;
+    /** @deprecated Use `constants.Z_RLE` */
+    const Z_RLE: number;
+    /** @deprecated Use `constants.Z_FIXED` */
+    const Z_FIXED: number;
+    /** @deprecated Use `constants.Z_DEFAULT_STRATEGY` */
+    const Z_DEFAULT_STRATEGY: number;
+    /** @deprecated */
+    const Z_BINARY: number;
+    /** @deprecated */
+    const Z_TEXT: number;
+    /** @deprecated */
+    const Z_ASCII: number;
+    /** @deprecated  */
+    const Z_UNKNOWN: number;
+    /** @deprecated */
+    const Z_DEFLATED: number;
 }
-declare module "zlib" {
-    export * from "node:zlib";
+declare module "node:zlib" {
+    export * from "zlib";
 }

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

@@ -1,32 +1,31 @@
-import { URL } from 'node:url'
+import { URL } from 'url'
 import Pool from './pool'
-import Dispatcher from './dispatcher'
-import TClientStats from './client-stats'
-import TPoolStats from './pool-stats'
+import Dispatcher from "./dispatcher";
 
 export default Agent
 
-declare class Agent extends Dispatcher {
-  constructor (opts?: Agent.Options)
+declare class Agent extends Dispatcher{
+  constructor(opts?: Agent.Options)
   /** `true` after `dispatcher.close()` has been called. */
-  closed: boolean
+  closed: boolean;
   /** `true` after `dispatcher.destroyed()` has been called or `dispatcher.close()` has been called and the dispatcher shutdown has completed. */
-  destroyed: boolean
+  destroyed: boolean;
   /** Dispatches a request. */
-  dispatch (options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandler): boolean
-  /** Aggregate stats for a Agent by origin. */
-  readonly stats: Record<string, TClientStats | TPoolStats>
+  dispatch(options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandlers): boolean;
 }
 
 declare namespace Agent {
   export interface Options extends Pool.Options {
     /** Default: `(origin, opts) => new Pool(origin, opts)`. */
     factory?(origin: string | URL, opts: Object): Dispatcher;
+    /** Integer. Default: `0` */
+    maxRedirections?: number;
 
-    interceptors?: { Agent?: readonly Dispatcher.DispatchInterceptor[] } & Pool.Options['interceptors']
-    maxOrigins?: number
+    interceptors?: { Agent?: readonly Dispatcher.DispatchInterceptor[] } & Pool.Options["interceptors"]
   }
 
   export interface DispatchOptions extends Dispatcher.DispatchOptions {
+    /** Integer. */
+    maxRedirections?: number;
   }
 }

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

@@ -1,43 +1,43 @@
-import { URL, UrlObject } from 'node:url'
-import { Duplex } from 'node:stream'
+import { URL, UrlObject } from 'url'
+import { Duplex } from 'stream'
 import Dispatcher from './dispatcher'
 
+export {
+  request,
+  stream,
+  pipeline,
+  connect,
+  upgrade,
+}
+
 /** Performs an HTTP request. */
-declare function request<TOpaque = null> (
+declare function request(
   url: string | URL | UrlObject,
-  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions<TOpaque>, 'origin' | 'path' | 'method'> & Partial<Pick<Dispatcher.RequestOptions, 'method'>>,
-): Promise<Dispatcher.ResponseData<TOpaque>>
+  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions, 'origin' | 'path' | 'method'> & Partial<Pick<Dispatcher.RequestOptions, 'method'>>,
+): Promise<Dispatcher.ResponseData>;
 
 /** A faster version of `request`. */
-declare function stream<TOpaque = null> (
+declare function stream(
   url: string | URL | UrlObject,
-  options: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions<TOpaque>, 'origin' | 'path'>,
-  factory: Dispatcher.StreamFactory<TOpaque>
-): Promise<Dispatcher.StreamData<TOpaque>>
+  options: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions, 'origin' | 'path'>,
+  factory: Dispatcher.StreamFactory
+): Promise<Dispatcher.StreamData>;
 
 /** For easy use with `stream.pipeline`. */
-declare function pipeline<TOpaque = null> (
+declare function pipeline(
   url: string | URL | UrlObject,
-  options: { dispatcher?: Dispatcher } & Omit<Dispatcher.PipelineOptions<TOpaque>, 'origin' | 'path'>,
-  handler: Dispatcher.PipelineHandler<TOpaque>
-): Duplex
+  options: { dispatcher?: Dispatcher } & Omit<Dispatcher.PipelineOptions, 'origin' | 'path'>,
+  handler: Dispatcher.PipelineHandler
+): Duplex;
 
 /** Starts two-way communications with the requested resource. */
-declare function connect<TOpaque = null> (
+declare function connect(
   url: string | URL | UrlObject,
-  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.ConnectOptions<TOpaque>, 'origin' | 'path'>
-): Promise<Dispatcher.ConnectData<TOpaque>>
+  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.ConnectOptions, 'origin' | 'path'>
+): Promise<Dispatcher.ConnectData>;
 
 /** Upgrade to a different protocol. */
-declare function upgrade (
+declare function upgrade(
   url: string | URL | UrlObject,
   options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.UpgradeOptions, 'origin' | 'path'>
-): Promise<Dispatcher.UpgradeData>
-
-export {
-  request,
-  stream,
-  pipeline,
-  connect,
-  upgrade
-}
+): Promise<Dispatcher.UpgradeData>;

package/node_modules/undici-types/balanced-pool.d.ts

@@ -1,30 +1,29 @@
 import Pool from './pool'
 import Dispatcher from './dispatcher'
-import { URL } from 'node:url'
+import { URL } from 'url'
 
 export default BalancedPool
 
-type BalancedPoolConnectOptions = Omit<Dispatcher.ConnectOptions, 'origin'>
+type BalancedPoolConnectOptions = Omit<Dispatcher.ConnectOptions, "origin">;
 
 declare class BalancedPool extends Dispatcher {
-  constructor (url: string | string[] | URL | URL[], options?: Pool.Options)
+  constructor(url: string | string[] | URL | URL[], options?: Pool.Options);
 
-  addUpstream (upstream: string | URL): BalancedPool
-  removeUpstream (upstream: string | URL): BalancedPool
-  getUpstream (upstream: string | URL): Pool | undefined
-  upstreams: Array<string>
+  addUpstream(upstream: string | URL): BalancedPool;
+  removeUpstream(upstream: string | URL): BalancedPool;
+  upstreams: Array<string>;
 
   /** `true` after `pool.close()` has been called. */
-  closed: boolean
+  closed: boolean;
   /** `true` after `pool.destroyed()` has been called or `pool.close()` has been called and the pool shutdown has completed. */
-  destroyed: boolean
+  destroyed: boolean;
 
   // Override dispatcher APIs.
-  override connect (
+  override connect(
     options: BalancedPoolConnectOptions
-  ): Promise<Dispatcher.ConnectData>
-  override connect (
+  ): Promise<Dispatcher.ConnectData>;
+  override connect(
     options: BalancedPoolConnectOptions,
     callback: (err: Error | null, data: Dispatcher.ConnectData) => void
-  ): void
+  ): void;
 }

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

@@ -1,32 +1,30 @@
-import { URL } from 'node:url'
+import { URL } from 'url'
+import { TlsOptions } from 'tls'
 import Dispatcher from './dispatcher'
-import buildConnector from './connector'
-import TClientStats from './client-stats'
+import buildConnector from "./connector";
 
-type ClientConnectOptions = Omit<Dispatcher.ConnectOptions, 'origin'>
+type ClientConnectOptions = Omit<Dispatcher.ConnectOptions, "origin">;
 
 /**
  * A basic HTTP/1.1 client, mapped on top a single TCP/TLS connection. Pipelining is disabled by default.
  */
 export class Client extends Dispatcher {
-  constructor (url: string | URL, options?: Client.Options)
+  constructor(url: string | URL, options?: Client.Options);
   /** Property to get and set the pipelining factor. */
-  pipelining: number
+  pipelining: number;
   /** `true` after `client.close()` has been called. */
-  closed: boolean
+  closed: boolean;
   /** `true` after `client.destroyed()` has been called or `client.close()` has been called and the client shutdown has completed. */
-  destroyed: boolean
-  /** Aggregate stats for a Client. */
-  readonly stats: TClientStats
+  destroyed: boolean;
 
   // Override dispatcher APIs.
-  override connect (
+  override connect(
     options: ClientConnectOptions
-  ): Promise<Dispatcher.ConnectData>
-  override connect (
+  ): Promise<Dispatcher.ConnectData>;
+  override connect(
     options: ClientConnectOptions,
     callback: (err: Error | null, data: Dispatcher.ConnectData) => void
-  ): void
+  ): void;
 }
 
 export declare namespace Client {
@@ -71,7 +69,9 @@ export declare namespace Client {
     /** TODO */
     maxCachedSessions?: number;
     /** TODO */
-    connect?: Partial<buildConnector.BuildOptions> | buildConnector.connector;
+    maxRedirections?: number;
+    /** TODO */
+    connect?: buildConnector.BuildOptions | buildConnector.connector;
     /** TODO */
     maxRequestsPerClient?: number;
     /** TODO */
@@ -85,13 +85,13 @@ export declare namespace Client {
     /**
      * @description Enables support for H2 if the server has assigned bigger priority to it through ALPN negotiation.
      * @default false
-     */
+    */
     allowH2?: boolean;
     /**
      * @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;
+    */
+    maxConcurrentStreams?: number
   }
   export interface SocketInfo {
     localAddress?: string
@@ -105,4 +105,4 @@ export declare namespace Client {
   }
 }
 
-export default Client
+export default Client;

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

@@ -1,5 +1,5 @@
-import { TLSSocket, ConnectionOptions } from 'node:tls'
-import { IpcNetConnectOpts, Socket, TcpNetConnectOpts } from 'node:net'
+import { TLSSocket, ConnectionOptions } from 'tls'
+import { IpcNetConnectOpts, Socket, TcpNetConnectOpts } from 'net'
 
 export default buildConnector
 declare function buildConnector (options?: buildConnector.BuildOptions): buildConnector.connector

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

@@ -26,5 +26,3 @@ export function getCookies (headers: Headers): Record<string, string>
 export function getSetCookies (headers: Headers): Cookie[]
 
 export function setCookie (headers: Headers, cookie: Cookie): void
-
-export function parseCookie (cookie: string): Cookie | null

package/node_modules/undici-types/diagnostics-channel.d.ts

@@ -1,7 +1,7 @@
-import { Socket } from 'node:net'
-import { URL } from 'node:url'
-import buildConnector from './connector'
-import Dispatcher from './dispatcher'
+import { Socket } from "net";
+import { URL } from "url";
+import Connector from "./connector";
+import Dispatcher from "./dispatcher";
 
 declare namespace DiagnosticsChannel {
   interface Request {
@@ -16,29 +16,21 @@ declare namespace DiagnosticsChannel {
     statusText: string;
     headers: Array<Buffer>;
   }
+  type Error = unknown;
   interface ConnectParams {
-    host: URL['host'];
-    hostname: URL['hostname'];
-    protocol: URL['protocol'];
-    port: URL['port'];
+    host: URL["host"];
+    hostname: URL["hostname"];
+    protocol: URL["protocol"];
+    port: URL["port"];
     servername: string | null;
   }
-  type Connector = buildConnector.connector
+  type Connector = Connector.connector;
   export interface RequestCreateMessage {
     request: Request;
   }
   export interface RequestBodySentMessage {
     request: Request;
   }
-
-  export interface RequestBodyChunkSentMessage {
-    request: Request;
-    chunk: Uint8Array | string;
-  }
-  export interface RequestBodyChunkReceivedMessage {
-    request: Request;
-    chunk: Buffer;
-  }
   export interface RequestHeadersMessage {
     request: Request;
     response: Response;