@hasna/connectors 1.3.0 → 1.3.2

package/connectors/connect-yousign/node_modules/bun-types/bun.ns.d.ts

@@ -0,0 +1,5 @@
+import * as BunModule from "bun";
+
+declare global {
+  export import Bun = BunModule;
+}

package/connectors/connect-yousign/node_modules/bun-types/bundle.d.ts

@@ -0,0 +1,74 @@
+/**
+ * The `bun:bundle` module provides compile-time utilities for dead-code elimination.
+ *
+ * @example
+ * ```ts
+ * import { feature } from "bun:bundle";
+ *
+ * if (feature("SUPER_SECRET")) {
+ *   console.log("Secret feature enabled!");
+ * } else {
+ *   console.log("Normal mode");
+ * }
+ * ```
+ *
+ * Enable feature flags via CLI:
+ * ```bash
+ * # During build
+ * bun build --feature=SUPER_SECRET index.ts
+ *
+ * # At runtime
+ * bun run --feature=SUPER_SECRET index.ts
+ *
+ * # In tests
+ * bun test --feature=SUPER_SECRET
+ * ```
+ *
+ * @module bun:bundle
+ */
+declare module "bun:bundle" {
+  /**
+   * Registry for type-safe feature flags.
+   *
+   * Augment this interface to get autocomplete and type checking for your feature flags:
+   *
+   * @example
+   * ```ts
+   * // env.d.ts
+   * declare module "bun:bundle" {
+   *   interface Registry {
+   *     features: "DEBUG" | "PREMIUM" | "BETA";
+   *   }
+   * }
+   * ```
+   *
+   * Now `feature()` only accepts `"DEBUG"`, `"PREMIUM"`, or `"BETA"`:
+   * ```ts
+   * feature("DEBUG");    // OK
+   * feature("TYPO");     // Type error
+   * ```
+   */
+  interface Registry {}
+
+  /**
+   * Check if a feature flag is enabled at compile time.
+   *
+   * This function is replaced with a boolean literal (`true` or `false`) at bundle time,
+   * enabling dead-code elimination. The bundler will remove unreachable branches.
+   *
+   * @param flag - The name of the feature flag to check
+   * @returns `true` if the flag was passed via `--feature=FLAG`, `false` otherwise
+   *
+   * @example
+   * ```ts
+   * import { feature } from "bun:bundle";
+   *
+   * // With --feature=DEBUG, this becomes: if (true) { ... }
+   * // Without --feature=DEBUG, this becomes: if (false) { ... }
+   * if (feature("DEBUG")) {
+   *   console.log("Debug mode enabled");
+   * }
+   * ```
+   */
+  function feature(flag: Registry extends { features: infer Features extends string } ? Features : string): boolean;
+}

package/connectors/connect-yousign/node_modules/bun-types/deprecated.d.ts

@@ -0,0 +1,184 @@
+declare module "bun" {
+  /** @deprecated This type is unused in Bun's types and might be removed in the near future */
+  type Platform =
+    | "aix"
+    | "android"
+    | "darwin"
+    | "freebsd"
+    | "haiku"
+    | "linux"
+    | "openbsd"
+    | "sunos"
+    | "win32"
+    | "cygwin"
+    | "netbsd";
+
+  /** @deprecated This type is unused in Bun's types and might be removed in the near future */
+  type Architecture = "arm" | "arm64" | "ia32" | "mips" | "mipsel" | "ppc" | "ppc64" | "s390" | "s390x" | "x64";
+
+  /** @deprecated This type is unused in Bun's types and might be removed in the near future */
+  type UncaughtExceptionListener = (error: Error, origin: UncaughtExceptionOrigin) => void;
+
+  /**
+   * Most of the time the unhandledRejection will be an Error, but this should not be relied upon
+   * as *anything* can be thrown/rejected, it is therefore unsafe to assume that the value is an Error.
+   *
+   * @deprecated This type is unused in Bun's types and might be removed in the near future
+   */
+  type UnhandledRejectionListener = (reason: unknown, promise: Promise<unknown>) => void;
+
+  /** @deprecated This type is unused in Bun's types and might be removed in the near future */
+  type MultipleResolveListener = (type: MultipleResolveType, promise: Promise<unknown>, value: unknown) => void;
+
+  /**
+   * Consume all data from a {@link ReadableStream} until it closes or errors.
+   *
+   * Concatenate the chunks into a single {@link ArrayBuffer}.
+   *
+   * Each chunk must be a TypedArray or an ArrayBuffer. If you need to support
+   * chunks of different types, consider {@link readableStreamToBlob}
+   *
+   * @param stream The stream to consume.
+   * @returns A promise that resolves with the concatenated chunks or the concatenated chunks as a {@link Uint8Array}.
+   *
+   * @deprecated Use {@link ReadableStream.bytes}
+   */
+  function readableStreamToBytes(
+    stream: ReadableStream<ArrayBufferView | ArrayBufferLike>,
+  ): Promise<Uint8Array<ArrayBuffer>> | Uint8Array<ArrayBuffer>;
+
+  /**
+   * Consume all data from a {@link ReadableStream} until it closes or errors.
+   *
+   * Concatenate the chunks into a single {@link Blob}.
+   *
+   * @param stream The stream to consume.
+   * @returns A promise that resolves with the concatenated chunks as a {@link Blob}.
+   *
+   * @deprecated Use {@link ReadableStream.blob}
+   */
+  function readableStreamToBlob(stream: ReadableStream): Promise<Blob>;
+
+  /**
+   * Consume all data from a {@link ReadableStream} until it closes or errors.
+   *
+   * Concatenate the chunks into a single string. Chunks must be a TypedArray or an ArrayBuffer. If you need to support chunks of different types, consider {@link readableStreamToBlob}.
+   *
+   * @param stream The stream to consume.
+   * @returns A promise that resolves with the concatenated chunks as a {@link String}.
+   *
+   * @deprecated Use {@link ReadableStream.text}
+   */
+  function readableStreamToText(stream: ReadableStream): Promise<string>;
+
+  /**
+   * Consume all data from a {@link ReadableStream} until it closes or errors.
+   *
+   * Concatenate the chunks into a single string and parse as JSON. Chunks must be a TypedArray or an ArrayBuffer. If you need to support chunks of different types, consider {@link readableStreamToBlob}.
+   *
+   * @param stream The stream to consume.
+   * @returns A promise that resolves with the concatenated chunks as a {@link String}.
+   *
+   * @deprecated Use {@link ReadableStream.json}
+   */
+  function readableStreamToJSON(stream: ReadableStream): Promise<any>;
+
+  interface BunMessageEvent<T> {
+    /**
+     * @deprecated
+     */
+    initMessageEvent(
+      type: string,
+      bubbles?: boolean,
+      cancelable?: boolean,
+      data?: any,
+      origin?: string,
+      lastEventId?: string,
+      source?: null,
+    ): void;
+  }
+
+  /**
+   * @deprecated Use {@link Serve.Options Bun.Serve.Options<T, R>} instead
+   */
+  type ServeOptions<T = undefined, R extends string = never> = Serve.Options<T, R>;
+
+  /** @deprecated Use {@link SQL.Query Bun.SQL.Query} */
+  type SQLQuery<T = any> = SQL.Query<T>;
+
+  /** @deprecated Use {@link SQL.TransactionContextCallback Bun.SQL.TransactionContextCallback} */
+  type SQLTransactionContextCallback<T> = SQL.TransactionContextCallback<T>;
+
+  /** @deprecated Use {@link SQL.SavepointContextCallback Bun.SQL.SavepointContextCallback} */
+  type SQLSavepointContextCallback<T> = SQL.SavepointContextCallback<T>;
+
+  /** @deprecated Use {@link SQL.Options Bun.SQL.Options} */
+  type SQLOptions = SQL.Options;
+
+  /**
+   * @deprecated Renamed to `ErrorLike`
+   */
+  type Errorlike = ErrorLike;
+
+  /** @deprecated This is unused in Bun's types and may be removed in the future */
+  type ShellFunction = (input: Uint8Array<ArrayBuffer>) => Uint8Array<ArrayBuffer>;
+
+  interface TLSOptions {
+    /**
+     * File path to a TLS key
+     *
+     * To enable TLS, this option is required.
+     *
+     * @deprecated since v0.6.3 - Use `key: Bun.file(path)` instead.
+     */
+    keyFile?: string;
+
+    /**
+     * File path to a TLS certificate
+     *
+     * To enable TLS, this option is required.
+     *
+     * @deprecated since v0.6.3 - Use `cert: Bun.file(path)` instead.
+     */
+    certFile?: string;
+
+    /**
+     *  File path to a .pem file for a custom root CA
+     *
+     * @deprecated since v0.6.3 - Use `ca: Bun.file(path)` instead.
+     */
+    caFile?: string;
+  }
+
+  /** @deprecated This type is unused in Bun's declarations and may be removed in the future */
+  type ReadableIO = ReadableStream<Uint8Array<ArrayBuffer>> | number | undefined;
+}
+
+declare namespace NodeJS {
+  interface Process {
+    /**
+     * @deprecated This is deprecated; use the "node:assert" module instead.
+     */
+    assert(value: unknown, message?: string | Error): asserts value;
+  }
+}
+
+interface CustomEvent<T = any> {
+  /** @deprecated */
+  initCustomEvent(type: string, bubbles?: boolean, cancelable?: boolean, detail?: T): void;
+}
+
+interface DOMException {
+  /** @deprecated */
+  readonly code: number;
+}
+
+/**
+ * @deprecated Renamed to `BuildMessage`
+ */
+declare var BuildError: typeof BuildMessage;
+
+/**
+ * @deprecated Renamed to `ResolveMessage`
+ */
+declare var ResolveError: typeof ResolveMessage;

package/connectors/connect-yousign/node_modules/bun-types/devserver.d.ts

@@ -0,0 +1,187 @@
+declare module "bun" {
+  type HMREventNames =
+    | "beforeUpdate"
+    | "afterUpdate"
+    | "beforeFullReload"
+    | "beforePrune"
+    | "invalidate"
+    | "error"
+    | "ws:disconnect"
+    | "ws:connect";
+
+  /**
+   * The event names for the dev server
+   */
+  type HMREvent = `bun:${HMREventNames}` | (string & {});
+}
+
+interface ImportMeta {
+  /**
+   * Hot module replacement APIs. This value is `undefined` in production and
+   * can be used in an `if` statement to check if HMR APIs are available
+   *
+   * ```ts
+   * if (import.meta.hot) {
+   *   // HMR APIs are available
+   * }
+   * ```
+   *
+   * However, this check is usually not needed as Bun will dead-code-eliminate
+   * calls to all of the HMR APIs in production builds.
+   *
+   * https://bun.com/docs/bundler/hmr
+   */
+  hot: {
+    /**
+     * `import.meta.hot.data` maintains state between module instances during
+     * hot replacement, enabling data transfer from previous to new versions.
+     * When `import.meta.hot.data` is written to, Bun will mark this module as
+     * capable of self-accepting (equivalent of calling `accept()`).
+     *
+     * @example
+     * ```ts
+     * const root = import.meta.hot.data.root ??= createRoot(elem);
+     * root.render(<App />); // re-use an existing root
+     * ```
+     *
+     * In production, `data` is inlined to be `{}`. This is handy because Bun
+     * knows it can minify `{}.prop ??= value` into `value` in production.
+     */
+    data: any;
+
+    /**
+     * Indicate that this module can be replaced simply by re-evaluating the
+     * file. After a hot update, importers of this module will be
+     * automatically patched.
+     *
+     * When `import.meta.hot.accept` is not used, the page will reload when
+     * the file updates, and a console message shows which files were checked.
+     *
+     * @example
+     * ```ts
+     * import { getCount } from "./foo";
+     *
+     * console.log("count is ", getCount());
+     *
+     * import.meta.hot.accept();
+     * ```
+     */
+    accept(): void;
+
+    /**
+     * Indicate that this module can be replaced by evaluating the new module,
+     * and then calling the callback with the new module. In this mode, the
+     * importers do not get patched. This is to match Vite, which is unable
+     * to patch their import statements. Prefer using `import.meta.hot.accept()`
+     * without an argument as it usually makes your code easier to understand.
+     *
+     * When `import.meta.hot.accept` is not used, the page will reload when
+     * the file updates, and a console message shows which files were checked.
+     *
+     * @example
+     * ```ts
+     * export const count = 0;
+     *
+     * import.meta.hot.accept((newModule) => {
+     *   if (newModule) {
+     *     // newModule is undefined when SyntaxError happened
+     *     console.log('updated: count is now ', newModule.count)
+     *   }
+     * });
+     * ```
+     *
+     * In production, calls to this are dead-code-eliminated.
+     */
+    accept(cb: (newModule: any | undefined) => void): void;
+
+    /**
+     * Indicate that a dependency's module can be accepted. When the dependency
+     * is updated, the callback will be called with the new module.
+     *
+     * When `import.meta.hot.accept` is not used, the page will reload when
+     * the file updates, and a console message shows which files were checked.
+     *
+     * @example
+     * ```ts
+     * import.meta.hot.accept('./foo', (newModule) => {
+     *   if (newModule) {
+     *     // newModule is undefined when SyntaxError happened
+     *     console.log('updated: count is now ', newModule.count)
+     *   }
+     * });
+     * ```
+     */
+    accept(specifier: string, callback: (newModule: any) => void): void;
+
+    /**
+     * Indicate that a dependency's module can be accepted. This variant
+     * accepts an array of dependencies, where the callback will receive
+     * the one updated module, and `undefined` for the rest.
+     *
+     * When `import.meta.hot.accept` is not used, the page will reload when
+     * the file updates, and a console message shows which files were checked.
+     */
+    accept(specifiers: string[], callback: (newModules: (any | undefined)[]) => void): void;
+
+    /**
+     * Attach an on-dispose callback. This is called:
+     * - Just before the module is replaced with another copy (before the next is loaded)
+     * - After the module is detached (removing all imports to this module)
+     *
+     * This callback is not called on route navigation or when the browser tab closes.
+     *
+     * Returning a promise will delay module replacement until the module is
+     * disposed. All dispose callbacks are called in parallel.
+     */
+    dispose(cb: (data: any) => void | Promise<void>): void;
+
+    /**
+     * No-op
+     * @deprecated
+     */
+    decline(): void;
+
+    // NOTE TO CONTRIBUTORS ////////////////////////////////////////
+    //     Callback is currently never called for `.prune()`      //
+    //     so the types are commented out until we support it.    //
+    ////////////////////////////////////////////////////////////////
+    // /**
+    //  * Attach a callback that is called when the module is removed from the module graph.
+    //  *
+    //  * This can be used to clean up resources that were created when the module was loaded.
+    //  * Unlike `import.meta.hot.dispose()`, this pairs much better with `accept` and `data` to manage stateful resources.
+    //  *
+    //  * @example
+    //  * ```ts
+    //  * export const ws = (import.meta.hot.data.ws ??= new WebSocket(location.origin));
+    //  *
+    //  * import.meta.hot.prune(() => {
+    //  *   ws.close();
+    //  * });
+    //  * ```
+    //  */
+    // prune(callback: () => void): void;
+
+    /**
+     * Listen for an event from the dev server
+     *
+     * For compatibility with Vite, event names are also available via vite:* prefix instead of bun:*.
+     *
+     * https://bun.com/docs/bundler/hmr#import-meta-hot-on-and-off
+     * @param event The event to listen to
+     * @param callback The callback to call when the event is emitted
+     */
+    on(event: Bun.HMREvent, callback: () => void): void;
+
+    /**
+     * Stop listening for an event from the dev server
+     *
+     * For compatibility with Vite, event names are also available via vite:* prefix instead of bun:*.
+     *
+     * https://bun.com/docs/bundler/hmr#import-meta-hot-on-and-off
+     * @param event The event to stop listening to
+     * @param callback The callback to stop listening to
+     */
+    off(event: Bun.HMREvent, callback: () => void): void;
+  };
+}

package/connectors/connect-yousign/node_modules/bun-types/docs/README.md

@@ -0,0 +1,28 @@
+<p align="center">
+  <a href="https://bun.com">
+		<img src="https://github.com/user-attachments/assets/50282090-adfd-4ddb-9e27-c30753c6b161" alt="Logo" height="170" />
+	</a>
+</p>
+<h1 align="center">Bun Documentation</h1>
+
+Official documentation for Bun: the fast, all-in-one JavaScript runtime.
+
+## Development
+
+Install the [Mintlify CLI](https://www.npmjs.com/package/mint) to preview the documentation locally:
+
+```bash
+bun install -g mint
+```
+
+Run the development server:
+
+```bash
+mint dev
+```
+
+The site will be available at `http://localhost:3000`.
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request.