@brokerize/client 1.0.1

package/dist/dependencyDefinitions/abortController.d.ts

@@ -0,0 +1,16 @@
+import { AbortSignal } from "./abortSignal";
+/** A controller object that allows you to abort one or more DOM requests as and when desired. */
+export declare interface AbortController {
+    /**
+     * Returns the AbortSignal object associated with this object.
+     */
+    readonly signal: AbortSignal;
+    /**
+     * Invoking this method will set this object's AbortSignal's aborted flag and signal to any observers that the associated activity is to be aborted.
+     */
+    abort(): void;
+}
+export type WhatWgAbortController = {
+    prototype: AbortController;
+    new (): AbortController;
+};

package/dist/dependencyDefinitions/abortController.js

@@ -0,0 +1,2 @@
+// stripped-down version of https://github.com/microsoft/TypeScript/blob/master/lib/lib.dom.d.ts (reduced to the parts we actually use).
+export {};

package/dist/dependencyDefinitions/abortSignal.d.ts

@@ -0,0 +1,13 @@
+/** A signal object that allows you to communicate with a DOM request (such as a Fetch) and abort it if required via an AbortController object. */
+export declare interface AbortSignal {
+    /**
+     * Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise.
+     */
+    readonly aborted: boolean;
+    addEventListener(eventName: "abort", listener: () => any): void;
+    removeEventListener(eventName: "abort", listener: () => any): void;
+}
+export type WhatWgAbortSignal = {
+    prototype: AbortSignal;
+    new (): AbortSignal;
+};

package/dist/dependencyDefinitions/abortSignal.js

@@ -0,0 +1,2 @@
+// stripped-down version of https://github.com/microsoft/TypeScript/blob/master/lib/lib.dom.d.ts (reduced to the parts we actually use).
+export {};

package/dist/dependencyDefinitions/fetch.d.ts

@@ -0,0 +1,160 @@
+import { AbortSignal } from "./abortSignal";
+export declare type WhatWgFetch = (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+export declare type RequestInfo = Request | string;
+declare interface Body {
+    json(): Promise<any>;
+    text(): Promise<string>;
+}
+/** This Fetch API interface represents a resource request. */
+declare interface Request extends Body {
+    /**
+     * Returns the cache mode associated with request, which is a string indicating how the request will interact with the browser's cache when fetching.
+     */
+    readonly cache: RequestCache;
+    /**
+     * Returns the credentials mode associated with request, which is a string indicating whether credentials will be sent with the request always, never, or only when sent to a same-origin URL.
+     */
+    readonly credentials: RequestCredentials;
+    /**
+     * Returns the kind of resource requested by request, e.g., "document" or "script".
+     */
+    readonly destination: RequestDestination;
+    /**
+     * Returns a Headers object consisting of the headers associated with request. Note that headers added in the network layer by the user agent will not be accounted for in this object, e.g., the "Host" header.
+     */
+    readonly headers: Headers;
+    /**
+     * Returns request's subresource integrity metadata, which is a cryptographic hash of the resource being fetched. Its value consists of multiple hashes separated by whitespace. [SRI]
+     */
+    readonly integrity: string;
+    /**
+     * Returns a boolean indicating whether or not request is for a history navigation (a.k.a. back-foward navigation).
+     */
+    readonly isHistoryNavigation: boolean;
+    /**
+     * Returns a boolean indicating whether or not request is for a reload navigation.
+     */
+    readonly isReloadNavigation: boolean;
+    /**
+     * Returns a boolean indicating whether or not request can outlive the global in which it was created.
+     */
+    readonly keepalive: boolean;
+    /**
+     * Returns request's HTTP method, which is "GET" by default.
+     */
+    readonly method: string;
+    /**
+     * Returns the mode associated with request, which is a string indicating whether the request will use CORS, or will be restricted to same-origin URLs.
+     */
+    readonly mode: RequestMode;
+    /**
+     * Returns the redirect mode associated with request, which is a string indicating how redirects for the request will be handled during fetching. A request will follow redirects by default.
+     */
+    readonly redirect: RequestRedirect;
+    /**
+     * Returns the referrer of request. Its value can be a same-origin URL if explicitly set in init, the empty string to indicate no referrer, and "about:client" when defaulting to the global's default. This is used during fetching to determine the value of the `Referer` header of the request being made.
+     */
+    readonly referrer: string;
+    /**
+     * Returns the referrer policy associated with request. This is used during fetching to compute the value of the request's referrer.
+     */
+    readonly referrerPolicy: ReferrerPolicy;
+    /**
+     * Returns the signal associated with request, which is an AbortSignal object indicating whether or not request has been aborted, and its abort event handler.
+     */
+    readonly signal: AbortSignal;
+    /**
+     * Returns the URL of request as a string.
+     */
+    readonly url: string;
+    clone(): Request;
+}
+declare type RequestMode = "cors" | "navigate" | "no-cors" | "same-origin";
+declare type RequestRedirect = "error" | "follow" | "manual";
+declare type ReferrerPolicy = "" | "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "same-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url";
+declare type RequestCache = "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload";
+declare type RequestCredentials = "include" | "omit" | "same-origin";
+declare type RequestDestination = "" | "audio" | "audioworklet" | "document" | "embed" | "font" | "image" | "manifest" | "object" | "paintworklet" | "report" | "script" | "sharedworker" | "style" | "track" | "video" | "worker" | "xslt";
+/** This Fetch API interface allows you to perform various actions on HTTP request and response headers. These actions include retrieving, setting, adding to, and removing. A Headers object has an associated header list, which is initially empty and consists of zero or more name and value pairs.  You can add to this using methods like append() (see Examples.) In all methods of this interface, header names are matched by case-insensitive byte sequence. */
+declare interface Headers {
+    append(name: string, value: string): void;
+    delete(name: string): void;
+    get(name: string): string | null;
+    has(name: string): boolean;
+    set(name: string, value: string): void;
+    forEach(callbackfn: (value: string, key: string, parent: Headers) => void, thisArg?: any): void;
+}
+declare let Headers: {
+    prototype: Headers;
+    new (init?: HeadersInit): Headers;
+};
+declare type HeadersInit = Headers | string[][] | Record<string, string>;
+export declare interface RequestInit {
+    /**
+     * A BodyInit object or null to set request's body.
+     */
+    body?: BodyInit | null;
+    /**
+     * A string indicating how the request will interact with the browser's cache to set request's cache.
+     */
+    cache?: RequestCache;
+    /**
+     * A string indicating whether credentials will be sent with the request always, never, or only when sent to a same-origin URL. Sets request's credentials.
+     */
+    credentials?: RequestCredentials;
+    /**
+     * A Headers object, an object literal, or an array of two-item arrays to set request's headers.
+     */
+    headers?: HeadersInit;
+    /**
+     * A cryptographic hash of the resource to be fetched by request. Sets request's integrity.
+     */
+    integrity?: string;
+    /**
+     * A boolean to set request's keepalive.
+     */
+    keepalive?: boolean;
+    /**
+     * A string to set request's method.
+     */
+    method?: string;
+    /**
+     * A string to indicate whether the request will use CORS, or will be restricted to same-origin URLs. Sets request's mode.
+     */
+    mode?: RequestMode;
+    /**
+     * A string indicating whether request follows redirects, results in an error upon encountering a redirect, or returns the redirect (in an opaque fashion). Sets request's redirect.
+     */
+    redirect?: RequestRedirect;
+    /**
+     * A string whose value is a same-origin URL, "about:client", or the empty string, to set request's referrer.
+     */
+    referrer?: string;
+    /**
+     * A referrer policy to set request's referrerPolicy.
+     */
+    referrerPolicy?: ReferrerPolicy;
+    /**
+     * An AbortSignal to set request's signal.
+     */
+    signal?: AbortSignal | null;
+    /**
+     * Can only be null. Used to disassociate request from any Window.
+     */
+    window?: any;
+}
+declare type BodyInit = string;
+/** This Fetch API interface represents the response to a request. */
+export declare interface Response extends Body {
+    readonly headers: Headers;
+    readonly ok: boolean;
+    readonly redirected: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly trailer: Promise<Headers>;
+    readonly type: ResponseType;
+    readonly url: string;
+    clone(): Response;
+}
+declare type ResponseType = "basic" | "cors" | "default" | "error" | "opaque" | "opaqueredirect";
+export {};

package/dist/dependencyDefinitions/fetch.js

@@ -0,0 +1,2 @@
+// stripped-down version of https://github.com/microsoft/TypeScript/blob/master/lib/lib.dom.d.ts (reduced to the parts we actually use).
+export {};

package/dist/dependencyDefinitions/readableStream.d.ts

@@ -0,0 +1,68 @@
+/** This Streams API interface represents a readable stream of byte data. The Fetch API offers a concrete instance of a ReadableStream through the body property of a Response object. */
+export type WhatWgReadableStream = {
+    prototype: ReadableStream;
+    new (): ReadableStream;
+};
+export declare interface ReadableStream<R = any> {
+    readonly locked: boolean;
+    cancel(reason?: any): Promise<void>;
+    getReader(options: {
+        mode: "byob";
+    }): ReadableStreamBYOBReader;
+    getReader(): ReadableStreamDefaultReader<R>;
+    pipeThrough<T>({ writable, readable, }: {
+        writable: WritableStream<R>;
+        readable: ReadableStream<T>;
+    }, options?: any): ReadableStream<T>;
+    pipeTo(dest: WritableStream<R>, options?: any): Promise<void>;
+    tee(): [ReadableStream<R>, ReadableStream<R>];
+}
+interface ReadableStreamBYOBReader {
+    readonly closed: Promise<void>;
+    cancel(reason?: any): Promise<void>;
+    read<T extends ArrayBufferView>(view: T): Promise<ReadableStreamReadResult<T>>;
+    releaseLock(): void;
+}
+interface ReadableStreamDefaultReader<R = any> {
+    readonly closed: Promise<void>;
+    cancel(reason?: any): Promise<void>;
+    read(): Promise<ReadableStreamReadResult<R>>;
+    releaseLock(): void;
+}
+interface WritableStream<W = any> {
+    readonly locked: boolean;
+    abort(reason?: any): Promise<void>;
+    getWriter(): WritableStreamDefaultWriter<W>;
+}
+/** This Streams API interface is the object returned by WritableStream.getWriter() and once created locks the < writer to the WritableStream ensuring that no other streams can write to the underlying sink. */
+interface WritableStreamDefaultWriter<W = any> {
+    readonly closed: Promise<void>;
+    readonly desiredSize: number | null;
+    readonly ready: Promise<void>;
+    abort(reason?: any): Promise<void>;
+    close(): Promise<void>;
+    releaseLock(): void;
+    write(chunk: W): Promise<void>;
+}
+interface ReadableStreamDefaultReader<R = any> {
+    readonly closed: Promise<void>;
+    cancel(reason?: any): Promise<void>;
+    read(): Promise<ReadableStreamReadResult<R>>;
+    releaseLock(): void;
+}
+type ReadableStreamReadResult<T> = ReadableStreamReadValueResult<T> | ReadableStreamReadDoneResult<T>;
+interface ReadableStreamReadDoneResult<T> {
+    done: true;
+    value?: T;
+}
+interface ReadableStreamReadValueResult<T> {
+    done: false;
+    value: T;
+}
+interface ReadableStreamDefaultReader<R = any> {
+    readonly closed: Promise<void>;
+    cancel(reason?: any): Promise<void>;
+    read(): Promise<ReadableStreamReadResult<R>>;
+    releaseLock(): void;
+}
+export {};

package/dist/dependencyDefinitions/readableStream.js

@@ -0,0 +1 @@
+export {};

package/dist/dependencyDefinitions/textDecoder.d.ts

@@ -0,0 +1,39 @@
+export type WhatWgTextDecoder = {
+    prototype: TextDecoder;
+    new (): TextDecoder;
+};
+export declare interface TextDecoder extends TextDecoderCommon {
+    /**
+     * Returns the result of running encoding's decoder. The method can be invoked zero or more times with options's stream set to true, and then once without options's stream (or set to false), to process a fragmented stream. If the invocation without options's stream (or set to false) has no input, it's clearest to omit both arguments.
+     *
+     * ```
+     * var string = "", decoder = new TextDecoder(encoding), buffer;
+     * while(buffer = next_chunk()) {
+     *   string += decoder.decode(buffer, {stream:true});
+     * }
+     * string += decoder.decode(); // end-of-stream
+     * ```
+     *
+     * If the error mode is "fatal" and encoding's decoder returns error, throws a TypeError.
+     */
+    decode(input?: BufferSource, options?: TextDecodeOptions): string;
+}
+interface TextDecoderCommon {
+    /**
+     * Returns encoding's name, lowercased.
+     */
+    readonly encoding: string;
+    /**
+     * Returns true if error mode is "fatal", and false otherwise.
+     */
+    readonly fatal: boolean;
+    /**
+     * Returns true if ignore BOM flag is set, and false otherwise.
+     */
+    readonly ignoreBOM: boolean;
+}
+type BufferSource = ArrayBufferView | ArrayBuffer | string;
+interface TextDecodeOptions {
+    stream?: boolean;
+}
+export {};

package/dist/dependencyDefinitions/textDecoder.js

@@ -0,0 +1 @@
+export {};

package/dist/dependencyDefinitions/webSocket.d.ts

@@ -0,0 +1,182 @@
+/** Provides the API for creating and managing a WebSocket connection to a server, as well as for sending and receiving data on the connection. */
+export declare interface WebSocket {
+    /**
+     * Returns a string that indicates how binary data from the WebSocket object is exposed to scripts:
+     *
+     * Can be set, to change how binary data is returned. The default is "blob".
+     */
+    binaryType: BinaryType;
+    /**
+     * Returns the number of bytes of application data (UTF-8 text and binary data) that have been queued using send() but not yet been transmitted to the network.
+     *
+     * If the WebSocket connection is closed, this attribute's value will only increase with each call to the send() method. (The number does not reset to zero once the connection closes.)
+     */
+    readonly bufferedAmount: number;
+    /**
+     * Returns the extensions selected by the server, if any.
+     */
+    readonly extensions: string;
+    onclose: ((this: WebSocket, ev: CloseEvent) => any) | null;
+    onerror: ((this: WebSocket, ev: Event) => any) | null;
+    onmessage: ((this: WebSocket, ev: MessageEvent) => any) | null;
+    onopen: ((this: WebSocket, ev: Event) => any) | null;
+    /**
+     * Returns the subprotocol selected by the server, if any. It can be used in conjunction with the array form of the constructor's second argument to perform subprotocol negotiation.
+     */
+    readonly protocol: string;
+    /**
+     * Returns the state of the WebSocket object's connection. It can have the values described below.
+     */
+    readonly readyState: number;
+    /**
+     * Returns the URL that was used to establish the WebSocket connection.
+     */
+    readonly url: string;
+    /**
+     * Closes the WebSocket connection, optionally using code as the the WebSocket connection close code and reason as the the WebSocket connection close reason.
+     */
+    close(code?: number, reason?: string): void;
+    /**
+     * Transmits data using the WebSocket connection. data can be a string, a Blob, an ArrayBuffer, or an ArrayBufferView.
+     */
+    send(data: string | ArrayBufferLike | /*Blob |*/ ArrayBufferView): void;
+    readonly CLOSED: number;
+    readonly CLOSING: number;
+    readonly CONNECTING: number;
+    readonly OPEN: number;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+}
+export type WhatWgWebSocket = {
+    prototype: WebSocket;
+    new (url: string, protocols?: string | string[]): WebSocket;
+    readonly CLOSED: number;
+    readonly CLOSING: number;
+    readonly CONNECTING: number;
+    readonly OPEN: number;
+};
+export declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
+export declare interface EventListener {
+    (evt: Event): void;
+}
+export declare interface EventListenerObject {
+    handleEvent(evt: Event): void;
+}
+type BinaryType = "arraybuffer" | "blob";
+/** A CloseEvent is sent to clients using WebSockets when the connection is closed. This is delivered to the listener indicated by the WebSocket object's onclose attribute. */
+export interface CloseEvent extends Event {
+    /**
+     * Returns the WebSocket connection close code provided by the server.
+     */
+    readonly code: number;
+    /**
+     * Returns the WebSocket connection close reason provided by the server.
+     */
+    readonly reason: string;
+    /**
+     * Returns true if the connection closed cleanly; false otherwise.
+     */
+    readonly wasClean: boolean;
+}
+/** An event which takes place in the DOM. */
+interface Event {
+    /**
+     * Returns true or false depending on how event was initialized. True if event goes through its target's ancestors in reverse tree order, and false otherwise.
+     */
+    readonly bubbles: boolean;
+    cancelBubble: boolean;
+    /**
+     * Returns true or false depending on how event was initialized. Its return value does not always carry meaning, but true can indicate that part of the operation during which event was dispatched, can be canceled by invoking the preventDefault() method.
+     */
+    readonly cancelable: boolean;
+    /**
+     * Returns true or false depending on how event was initialized. True if event invokes listeners past a ShadowRoot node that is the root of its target, and false otherwise.
+     */
+    readonly composed: boolean;
+    /**
+     * Returns the object whose event listener's callback is currently being invoked.
+     */
+    /**
+     * Returns true if preventDefault() was invoked successfully to indicate cancelation, and false otherwise.
+     */
+    readonly defaultPrevented: boolean;
+    /**
+     * Returns the event's phase, which is one of NONE, CAPTURING_PHASE, AT_TARGET, and BUBBLING_PHASE.
+     */
+    readonly eventPhase: number;
+    /**
+     * Returns true if event was dispatched by the user agent, and false otherwise.
+     */
+    readonly isTrusted: boolean;
+    returnValue: boolean;
+    /** @deprecated */
+    /**
+     * Returns the object to which event is dispatched (its target).
+     */
+    /**
+     * Returns the event's timestamp as the number of milliseconds measured relative to the time origin.
+     */
+    readonly timeStamp: number;
+    /**
+     * Returns the type of event, e.g. "click", "hashchange", or "submit".
+     */
+    readonly type: string;
+    /**
+     * Returns the invocation target objects of event's path (objects on which listeners will be invoked), except for any nodes in shadow trees of which the shadow root's mode is "closed" that are not reachable from event's currentTarget.
+     */
+    initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;
+    /**
+     * If invoked when the cancelable attribute value is true, and while executing a listener for the event with passive set to false, signals to the operation that caused event to be dispatched that it needs to be canceled.
+     */
+    preventDefault(): void;
+    /**
+     * Invoking this method prevents event from reaching any registered event listeners after the current one finishes running and, when dispatched in a tree, also prevents event from reaching any other objects.
+     */
+    stopImmediatePropagation(): void;
+    /**
+     * When dispatched in a tree, invoking this method prevents event from reaching any objects other than the current object.
+     */
+    stopPropagation(): void;
+    readonly AT_TARGET: number;
+    readonly BUBBLING_PHASE: number;
+    readonly CAPTURING_PHASE: number;
+    readonly NONE: number;
+}
+/** A message received by a target object. */
+export interface MessageEvent extends Event {
+    /**
+     * Returns the data of the message.
+     */
+    readonly data: any;
+    /**
+     * Returns the last event ID string, for server-sent events.
+     */
+    readonly lastEventId: string;
+    /**
+     * Returns the origin of the message, for server-sent events and cross-document messaging.
+     */
+    readonly origin: string;
+}
+/** This Channel Messaging API interface represents one of the two ports of a MessageChannel, allowing messages to be sent from one port and listening out for them arriving at the other. */
+export interface AddEventListenerOptions extends EventListenerOptions {
+    once?: boolean;
+    passive?: boolean;
+}
+export interface EventListenerOptions {
+    capture?: boolean;
+}
+export interface WebSocketEventMap {
+    close: CloseEvent;
+    error: Event;
+    message: MessageEvent;
+    open: Event;
+}
+/** Events providing information related to errors in scripts or in files. */
+export interface ErrorEvent extends Event {
+    readonly colno: number;
+    readonly error: any;
+    readonly filename: string;
+    readonly lineno: number;
+    readonly message: string;
+}
+export {};

package/dist/dependencyDefinitions/webSocket.js

@@ -0,0 +1,2 @@
+// stripped-down version of https://github.com/microsoft/TypeScript/blob/master/lib/lib.dom.d.ts (reduced to the parts we actually use).
+export {};