npm - @hasna/connectors - Versions diffs - 1.3.0 → 1.3.2 - Mend

@hasna/connectors 1.3.0 → 1.3.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (708) hide show

package/connectors/connect-yousign/node_modules/bun-types/html-rewriter.d.ts ADDED Viewed

@@ -0,0 +1,186 @@
+declare namespace HTMLRewriterTypes {
+  interface HTMLRewriterElementContentHandlers {
+    element?(element: Element): void | Promise<void>;
+    comments?(comment: Comment): void | Promise<void>;
+    text?(text: Text): void | Promise<void>;
+  }
+  interface HTMLRewriterDocumentContentHandlers {
+    doctype?(doctype: Doctype): void | Promise<void>;
+    comments?(comment: Comment): void | Promise<void>;
+    text?(text: Text): void | Promise<void>;
+    end?(end: DocumentEnd): void | Promise<void>;
+  }
+  interface Text {
+    /** The text content */
+    readonly text: string;
+    /** Whether this chunk is the last piece of text in a text node */
+    readonly lastInTextNode: boolean;
+    /** Whether this chunk was removed */
+    readonly removed: boolean;
+    /** Insert content before this chunk */
+    before(content: Content, options?: ContentOptions): Text;
+    /** Insert content after this chunk */
+    after(content: Content, options?: ContentOptions): Text;
+    /** Replace this chunk with new content */
+    replace(content: Content, options?: ContentOptions): Text;
+    /** Remove this chunk */
+    remove(): Text;
+  }
+  interface Doctype {
+    /** The doctype name (e.g. "html" for <!DOCTYPE html>) */
+    readonly name: string | null;
+    /** The doctype public identifier */
+    readonly publicId: string | null;
+    /** The doctype system identifier */
+    readonly systemId: string | null;
+    /** Whether this doctype was removed */
+    readonly removed: boolean;
+    /** Remove this doctype */
+    remove(): Doctype;
+  }
+  interface DocumentEnd {
+    /** Append content at the end of the document */
+    append(content: Content, options?: ContentOptions): DocumentEnd;
+  }
+  interface ContentOptions {
+    /** Whether to parse the content as HTML */
+    html?: boolean;
+  }
+  type Content = string;
+  interface Comment {
+    /** The comment text */
+    text: string;
+    /** Whether this comment was removed */
+    readonly removed: boolean;
+    /** Insert content before this comment */
+    before(content: Content, options?: ContentOptions): Comment;
+    /** Insert content after this comment */
+    after(content: Content, options?: ContentOptions): Comment;
+    /** Replace this comment with new content */
+    replace(content: Content, options?: ContentOptions): Comment;
+    /** Remove this comment */
+    remove(): Comment;
+  }
+  interface Element {
+    /** The tag name in lowercase (e.g. "div", "span") */
+    tagName: string;
+    /** Iterator for the element's attributes */
+    readonly attributes: IterableIterator<[string, string]>;
+    /** Whether this element was removed */
+    readonly removed: boolean;
+    /** Whether the element is explicitly self-closing, e.g. <foo /> */
+    readonly selfClosing: boolean;
+    /**
+     * Whether the element can have inner content. Returns `true` unless
+     * - the element is an [HTML void element](https://html.spec.whatwg.org/multipage/syntax.html#void-elements)
+     * - or it's self-closing in a foreign context (eg. in SVG, MathML).
+     */
+    readonly canHaveContent: boolean;
+    /** The element's namespace URI */
+    readonly namespaceURI: string;
+    /** Get an attribute value by name */
+    getAttribute(name: string): string | null;
+    /** Check if an attribute exists */
+    hasAttribute(name: string): boolean;
+    /** Set an attribute value */
+    setAttribute(name: string, value: string): Element;
+    /** Remove an attribute */
+    removeAttribute(name: string): Element;
+    /** Insert content before this element */
+    before(content: Content, options?: ContentOptions): Element;
+    /** Insert content after this element */
+    after(content: Content, options?: ContentOptions): Element;
+    /** Insert content at the start of this element */
+    prepend(content: Content, options?: ContentOptions): Element;
+    /** Insert content at the end of this element */
+    append(content: Content, options?: ContentOptions): Element;
+    /** Replace this element with new content */
+    replace(content: Content, options?: ContentOptions): Element;
+    /** Remove this element and its contents */
+    remove(): Element;
+    /** Remove this element but keep its contents */
+    removeAndKeepContent(): Element;
+    /** Set the inner content of this element */
+    setInnerContent(content: Content, options?: ContentOptions): Element;
+    /** Add a handler for the end tag of this element */
+    onEndTag(handler: (tag: EndTag) => void | Promise<void>): void;
+  }
+  interface EndTag {
+    /** The tag name in lowercase */
+    name: string;
+    /** Insert content before this end tag */
+    before(content: Content, options?: ContentOptions): EndTag;
+    /** Insert content after this end tag */
+    after(content: Content, options?: ContentOptions): EndTag;
+    /** Remove this end tag */
+    remove(): EndTag;
+  }
+}
+/**
+ * [HTMLRewriter](https://developers.cloudflare.com/workers/runtime-apis/html-rewriter?bun) is a fast API for transforming HTML.
+ *
+ * Bun leverages a native implementation powered by [lol-html](https://github.com/cloudflare/lol-html).
+ *
+ * HTMLRewriter can be used to transform HTML in a variety of ways, including:
+ * * Rewriting URLs
+ * * Adding meta tags
+ * * Removing elements
+ * * Adding elements to the head
+ *
+ * @example
+ * ```ts
+ * const rewriter = new HTMLRewriter().on('a[href]', {
+ *   element(element: Element) {
+ *     // Rewrite all the URLs to this youtube video
+ *     element.setAttribute('href', 'https://www.youtube.com/watch?v=dQw4w9WgXcQ');
+ *   }
+ * });
+ * rewriter.transform(await fetch("https://remix.run"));
+ * ```
+ *
+ * @category HTML Manipulation
+ */
+declare class HTMLRewriter {
+  constructor();
+  /**
+   * Add handlers for elements matching a CSS selector
+   * @param selector - A CSS selector (e.g. "div", "a[href]", ".class")
+   * @param handlers - Object containing handler functions for elements, comments, and text nodes
+   */
+  on(selector: string, handlers: HTMLRewriterTypes.HTMLRewriterElementContentHandlers): HTMLRewriter;
+  /**
+   * Add handlers for document-level events
+   * @param handlers - Object containing handler functions for doctype, comments, text nodes and document end
+   */
+  onDocument(handlers: HTMLRewriterTypes.HTMLRewriterDocumentContentHandlers): HTMLRewriter;
+  /**
+   * Transform HTML content
+   * @param input - The HTML to transform
+   * @returns A new {@link Response} with the transformed HTML
+   */
+  transform(input: Response | Blob | Bun.BufferSource): Response;
+  /**
+   * Transform HTML content
+   * @param input - The HTML string to transform
+   * @returns A new {@link String} containing the transformed HTML
+   */
+  transform(input: string): string;
+  /**
+   * Transform HTML content
+   * @param input - The HTML to transform as a {@link ArrayBuffer}
+   * @returns A new {@link ArrayBuffer} with the transformed HTML
+   */
+  transform(input: ArrayBuffer): ArrayBuffer;
+}

package/connectors/connect-yousign/node_modules/bun-types/index.d.ts ADDED Viewed

@@ -0,0 +1,32 @@
+// Project: https://github.com/oven-sh/bun
+// Definitions by: Bun Contributors <https://github.com/oven-sh/bun/graphs/contributors>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+/// <reference types="node" />
+/// <reference path="./globals.d.ts" />
+/// <reference path="./s3.d.ts" />
+/// <reference path="./fetch.d.ts" />
+/// <reference path="./bun.d.ts" />
+/// <reference path="./extensions.d.ts" />
+/// <reference path="./devserver.d.ts" />
+/// <reference path="./ffi.d.ts" />
+/// <reference path="./html-rewriter.d.ts" />
+/// <reference path="./jsc.d.ts" />
+/// <reference path="./sqlite.d.ts" />
+/// <reference path="./test.d.ts" />
+/// <reference path="./wasm.d.ts" />
+/// <reference path="./overrides.d.ts" />
+/// <reference path="./deprecated.d.ts" />
+/// <reference path="./redis.d.ts" />
+/// <reference path="./shell.d.ts" />
+/// <reference path="./serve.d.ts" />
+/// <reference path="./sql.d.ts" />
+/// <reference path="./security.d.ts" />
+/// <reference path="./bundle.d.ts" />
+/// <reference path="./bun.ns.d.ts" />
+// Must disable this so it doesn't conflict with the DOM onmessage type, but still
+// allows us to declare our own globals that Node's types can "see" and not conflict with
+declare var onmessage: Bun.__internal.UseLibDomIfAvailable<"onmessage", never>;

package/connectors/connect-yousign/node_modules/bun-types/jsc.d.ts ADDED Viewed

@@ -0,0 +1,233 @@
+declare module "bun:jsc" {
+  /**
+   * This used to be called "describe" but it could be confused with the test runner.
+   */
+  function jscDescribe(value: any): string;
+  function jscDescribeArray(args: any[]): string;
+  function gcAndSweep(): number;
+  function fullGC(): number;
+  function edenGC(): number;
+  function heapSize(): number;
+  function heapStats(): HeapStats;
+  function memoryUsage(): MemoryUsage;
+  function getRandomSeed(): number;
+  function setRandomSeed(value: number): void;
+  function isRope(input: string): boolean;
+  function callerSourceOrigin(): string;
+  function noFTL(func: (...args: any[]) => any): (...args: any[]) => any;
+  function noOSRExitFuzzing(func: (...args: any[]) => any): (...args: any[]) => any;
+  function optimizeNextInvocation(func: (...args: any[]) => any): void;
+  function numberOfDFGCompiles(func: (...args: any[]) => any): number;
+  function releaseWeakRefs(): void;
+  function totalCompileTime(func: (...args: any[]) => any): number;
+  function reoptimizationRetryCount(func: (...args: any[]) => any): number;
+  function drainMicrotasks(): void;
+  /**
+   * Convert a JavaScript value to a binary representation that can be sent to another Bun instance.
+   *
+   * Internally, this uses the serialization format from WebKit/Safari.
+   *
+   * @param value A JavaScript value, usually an object or array, to be converted.
+   * @returns A SharedArrayBuffer that can be sent to another Bun instance.
+   */
+  function serialize(value: any, options?: { binaryType?: "arraybuffer" }): SharedArrayBuffer;
+  /**
+   * Convert a JavaScript value to a binary representation that can be sent to another Bun instance.
+   *
+   * Internally, this uses the serialization format from WebKit/Safari.
+   *
+   * @param value A JavaScript value, usually an object or array, to be converted.
+   * @returns A Buffer that can be sent to another Bun instance.
+   */
+  function serialize(value: any, options?: { binaryType: "nodebuffer" }): Buffer;
+  /**
+   * Convert an ArrayBuffer or Buffer to a JavaScript value compatible with the HTML Structured Clone Algorithm.
+   *
+   * @param value A serialized value, usually an ArrayBuffer or Buffer, to be converted.
+   */
+  function deserialize(value: ArrayBufferLike | NodeJS.TypedArray | Buffer): any;
+  /**
+   * Set the timezone used by Intl, Date, etc.
+   *
+   * @param timeZone A string representing the time zone to use, such as "America/Los_Angeles"
+   *
+   * @returns The normalized time zone string
+   *
+   * You can also set process.env.TZ to the time zone you want to use.
+   * You can also view the current timezone with `Intl.DateTimeFormat().resolvedOptions().timeZone`
+   */
+  function setTimeZone(timeZone: string): string;
+  interface HeapStats {
+    heapSize: number;
+    heapCapacity: number;
+    extraMemorySize: number;
+    objectCount: number;
+    protectedObjectCount: number;
+    globalObjectCount: number;
+    protectedGlobalObjectCount: number;
+    objectTypeCounts: Record<string, number>;
+    protectedObjectTypeCounts: Record<string, number>;
+  }
+  interface MemoryUsage {
+    current: number;
+    peak: number;
+    currentCommit: number;
+    peakCommit: number;
+    pageFaults: number;
+  }
+  interface SamplingProfile {
+    /**
+     * A formatted summary of the top functions
+     *
+     * Example output:
+     * ```js
+     *
+     * Sampling rate: 100.000000 microseconds. Total samples: 6858
+     * Top functions as <numSamples  'functionName#hash:sourceID'>
+     * 2948    '#<nil>:8'
+     * 393    'visit#<nil>:8'
+     * 263    'push#<nil>:8'
+     * 164    'scan_ref_scoped#<nil>:8'
+     * 164    'walk#<nil>:8'
+     * 144    'pop#<nil>:8'
+     * 107    'extract_candidates#<nil>:8'
+     *  94    'get#<nil>:8'
+     *  82    'Function#<nil>:4294967295'
+     *  79    'set#<nil>:8'
+     *  67    'forEach#<nil>:5'
+     *  58    'collapse#<nil>:8'
+     * ```
+     */
+    functions: string;
+    /**
+     * A formatted summary of the top bytecodes
+     *
+     * Example output:
+     * ```js
+     * Tier breakdown:
+     * -----------------------------------
+     * LLInt:                   106  (1.545640%)
+     * Baseline:               2355  (34.339458%)
+     * DFG:                    3290  (47.973170%)
+     * FTL:                     833  (12.146398%)
+     * js builtin:              132  (1.924759%)
+     * Wasm:                      0  (0.000000%)
+     * Host:                    111  (1.618548%)
+     * RegExp:                   15  (0.218723%)
+     * C/C++:                     0  (0.000000%)
+     * Unknown Executable:      148  (2.158064%)
+     *
+     * Hottest bytecodes as <numSamples   'functionName#hash:JITType:bytecodeIndex'>
+     * 273    'visit#<nil>:DFG:bc#63'
+     * 121    'walk#<nil>:DFG:bc#7'
+     * 119    '#<nil>:Baseline:bc#1'
+     * 82    'Function#<nil>:None:<nil>'
+     * 66    '#<nil>:DFG:bc#11'
+     * 65    '#<nil>:DFG:bc#33'
+     * 58    '#<nil>:Baseline:bc#7'
+     * 53    '#<nil>:Baseline:bc#23'
+     * 50    'forEach#<nil>:DFG:bc#83'
+     * 49    'pop#<nil>:FTL:bc#65'
+     * 47    '#<nil>:DFG:bc#99'
+     * 45    '#<nil>:DFG:bc#16'
+     * 44    '#<nil>:DFG:bc#7'
+     * 44    '#<nil>:Baseline:bc#30'
+     * 44    'push#<nil>:FTL:bc#214'
+     * 41    '#<nil>:DFG:bc#50'
+     * 39    'get#<nil>:DFG:bc#27'
+     * 39    '#<nil>:Baseline:bc#0'
+     * 36    '#<nil>:DFG:bc#27'
+     * 36    'Dictionary#<nil>:DFG:bc#41'
+     * 36    'visit#<nil>:DFG:bc#81'
+     * 36    'get#<nil>:FTL:bc#11'
+     * 32    'push#<nil>:FTL:bc#49'
+     * 31    '#<nil>:DFG:bc#76'
+     * 31    '#<nil>:DFG:bc#10'
+     * 31    '#<nil>:DFG:bc#73'
+     * 29    'set#<nil>:DFG:bc#28'
+     * 28    'in_boolean_context#<nil>:DFG:bc#104'
+     * 28    '#<nil>:Baseline:<nil>'
+     * 28    'regExpSplitFast#<nil>:None:<nil>'
+     * 26    'visit#<nil>:DFG:bc#95'
+     * 26    'pop#<nil>:FTL:bc#120'
+     * 25    '#<nil>:DFG:bc#23'
+     * 25    'push#<nil>:FTL:bc#152'
+     * 24    'push#<nil>:FTL:bc#262'
+     * 24    '#<nil>:FTL:bc#10'
+     * 23    'is_identifier_char#<nil>:DFG:bc#22'
+     * 23    'visit#<nil>:DFG:bc#22'
+     * 22    '#<nil>:FTL:bc#27'
+     * 22    'indexOf#<nil>:None:<nil>'
+     * ```
+     */
+    bytecodes: string;
+    /**
+     * Stack traces of the top functions
+     */
+    stackTraces: string[];
+  }
+  /**
+   * Run JavaScriptCore's sampling profiler for a particular function
+   *
+   * This is pretty low-level.
+   *
+   * Things to know:
+   * - LLint means "Low Level Interpreter", which is the interpreter that runs before any JIT compilation
+   * - Baseline is the first JIT compilation tier. It's the least optimized, but the fastest to compile
+   * - DFG means "Data Flow Graph", which is the second JIT compilation tier. It has some optimizations, but is slower to compile
+   * - FTL means "Faster Than Light", which is the third JIT compilation tier. It has the most optimizations, but is the slowest to compile
+   */
+  function profile<T extends (...args: any[]) => any>(
+    callback: T,
+    sampleInterval?: number,
+    ...args: Parameters<T>
+  ): ReturnType<T> extends Promise<infer U> ? Promise<SamplingProfile> : SamplingProfile;
+  /**
+   * This returns objects which native code has explicitly protected from being
+   * garbage collected
+   *
+   * By calling this function you create another reference to the object, which
+   * will further prevent it from being garbage collected
+   *
+   * This function is mostly a debugging tool for bun itself.
+   *
+   * Warning: not all objects returned are supposed to be observable from JavaScript
+   */
+  function getProtectedObjects(): any[];
+  /**
+   * Start a remote debugging socket server on the given port.
+   *
+   * This exposes JavaScriptCore's built-in debugging server.
+   *
+   * This is untested. May not be supported yet on macOS
+   */
+  function startRemoteDebugger(host?: string, port?: number): void;
+  /**
+   * Run JavaScriptCore's sampling profiler
+   */
+  function startSamplingProfiler(optionalDirectory?: string): void;
+  /**
+   * Non-recursively estimate the memory usage of an object, excluding the memory usage of
+   * properties or other objects it references. For more accurate per-object
+   * memory usage, use {@link Bun.generateHeapSnapshot}.
+   *
+   * This is a best-effort estimate. It may not be 100% accurate. When it's
+   * wrong, it may mean the memory is non-contiguous (such as a large array).
+   *
+   * Passing a primitive type that isn't heap allocated returns 0.
+   */
+  function estimateShallowMemoryUsageOf(value: object | CallableFunction | bigint | symbol | string): number;
+}

package/connectors/connect-yousign/node_modules/bun-types/jsx.d.ts ADDED Viewed

@@ -0,0 +1,11 @@
+export {};
+type ReactElement = typeof globalThis extends { React: infer React }
+  ? React extends { createElement(...args: any): infer R }
+    ? R
+    : never
+  : unknown;
+export namespace JSX {
+  export type Element = ReactElement;
+}