mphttpx 1.0.4 → 1.0.6

package/dist/index.d.ts

@@ -13,17 +13,15 @@ declare const TextEncoderE: {
     prototype: TextEncoder;
 };
 
-declare const state$h: unique symbol;
 declare class TextDecoderP implements TextDecoder {
     constructor(utfLabel?: string, { fatal, ignoreBOM }?: {
         fatal?: boolean | undefined;
         ignoreBOM?: boolean | undefined;
     });
-    [state$h]: TextDecoderState;
     get encoding(): string;
     get fatal(): boolean;
     get ignoreBOM(): boolean;
-    decode(buffer?: TAllowSharedBufferSource, { stream }?: {
+    decode(buffer?: Parameters<TextDecoder["decode"]>[0], { stream }?: {
         stream?: boolean | undefined;
     }): string;
     toString(): string;
@@ -32,29 +30,17 @@ declare class TextDecoderP implements TextDecoder {
         hierarchy: string[];
     };
 }
-declare const _bomSeen: unique symbol;
-declare const _partial: unique symbol;
-declare class TextDecoderState {
-    fatal: boolean;
-    ignoreBOM: boolean;
-    [_bomSeen]: boolean;
-    [_partial]: number[];
-}
-type TAllowSharedBufferSource = NonNullable<Parameters<TextDecoder["decode"]>[0]>;
 declare const TextDecoderE: {
     new (label?: string, options?: TextDecoderOptions): TextDecoder;
     prototype: TextDecoder;
 };
 
-declare const state$g: unique symbol;
-
 declare class EventP implements Event {
-    static readonly NONE = 0;
-    static readonly CAPTURING_PHASE = 1;
-    static readonly AT_TARGET = 2;
-    static readonly BUBBLING_PHASE = 3;
+    static readonly NONE: 0;
+    static readonly CAPTURING_PHASE: 1;
+    static readonly AT_TARGET: 2;
+    static readonly BUBBLING_PHASE: 3;
     constructor(type: string, eventInitDict?: EventInit);
-    [state$g]: EventState;
     get type(): string;
     get bubbles(): boolean;
     get cancelable(): boolean;
@@ -62,17 +48,17 @@ declare class EventP implements Event {
     get target(): EventTarget | null;
     get currentTarget(): EventTarget | null;
     get eventPhase(): number;
-    readonly NONE = 0;
-    readonly CAPTURING_PHASE = 1;
-    readonly AT_TARGET = 2;
-    readonly BUBBLING_PHASE = 3;
+    readonly NONE: 0;
+    readonly CAPTURING_PHASE: 1;
+    readonly AT_TARGET: 2;
+    readonly BUBBLING_PHASE: 3;
     get srcElement(): EventTarget | null;
     get cancelBubble(): boolean;
     set cancelBubble(value: boolean);
     get defaultPrevented(): boolean;
     get returnValue(): boolean;
     set returnValue(value: boolean);
-    get isTrusted(): boolean;
+    readonly isTrusted: boolean;
     get timeStamp(): number;
     composedPath(): EventTarget[];
     initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;
@@ -85,31 +71,6 @@ declare class EventP implements Event {
         hierarchy: string[];
     };
 }
-declare const _TimeStamp: unique symbol;
-declare const _isTrusted: unique symbol;
-declare const _passive: unique symbol;
-declare const _dispatched: unique symbol;
-declare const _preventDefaultCalled: unique symbol;
-declare const _stopImmediatePropagationCalled: unique symbol;
-declare class EventState {
-    static [_TimeStamp]: number;
-    type: string;
-    bubbles: boolean;
-    cancelable: boolean;
-    composed: boolean;
-    target: EventTarget | null;
-    currentTarget: EventTarget | null;
-    eventPhase: number;
-    cancelBubble: boolean;
-    defaultPrevented: boolean;
-    returnValue: boolean;
-    timeStamp: number;
-    [_isTrusted]: boolean;
-    [_passive]: boolean;
-    [_dispatched]: boolean;
-    [_preventDefaultCalled]: boolean;
-    [_stopImmediatePropagationCalled]: boolean;
-}
 declare const EventE: {
     new (type: string, eventInitDict?: EventInit): Event;
     prototype: Event;
@@ -119,11 +80,8 @@ declare const EventE: {
     readonly BUBBLING_PHASE: 3;
 };
 
-declare const state$f: unique symbol;
-
 declare class EventTargetP implements EventTarget {
     constructor();
-    [state$f]: EventTargetState;
     addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
     dispatchEvent(event: Event): boolean;
     removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
@@ -133,28 +91,13 @@ declare class EventTargetP implements EventTarget {
         hierarchy: string[];
     };
 }
-declare const _executors: unique symbol;
-declare class EventTargetState {
-    constructor(target: EventTargetP);
-    target: EventTargetP;
-    [_executors]: Executor[];
-}
-declare class Executor {
-    constructor(type: string, callback: EventListenerOrEventListenerObject | null);
-    type: string;
-    callback: EventListener | null;
-    options: AddEventListenerOptions;
-    equals(executor: Executor): boolean;
-}
 declare const EventTargetE: {
     new (): EventTarget;
     prototype: EventTarget;
 };
 
-declare const state$e: unique symbol;
 declare class CustomEventP<T> extends EventP implements CustomEvent {
     constructor(type: string, eventInitDict?: CustomEventInit<T>);
-    [state$e]: CustomEventState;
     get detail(): T;
     initCustomEvent(type: string, bubbles?: boolean, cancelable?: boolean, detail?: T): void;
     toString(): string;
@@ -163,18 +106,13 @@ declare class CustomEventP<T> extends EventP implements CustomEvent {
         hierarchy: string[];
     };
 }
-declare class CustomEventState {
-    detail: unknown;
-}
 declare const CustomEventE: {
     new <T>(type: string, eventInitDict?: CustomEventInit<T>): CustomEvent<T>;
     prototype: CustomEvent;
 };
 
-declare const state$d: unique symbol;
 declare class ProgressEventP extends EventP implements ProgressEvent {
     constructor(type: string, eventInitDict?: ProgressEventInit);
-    [state$d]: ProgressEventState;
     get lengthComputable(): boolean;
     get loaded(): number;
     get total(): number;
@@ -184,27 +122,19 @@ declare class ProgressEventP extends EventP implements ProgressEvent {
         hierarchy: string[];
     };
 }
-declare class ProgressEventState {
-    lengthComputable: boolean | (() => boolean);
-    loaded: number | (() => number);
-    total: number | (() => number);
-}
 declare const ProgressEventE: {
     new (type: string, eventInitDict?: ProgressEventInit): ProgressEvent;
     prototype: ProgressEvent;
 };
 
-declare const state$c: unique symbol;
-
 declare class BlobP implements Blob {
     constructor(blobParts?: BlobPart[], options?: BlobPropertyBag);
-    [state$c]: BlobState;
     get size(): number;
     get type(): string;
     arrayBuffer(): Promise<ArrayBuffer>;
-    bytes(): Promise<TUint8ArrayOfArrayBuffer>;
+    bytes(): Promise<Uint8Array<ArrayBuffer>>;
     slice(start?: number, end?: number, contentType?: string): Blob;
-    stream(): ReadableStream<TUint8ArrayOfArrayBuffer>;
+    stream(): ReturnType<Blob["stream"]>;
     text(): Promise<string>;
     toString(): string;
     get isPolyfill(): {
@@ -212,23 +142,13 @@ declare class BlobP implements Blob {
         hierarchy: string[];
     };
 }
-declare const _u8array: unique symbol;
-declare class BlobState {
-    constructor(buffer: TUint8ArrayOfArrayBuffer);
-    size: number;
-    type: string;
-    [_u8array]: TUint8ArrayOfArrayBuffer;
-}
-type TUint8ArrayOfArrayBuffer = ReturnType<TextEncoder["encode"]>;
 declare const BlobE: {
     new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
     prototype: Blob;
 };
 
-declare const state$b: unique symbol;
 declare class FileP extends BlobP implements File {
     constructor(fileBits: BlobPart[], fileName: string, options?: FilePropertyBag);
-    [state$b]: FileState;
     get lastModified(): number;
     get name(): string;
     get webkitRelativePath(): string;
@@ -238,27 +158,21 @@ declare class FileP extends BlobP implements File {
         hierarchy: string[];
     };
 }
-declare class FileState {
-    lastModified: number;
-    name: string;
-}
 declare const FileE: {
     new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
     prototype: File;
 };
 
-declare const state$a: unique symbol;
 declare class FileReaderP extends EventTargetP implements FileReader {
-    static readonly EMPTY = 0;
-    static readonly LOADING = 1;
-    static readonly DONE = 2;
+    static readonly EMPTY: 0;
+    static readonly LOADING: 1;
+    static readonly DONE: 2;
     constructor();
-    [state$a]: FileReaderState;
     get readyState(): 0 | 1 | 2;
     get result(): string | ArrayBuffer | null;
-    readonly EMPTY = 0;
-    readonly LOADING = 1;
-    readonly DONE = 2;
+    readonly EMPTY: 0;
+    readonly LOADING: 1;
+    readonly DONE: 2;
     get error(): DOMException | null;
     abort(): void;
     readAsArrayBuffer(blob: Blob): void;
@@ -283,28 +197,6 @@ declare class FileReaderP extends EventTargetP implements FileReader {
         hierarchy: string[];
     };
 }
-declare const _handlers$3: unique symbol;
-declare class FileReaderState {
-    constructor(target: FileReaderP);
-    target: FileReaderP;
-    readyState: FileReader["readyState"];
-    result: string | ArrayBuffer | null;
-    error: DOMException | null;
-    [_handlers$3]: {
-        onabort: (ev: ProgressEvent<FileReader>) => void;
-        onerror: (ev: ProgressEvent<FileReader>) => void;
-        onload: (ev: ProgressEvent<FileReader>) => void;
-        onloadend: (ev: ProgressEvent<FileReader>) => void;
-        onloadstart: (ev: ProgressEvent<FileReader>) => void;
-        onprogress: (ev: ProgressEvent<FileReader>) => void;
-    };
-    onabort: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
-    onerror: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
-    onload: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
-    onloadend: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
-    onloadstart: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
-    onprogress: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
-}
 declare const FileReaderE: {
     new (): FileReader;
     prototype: FileReader;
@@ -313,11 +205,8 @@ declare const FileReaderE: {
     readonly DONE: 2;
 };
 
-declare const state$9: unique symbol;
-
 declare class FormDataP implements FormData {
     constructor(form?: HTMLFormElement, submitter?: HTMLElement | null);
-    [state$9]: FormDataState;
     append(name: string, value: string | Blob, filename?: string): void;
     delete(name: string): void;
     get(name: string): FormDataEntryValue | null;
@@ -335,20 +224,13 @@ declare class FormDataP implements FormData {
         hierarchy: string[];
     };
 }
-declare const _formData: unique symbol;
-declare class FormDataState {
-    [_formData]: [string, FormDataEntryValue][];
-    toBlob(): BlobP;
-}
 declare const FormDataE: {
     new (form?: HTMLFormElement, submitter?: HTMLElement | null): FormData;
     prototype: FormData;
 };
 
-declare const state$8: unique symbol;
 declare class URLSearchParamsP implements URLSearchParams {
     constructor(init?: string[][] | Record<string, string> | string | URLSearchParams);
-    [state$8]: URLSearchParamsState;
     get size(): number;
     append(name: string, value: string): void;
     delete(name: string, value?: string): void;
@@ -368,23 +250,16 @@ declare class URLSearchParamsP implements URLSearchParams {
         hierarchy: string[];
     };
 }
-declare const _urlspDict: unique symbol;
-declare class URLSearchParamsState {
-    [_urlspDict]: Record<string, string[]>;
-}
 declare const URLSearchParamsE: {
     new (init?: string[][] | Record<string, string> | string | URLSearchParams): URLSearchParams;
     prototype: URLSearchParams;
 };
 
-declare const state$7: unique symbol;
-
 declare class AbortSignalP extends EventTargetP implements AbortSignal {
     static abort(reason?: any): AbortSignal;
     static any(signals: AbortSignal[]): AbortSignal;
     static timeout(milliseconds: number): AbortSignal;
     constructor();
-    [state$7]: AbortSignalState;
     get aborted(): boolean;
     get reason(): any;
     throwIfAborted(): void;
@@ -396,17 +271,6 @@ declare class AbortSignalP extends EventTargetP implements AbortSignal {
         hierarchy: string[];
     };
 }
-declare const _handlers$2: unique symbol;
-declare class AbortSignalState {
-    constructor(target: AbortSignalP);
-    target: AbortSignalP;
-    aborted: boolean;
-    reason: any;
-    [_handlers$2]: {
-        onabort: (ev: Event) => void;
-    };
-    onabort: ((this: AbortSignal, ev: Event) => any) | null;
-}
 declare const AbortSignalE: {
     new (): AbortSignal;
     prototype: AbortSignal;
@@ -415,10 +279,8 @@ declare const AbortSignalE: {
     timeout(milliseconds: number): AbortSignal;
 };
 
-declare const state$6: unique symbol;
 declare class AbortControllerP implements AbortController {
     constructor();
-    [state$6]: AbortControllerState;
     get signal(): AbortSignal;
     abort(reason?: any): void;
     toString(): string;
@@ -427,19 +289,13 @@ declare class AbortControllerP implements AbortController {
         hierarchy: string[];
     };
 }
-declare class AbortControllerState {
-    signal: AbortSignalP;
-}
 declare const AbortControllerE: {
     new (): AbortController;
     prototype: AbortController;
 };
 
-declare const state$5: unique symbol;
-
 declare class XMLHttpRequestEventTargetP extends EventTargetP implements XMLHttpRequestEventTarget {
     constructor();
-    [state$5]: XMLHttpRequestEventTargetState;
     get onabort(): ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
     set onabort(value: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null);
     get onerror(): ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
@@ -460,96 +316,19 @@ declare class XMLHttpRequestEventTargetP extends EventTargetP implements XMLHttp
         hierarchy: string[];
     };
 }
-declare const _handlers$1: unique symbol;
-declare class XMLHttpRequestEventTargetState {
-    /**
-     * @param _target XMLHttpRequestEventTargetP
-     */
-    constructor(_target: unknown);
-    target: XMLHttpRequest;
-    [_handlers$1]: {
-        onabort: (ev: ProgressEvent) => void;
-        onerror: (ev: ProgressEvent) => void;
-        onload: (ev: ProgressEvent) => void;
-        onloadend: (ev: ProgressEvent) => void;
-        onloadstart: (ev: ProgressEvent) => void;
-        onprogress: (ev: ProgressEvent) => void;
-        ontimeout: (ev: ProgressEvent) => void;
-    };
-    onabort: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
-    onerror: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
-    onload: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
-    onloadend: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
-    onloadstart: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
-    onprogress: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
-    ontimeout: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
-}
-
-declare class XMLHttpRequestUploadP extends XMLHttpRequestEventTargetP implements XMLHttpRequestUpload {
-    constructor();
-    toString(): string;
-    get isPolyfill(): {
-        symbol: symbol;
-        hierarchy: string[];
-    };
-}
-
-interface IRequestTask {
-    /**
-     * 中断请求任务
-     */
-    abort: () => void;
-    /**
-     * 监听 HTTP Response Header 事件。会比请求完成事件更早
-     */
-    onHeadersReceived: (listener: (res: {
-        /**
-         * 开发者服务器返回的 HTTP Response Header
-         */
-        header: object;
-        /**
-         * 开发者服务器返回的 HTTP 状态码 （目前开发者工具上不会返回 statusCode 字段，可用真机查看该字段，后续将会支持）
-         */
-        statusCode: number;
-        /**
-         * 开发者服务器返回的 cookies，格式为字符串数组
-         */
-        cookies: string[];
-    }) => void) => void;
-    /**
-     * 移除 HTTP Response Header 事件的监听函数
-     */
-    offHeadersReceived: (listener: Function) => void;
-    /**
-     * 监听 Transfer-Encoding Chunk Received 事件。当接收到新的chunk时触发。
-     */
-    onChunkReceived: (listener: (res: {
-        /**
-         * 返回的chunk buffer
-         */
-        data: ArrayBuffer;
-    }) => void) => void;
-    /**
-     * 移除 Transfer-Encoding Chunk Received 事件的监听函数
-     */
-    offChunkReceived: (listener: Function) => void;
-}
-
-declare const state$4: unique symbol;
 
 declare class XMLHttpRequestP extends XMLHttpRequestEventTargetP implements XMLHttpRequest {
-    static readonly UNSENT = 0;
-    static readonly OPENED = 1;
-    static readonly HEADERS_RECEIVED = 2;
-    static readonly LOADING = 3;
-    static readonly DONE = 4;
+    static readonly UNSENT: 0;
+    static readonly OPENED: 1;
+    static readonly HEADERS_RECEIVED: 2;
+    static readonly LOADING: 3;
+    static readonly DONE: 4;
     constructor();
-    [state$4]: XMLHttpRequestState;
-    readonly UNSENT = 0;
-    readonly OPENED = 1;
-    readonly HEADERS_RECEIVED = 2;
-    readonly LOADING = 3;
-    readonly DONE = 4;
+    readonly UNSENT: 0;
+    readonly OPENED: 1;
+    readonly HEADERS_RECEIVED: 2;
+    readonly LOADING: 3;
+    readonly DONE: 4;
     get readyState(): number;
     get response(): any;
     get responseText(): string;
@@ -579,42 +358,6 @@ declare class XMLHttpRequestP extends XMLHttpRequestEventTargetP implements XMLH
         hierarchy: string[];
     };
 }
-declare const _handlers: unique symbol;
-declare const _inAfterOpenBeforeSend: unique symbol;
-declare const _resetPending: unique symbol;
-declare const _timeoutId: unique symbol;
-declare const _requestURL: unique symbol;
-declare const _method: unique symbol;
-declare const _requestHeaders: unique symbol;
-declare const _responseHeaders: unique symbol;
-declare const _responseContentLength: unique symbol;
-declare const _requestTask: unique symbol;
-declare class XMLHttpRequestState {
-    constructor(target: XMLHttpRequestP);
-    target: XMLHttpRequestP;
-    readyState: number;
-    response: any;
-    responseType: XMLHttpRequestResponseType;
-    responseURL: string;
-    status: number;
-    statusText: string;
-    timeout: number;
-    upload: XMLHttpRequestUploadP;
-    withCredentials: boolean;
-    [_handlers]: {
-        onreadystatechange: (ev: Event) => void;
-    };
-    onreadystatechange: ((this: XMLHttpRequest, ev: Event) => any) | null;
-    [_inAfterOpenBeforeSend]: boolean;
-    [_resetPending]: boolean;
-    [_timeoutId]: number;
-    [_requestURL]: string;
-    [_method]: string;
-    [_requestHeaders]: Record<string, string>;
-    [_responseHeaders]: Record<string, string> | null;
-    [_responseContentLength]: number | (() => number);
-    [_requestTask]: IRequestTask | null;
-}
 declare const XMLHttpRequestE: {
     new (): XMLHttpRequest;
     prototype: XMLHttpRequest;
@@ -628,10 +371,8 @@ declare const XMLHttpRequestE: {
 declare function fetchP(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
 declare const fetchE: typeof fetch;
 
-declare const state$3: unique symbol;
 declare class HeadersP implements Headers {
     constructor(init?: HeadersInit);
-    [state$3]: HeadersState;
     append(name: string, value: string): void;
     delete(name: string): void;
     get(name: string): string | null;
@@ -649,25 +390,18 @@ declare class HeadersP implements Headers {
         hierarchy: string[];
     };
 }
-declare const _headersMap: unique symbol;
-declare class HeadersState {
-    [_headersMap]: Map<string, [string, string]>;
-}
 declare const HeadersE: {
     new (init?: HeadersInit): Headers;
     prototype: Headers;
 };
 
-declare const state$2: unique symbol;
-
 declare class BodyP implements Body {
     constructor();
-    [state$2]: BodyState;
-    get body(): ReadableStream<TUint8ArrayOfArrayBuffer> | null;
+    get body(): Body["body"];
     get bodyUsed(): boolean;
     arrayBuffer(): Promise<ArrayBuffer>;
     blob(): Promise<Blob>;
-    bytes(): Promise<TUint8ArrayOfArrayBuffer>;
+    bytes(): Promise<Uint8Array<ArrayBuffer>>;
     formData(): Promise<FormData>;
     json(): Promise<any>;
     text(): Promise<string>;
@@ -677,18 +411,9 @@ declare class BodyP implements Body {
         hierarchy: string[];
     };
 }
-declare const _name: unique symbol;
-declare const _body: unique symbol;
-declare class BodyState {
-    bodyUsed: boolean;
-    [_name]: string;
-    [_body]: string | ArrayBuffer;
-}
 
-declare const state$1: unique symbol;
 declare class RequestP extends BodyP implements Request {
     constructor(input: RequestInfo | URL, init?: RequestInit);
-    [state$1]: RequestState;
     get cache(): RequestCache;
     get credentials(): RequestCredentials;
     get destination(): RequestDestination;
@@ -709,31 +434,13 @@ declare class RequestP extends BodyP implements Request {
         hierarchy: string[];
     };
 }
-declare class RequestState {
-    cache: RequestCache;
-    credentials: RequestCredentials;
-    destination: RequestDestination;
-    headers?: Headers;
-    integrity: string;
-    keepalive: boolean;
-    method: string;
-    mode: RequestMode;
-    redirect: RequestRedirect;
-    referrer: string;
-    referrerPolicy: ReferrerPolicy;
-    signal?: AbortSignal;
-    url: string;
-}
 declare const RequestE: {
     new (input: RequestInfo | URL, init?: RequestInit): Request;
     prototype: Request;
 };
 
-declare const state: unique symbol;
-
 declare class ResponseP extends BodyP implements Response {
     constructor(body?: BodyInit | null, init?: ResponseInit);
-    [state]: ResponseState;
     get headers(): Headers;
     get ok(): boolean;
     get redirected(): boolean;
@@ -751,15 +458,6 @@ declare class ResponseP extends BodyP implements Response {
         hierarchy: string[];
     };
 }
-declare class ResponseState {
-    headers?: Headers;
-    ok: boolean;
-    redirected: boolean;
-    status: number;
-    statusText: string;
-    type: ResponseType;
-    url: string;
-}
 declare const ResponseE: {
     new (body?: BodyInit | null, init?: ResponseInit): Response;
     prototype: Response;