leduo-patrol 2.2.1 → 2.2.4

package/vendor/claude-code-acp/node_modules/undici-types/retry-handler.d.ts

@@ -0,0 +1,125 @@
+import Dispatcher from './dispatcher'
+
+export default RetryHandler
+
+declare class RetryHandler implements Dispatcher.DispatchHandler {
+  constructor (
+    options: Dispatcher.DispatchOptions & {
+      retryOptions?: RetryHandler.RetryOptions;
+    },
+    retryHandlers: RetryHandler.RetryHandlers
+  )
+}
+
+declare namespace RetryHandler {
+  export type RetryState = { counter: number; }
+
+  export type RetryContext = {
+    state: RetryState;
+    opts: Dispatcher.DispatchOptions & {
+      retryOptions?: RetryHandler.RetryOptions;
+    };
+  }
+
+  export type OnRetryCallback = (result?: Error | null) => void
+
+  export type RetryCallback = (
+    err: Error,
+    context: {
+      state: RetryState;
+      opts: Dispatcher.DispatchOptions & {
+        retryOptions?: RetryHandler.RetryOptions;
+      };
+    },
+    callback: OnRetryCallback
+  ) => void
+
+  export interface RetryOptions {
+    /**
+     * If true, the retry handler will throw an error if the request fails,
+     * this will prevent the folling handlers from being called, and will destroy the socket.
+     *
+     * @type {boolean}
+     * @memberof RetryOptions
+     * @default true
+     */
+    throwOnError?: boolean;
+    /**
+     * Callback to be invoked on every retry iteration.
+     * It receives the error, current state of the retry object and the options object
+     * passed when instantiating the retry handler.
+     *
+     * @type {RetryCallback}
+     * @memberof RetryOptions
+     */
+    retry?: RetryCallback;
+    /**
+     * Maximum number of retries to allow.
+     *
+     * @type {number}
+     * @memberof RetryOptions
+     * @default 5
+     */
+    maxRetries?: number;
+    /**
+     * Max number of milliseconds allow between retries
+     *
+     * @type {number}
+     * @memberof RetryOptions
+     * @default 30000
+     */
+    maxTimeout?: number;
+    /**
+     * Initial number of milliseconds to wait before retrying for the first time.
+     *
+     * @type {number}
+     * @memberof RetryOptions
+     * @default 500
+     */
+    minTimeout?: number;
+    /**
+     * Factior to multiply the timeout factor between retries.
+     *
+     * @type {number}
+     * @memberof RetryOptions
+     * @default 2
+     */
+    timeoutFactor?: number;
+    /**
+     * It enables to automatically infer timeout between retries based on the `Retry-After` header.
+     *
+     * @type {boolean}
+     * @memberof RetryOptions
+     * @default true
+     */
+    retryAfter?: boolean;
+    /**
+     * HTTP methods to retry.
+     *
+     * @type {Dispatcher.HttpMethod[]}
+     * @memberof RetryOptions
+     * @default ['GET', 'HEAD', 'OPTIONS', 'PUT', 'DELETE', 'TRACE'],
+     */
+    methods?: Dispatcher.HttpMethod[];
+    /**
+     * Error codes to be retried. e.g. `ECONNRESET`, `ENOTFOUND`, `ETIMEDOUT`, `ECONNREFUSED`, etc.
+     *
+     * @type {string[]}
+     * @default ['ECONNRESET','ECONNREFUSED','ENOTFOUND','ENETDOWN','ENETUNREACH','EHOSTDOWN','EHOSTUNREACH','EPIPE']
+     */
+    errorCodes?: string[];
+    /**
+     * HTTP status codes to be retried.
+     *
+     * @type {number[]}
+     * @memberof RetryOptions
+     * @default [500, 502, 503, 504, 429],
+     */
+    statusCodes?: number[];
+  }
+
+  export interface RetryHandlers {
+    dispatch: Dispatcher['dispatch'];
+    handler: Dispatcher.DispatchHandler;
+  }
+}

package/vendor/claude-code-acp/node_modules/undici-types/snapshot-agent.d.ts

@@ -0,0 +1,109 @@
+import MockAgent from './mock-agent'
+
+declare class SnapshotRecorder {
+  constructor (options?: SnapshotRecorder.Options)
+
+  record (requestOpts: any, response: any): Promise<void>
+  findSnapshot (requestOpts: any): SnapshotRecorder.Snapshot | undefined
+  loadSnapshots (filePath?: string): Promise<void>
+  saveSnapshots (filePath?: string): Promise<void>
+  clear (): void
+  getSnapshots (): SnapshotRecorder.Snapshot[]
+  size (): number
+  resetCallCounts (): void
+  deleteSnapshot (requestOpts: any): boolean
+  getSnapshotInfo (requestOpts: any): SnapshotRecorder.SnapshotInfo | null
+  replaceSnapshots (snapshotData: SnapshotRecorder.SnapshotData[]): void
+  destroy (): void
+}
+
+declare namespace SnapshotRecorder {
+  type SnapshotRecorderMode = 'record' | 'playback' | 'update'
+
+  export interface Options {
+    snapshotPath?: string
+    mode?: SnapshotRecorderMode
+    maxSnapshots?: number
+    autoFlush?: boolean
+    flushInterval?: number
+    matchHeaders?: string[]
+    ignoreHeaders?: string[]
+    excludeHeaders?: string[]
+    matchBody?: boolean
+    matchQuery?: boolean
+    caseSensitive?: boolean
+    shouldRecord?: (requestOpts: any) => boolean
+    shouldPlayback?: (requestOpts: any) => boolean
+    excludeUrls?: (string | RegExp)[]
+  }
+
+  export interface Snapshot {
+    request: {
+      method: string
+      url: string
+      headers: Record<string, string>
+      body?: string
+    }
+    responses: {
+      statusCode: number
+      headers: Record<string, string>
+      body: string
+      trailers: Record<string, string>
+    }[]
+    callCount: number
+    timestamp: string
+  }
+
+  export interface SnapshotInfo {
+    hash: string
+    request: {
+      method: string
+      url: string
+      headers: Record<string, string>
+      body?: string
+    }
+    responseCount: number
+    callCount: number
+    timestamp: string
+  }
+
+  export interface SnapshotData {
+    hash: string
+    snapshot: Snapshot
+  }
+}
+
+declare class SnapshotAgent extends MockAgent {
+  constructor (options?: SnapshotAgent.Options)
+
+  saveSnapshots (filePath?: string): Promise<void>
+  loadSnapshots (filePath?: string): Promise<void>
+  getRecorder (): SnapshotRecorder
+  getMode (): SnapshotRecorder.SnapshotRecorderMode
+  clearSnapshots (): void
+  resetCallCounts (): void
+  deleteSnapshot (requestOpts: any): boolean
+  getSnapshotInfo (requestOpts: any): SnapshotRecorder.SnapshotInfo | null
+  replaceSnapshots (snapshotData: SnapshotRecorder.SnapshotData[]): void
+}
+
+declare namespace SnapshotAgent {
+  export interface Options extends MockAgent.Options {
+    mode?: SnapshotRecorder.SnapshotRecorderMode
+    snapshotPath?: string
+    maxSnapshots?: number
+    autoFlush?: boolean
+    flushInterval?: number
+    matchHeaders?: string[]
+    ignoreHeaders?: string[]
+    excludeHeaders?: string[]
+    matchBody?: boolean
+    matchQuery?: boolean
+    caseSensitive?: boolean
+    shouldRecord?: (requestOpts: any) => boolean
+    shouldPlayback?: (requestOpts: any) => boolean
+    excludeUrls?: (string | RegExp)[]
+  }
+}
+
+export { SnapshotAgent, SnapshotRecorder }

package/vendor/claude-code-acp/node_modules/undici-types/util.d.ts

@@ -0,0 +1,18 @@
+export namespace util {
+  /**
+   * Retrieves a header name and returns its lowercase value.
+   * @param value Header name
+   */
+  export function headerNameToString (value: string | Buffer): string
+
+  /**
+   * Receives a header object and returns the parsed value.
+   * @param headers Header object
+   * @param obj Object to specify a proxy object. Used to assign parsed values.
+   * @returns If `obj` is specified, it is equivalent to `obj`.
+   */
+  export function parseHeaders (
+    headers: (Buffer | string | (Buffer | string)[])[],
+    obj?: Record<string, string | string[]>
+  ): Record<string, string | string[]>
+}

package/vendor/claude-code-acp/node_modules/undici-types/utility.d.ts

@@ -0,0 +1,7 @@
+type AutocompletePrimitiveBaseType<T> =
+  T extends string ? string :
+    T extends number ? number :
+      T extends boolean ? boolean :
+        never
+
+export type Autocomplete<T> = T | (AutocompletePrimitiveBaseType<T> & Record<never, never>)

package/vendor/claude-code-acp/node_modules/undici-types/webidl.d.ts

@@ -0,0 +1,341 @@
+// These types are not exported, and are only used internally
+import * as undici from './index'
+
+/**
+ * Take in an unknown value and return one that is of type T
+ */
+type Converter<T> = (object: unknown) => T
+
+type SequenceConverter<T> = (object: unknown, iterable?: IterableIterator<T>) => T[]
+
+type RecordConverter<K extends string, V> = (object: unknown) => Record<K, V>
+
+interface WebidlErrors {
+  /**
+   * @description Instantiate an error
+   */
+  exception (opts: { header: string, message: string }): TypeError
+  /**
+   * @description Instantiate an error when conversion from one type to another has failed
+   */
+  conversionFailed (opts: {
+    prefix: string
+    argument: string
+    types: string[]
+  }): TypeError
+  /**
+   * @description Throw an error when an invalid argument is provided
+   */
+  invalidArgument (opts: {
+    prefix: string
+    value: string
+    type: string
+  }): TypeError
+}
+
+interface WebIDLTypes {
+  UNDEFINED: 1,
+  BOOLEAN: 2,
+  STRING: 3,
+  SYMBOL: 4,
+  NUMBER: 5,
+  BIGINT: 6,
+  NULL: 7
+  OBJECT: 8
+}
+
+interface WebidlUtil {
+  /**
+   * @see https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values
+   */
+  Type (object: unknown): WebIDLTypes[keyof WebIDLTypes]
+
+  TypeValueToString (o: unknown):
+    | 'Undefined'
+    | 'Boolean'
+    | 'String'
+    | 'Symbol'
+    | 'Number'
+    | 'BigInt'
+    | 'Null'
+    | 'Object'
+
+  Types: WebIDLTypes
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
+   */
+  ConvertToInt (
+    V: unknown,
+    bitLength: number,
+    signedness: 'signed' | 'unsigned',
+    flags?: number
+  ): number
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#abstract-opdef-integerpart
+   */
+  IntegerPart (N: number): number
+
+  /**
+   * Stringifies {@param V}
+   */
+  Stringify (V: any): string
+
+  MakeTypeAssertion <I>(I: I): (arg: any) => arg is I
+
+  /**
+   * Mark a value as uncloneable for Node.js.
+   * This is only effective in some newer Node.js versions.
+   */
+  markAsUncloneable (V: any): void
+
+  IsResizableArrayBuffer (V: ArrayBufferLike): boolean
+
+  HasFlag (flag: number, attributes: number): boolean
+}
+
+interface WebidlConverters {
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-DOMString
+   */
+  DOMString (V: unknown, prefix: string, argument: string, flags?: number): string
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-ByteString
+   */
+  ByteString (V: unknown, prefix: string, argument: string): string
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-USVString
+   */
+  USVString (V: unknown): string
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-boolean
+   */
+  boolean (V: unknown): boolean
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-any
+   */
+  any <Value>(V: Value): Value
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-long-long
+   */
+  ['long long'] (V: unknown): number
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-unsigned-long-long
+   */
+  ['unsigned long long'] (V: unknown): number
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-unsigned-long
+   */
+  ['unsigned long'] (V: unknown): number
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-unsigned-short
+   */
+  ['unsigned short'] (V: unknown, flags?: number): number
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#idl-ArrayBuffer
+   */
+  ArrayBuffer (
+    V: unknown,
+    prefix: string,
+    argument: string,
+    options?: { allowResizable: boolean }
+  ): ArrayBuffer
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#idl-SharedArrayBuffer
+   */
+  SharedArrayBuffer (
+    V: unknown,
+    prefix: string,
+    argument: string,
+    options?: { allowResizable: boolean }
+  ): SharedArrayBuffer
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-buffer-source-types
+   */
+  TypedArray (
+    V: unknown,
+    T: new () => NodeJS.TypedArray,
+    prefix: string,
+    argument: string,
+    flags?: number
+  ): NodeJS.TypedArray
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-buffer-source-types
+   */
+  DataView (
+    V: unknown,
+    prefix: string,
+    argument: string,
+    flags?: number
+  ): DataView
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-buffer-source-types
+   */
+  ArrayBufferView (
+    V: unknown,
+    prefix: string,
+    argument: string,
+    flags?: number
+  ): NodeJS.ArrayBufferView
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#BufferSource
+   */
+  BufferSource (
+    V: unknown,
+    prefix: string,
+    argument: string,
+    flags?: number
+  ): ArrayBuffer | NodeJS.ArrayBufferView
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#AllowSharedBufferSource
+   */
+  AllowSharedBufferSource (
+    V: unknown,
+    prefix: string,
+    argument: string,
+    flags?: number
+  ): ArrayBuffer | SharedArrayBuffer | NodeJS.ArrayBufferView
+
+  ['sequence<ByteString>']: SequenceConverter<string>
+
+  ['sequence<sequence<ByteString>>']: SequenceConverter<string[]>
+
+  ['record<ByteString, ByteString>']: RecordConverter<string, string>
+
+  /**
+  * @see https://fetch.spec.whatwg.org/#requestinfo
+  */
+  RequestInfo (V: unknown): undici.Request | string
+
+  /**
+   * @see https://fetch.spec.whatwg.org/#requestinit
+   */
+  RequestInit (V: unknown): undici.RequestInit
+
+  /**
+   * @see https://html.spec.whatwg.org/multipage/webappapis.html#eventhandlernonnull
+   */
+  EventHandlerNonNull (V: unknown): Function | null
+
+  WebSocketStreamWrite (V: unknown): ArrayBuffer | NodeJS.TypedArray | string
+
+  [Key: string]: (...args: any[]) => unknown
+}
+
+type WebidlIsFunction<T> = (arg: any) => arg is T
+
+interface WebidlIs {
+  Request: WebidlIsFunction<undici.Request>
+  Response: WebidlIsFunction<undici.Response>
+  ReadableStream: WebidlIsFunction<ReadableStream>
+  Blob: WebidlIsFunction<Blob>
+  URLSearchParams: WebidlIsFunction<URLSearchParams>
+  File: WebidlIsFunction<File>
+  FormData: WebidlIsFunction<undici.FormData>
+  URL: WebidlIsFunction<URL>
+  WebSocketError: WebidlIsFunction<undici.WebSocketError>
+  AbortSignal: WebidlIsFunction<AbortSignal>
+  MessagePort: WebidlIsFunction<MessagePort>
+  USVString: WebidlIsFunction<string>
+  /**
+   * @see https://webidl.spec.whatwg.org/#BufferSource
+   */
+  BufferSource: WebidlIsFunction<ArrayBuffer | NodeJS.TypedArray>
+}
+
+export interface Webidl {
+  errors: WebidlErrors
+  util: WebidlUtil
+  converters: WebidlConverters
+  is: WebidlIs
+  attributes: WebIDLExtendedAttributes
+
+  /**
+   * @description Performs a brand-check on {@param V} to ensure it is a
+   * {@param cls} object.
+   */
+  brandCheck <Interface extends new () => unknown>(V: unknown, cls: Interface): asserts V is Interface
+
+  brandCheckMultiple <Interfaces extends (new () => unknown)[]> (list: Interfaces): (V: any) => asserts V is Interfaces[number]
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-sequence
+   * @description Convert a value, V, to a WebIDL sequence type.
+   */
+  sequenceConverter <Type>(C: Converter<Type>): SequenceConverter<Type>
+
+  illegalConstructor (): never
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#es-to-record
+   * @description Convert a value, V, to a WebIDL record type.
+   */
+  recordConverter <K extends string, V>(
+    keyConverter: Converter<K>,
+    valueConverter: Converter<V>
+  ): RecordConverter<K, V>
+
+  /**
+   * Similar to {@link Webidl.brandCheck} but allows skipping the check if third party
+   * interfaces are allowed.
+   */
+  interfaceConverter <Interface>(typeCheck: WebidlIsFunction<Interface>, name: string): (
+    V: unknown,
+    prefix: string,
+    argument: string
+  ) => asserts V is Interface
+
+  // TODO(@KhafraDev): a type could likely be implemented that can infer the return type
+  // from the converters given?
+  /**
+   * Converts a value, V, to a WebIDL dictionary types. Allows limiting which keys are
+   * allowed, values allowed, optional and required keys. Auto converts the value to
+   * a type given a converter.
+   */
+  dictionaryConverter (converters: {
+    key: string,
+    defaultValue?: () => unknown,
+    required?: boolean,
+    converter: (...args: unknown[]) => unknown,
+    allowedValues?: unknown[]
+  }[]): (V: unknown) => Record<string, unknown>
+
+  /**
+   * @see https://webidl.spec.whatwg.org/#idl-nullable-type
+   * @description allows a type, V, to be null
+   */
+  nullableConverter <T>(
+    converter: Converter<T>
+  ): (V: unknown) => ReturnType<typeof converter> | null
+
+  argumentLengthCheck (args: { length: number }, min: number, context: string): void
+}
+
+interface WebIDLExtendedAttributes {
+  /** https://webidl.spec.whatwg.org/#Clamp */
+  Clamp: number
+  /** https://webidl.spec.whatwg.org/#EnforceRange */
+  EnforceRange: number
+  /** https://webidl.spec.whatwg.org/#AllowShared */
+  AllowShared: number
+  /** https://webidl.spec.whatwg.org/#AllowResizable */
+  AllowResizable: number
+  /** https://webidl.spec.whatwg.org/#LegacyNullToEmptyString */
+  LegacyNullToEmptyString: number
+}