mphttpx 1.0.1 → 1.0.3

package/dist/index.d.ts

@@ -13,13 +13,13 @@ declare const TextEncoderE: {
     prototype: TextEncoder;
 };
 
-declare const state$9: unique symbol;
+declare const state$h: unique symbol;
 declare class TextDecoderP implements TextDecoder {
     constructor(utfLabel?: string, { fatal, ignoreBOM }?: {
         fatal?: boolean | undefined;
         ignoreBOM?: boolean | undefined;
     });
-    [state$9]: TextDecoderState;
+    [state$h]: TextDecoderState;
     get encoding(): string;
     get fatal(): boolean;
     get ignoreBOM(): boolean;
@@ -32,11 +32,13 @@ 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[];
+    [_bomSeen]: boolean;
+    [_partial]: number[];
 }
 type TAllowSharedBufferSource = NonNullable<Parameters<TextDecoder["decode"]>[0]>;
 declare const TextDecoderE: {
@@ -44,7 +46,7 @@ declare const TextDecoderE: {
     prototype: TextDecoder;
 };
 
-declare const state$8: unique symbol;
+declare const state$g: unique symbol;
 
 declare class EventP implements Event {
     static readonly NONE = 0;
@@ -52,7 +54,7 @@ declare class EventP implements Event {
     static readonly AT_TARGET = 2;
     static readonly BUBBLING_PHASE = 3;
     constructor(type: string, eventInitDict?: EventInit);
-    [state$8]: EventState;
+    [state$g]: EventState;
     get type(): string;
     get bubbles(): boolean;
     get cancelable(): boolean;
@@ -65,16 +67,17 @@ declare class EventP implements Event {
     readonly AT_TARGET = 2;
     readonly BUBBLING_PHASE = 3;
     get srcElement(): EventTarget | null;
-    cancelBubble: boolean;
+    get cancelBubble(): boolean;
+    set cancelBubble(value: boolean);
     get defaultPrevented(): boolean;
     get returnValue(): boolean;
     set returnValue(value: boolean);
     get isTrusted(): boolean;
     get timeStamp(): number;
     composedPath(): EventTarget[];
-    initEvent: (type: string, bubbles?: boolean, cancelable?: boolean) => void;
-    preventDefault: () => void;
-    stopImmediatePropagation: () => void;
+    initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;
+    preventDefault(): void;
+    stopImmediatePropagation(): void;
     stopPropagation(): void;
     toString(): string;
     get isPolyfill(): {
@@ -82,8 +85,14 @@ 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;
+    static [_TimeStamp]: number;
     type: string;
     bubbles: boolean;
     cancelable: boolean;
@@ -91,14 +100,15 @@ declare class EventState {
     target: EventTarget | null;
     currentTarget: EventTarget | null;
     eventPhase: number;
+    cancelBubble: boolean;
     defaultPrevented: boolean;
     returnValue: boolean;
-    isTrusted: boolean;
     timeStamp: number;
-    _passive: boolean;
-    _dispatched: boolean;
-    _preventDefaultCalled: boolean;
-    _stopImmediatePropagationCalled: boolean;
+    [_isTrusted]: boolean;
+    [_passive]: boolean;
+    [_dispatched]: boolean;
+    [_preventDefaultCalled]: boolean;
+    [_stopImmediatePropagationCalled]: boolean;
 }
 declare const EventE: {
     new (type: string, eventInitDict?: EventInit): Event;
@@ -109,11 +119,11 @@ declare const EventE: {
     readonly BUBBLING_PHASE: 3;
 };
 
-declare const state$7: unique symbol;
+declare const state$f: unique symbol;
 
 declare class EventTargetP implements EventTarget {
     constructor();
-    [state$7]: EventTargetState;
+    [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;
@@ -123,15 +133,13 @@ declare class EventTargetP implements EventTarget {
         hierarchy: string[];
     };
 }
+declare const _executors: unique symbol;
 declare class EventTargetState {
     constructor(target: EventTargetP);
     target: EventTargetP;
-    executors: Executor[];
-    fire(event: EventP): boolean;
-    reply(signal: AbortSignal, executor: Executor): void;
+    [_executors]: Executor[];
 }
 declare class Executor {
-    static extract(cb: EventListenerOrEventListenerObject | null): EventListener | null;
     constructor(type: string, callback: EventListenerOrEventListenerObject | null);
     type: string;
     callback: EventListener | null;
@@ -143,10 +151,10 @@ declare const EventTargetE: {
     prototype: EventTarget;
 };
 
-declare const state$6: unique symbol;
+declare const state$e: unique symbol;
 declare class CustomEventP<T> extends EventP implements CustomEvent {
     constructor(type: string, eventInitDict?: CustomEventInit<T>);
-    [state$6]: CustomEventState;
+    [state$e]: CustomEventState;
     get detail(): T;
     initCustomEvent(type: string, bubbles?: boolean, cancelable?: boolean, detail?: T): void;
     toString(): string;
@@ -163,10 +171,10 @@ declare const CustomEventE: {
     prototype: CustomEvent;
 };
 
-declare const state$5: unique symbol;
+declare const state$d: unique symbol;
 declare class ProgressEventP extends EventP implements ProgressEvent {
     constructor(type: string, eventInitDict?: ProgressEventInit);
-    [state$5]: ProgressEventState;
+    [state$d]: ProgressEventState;
     get lengthComputable(): boolean;
     get loaded(): number;
     get total(): number;
@@ -177,18 +185,20 @@ declare class ProgressEventP extends EventP implements ProgressEvent {
     };
 }
 declare class ProgressEventState {
-    lengthComputable: boolean;
-    loaded: number;
-    total: number;
+    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$8]: BlobState;
+    [state$c]: BlobState;
     get size(): number;
     get type(): string;
     arrayBuffer(): Promise<ArrayBuffer>;
@@ -202,11 +212,12 @@ declare class BlobP implements Blob {
         hierarchy: string[];
     };
 }
+declare const _u8array: unique symbol;
 declare class BlobState {
     constructor(buffer: TUint8ArrayOfArrayBuffer);
     size: number;
     type: string;
-    _u8array: TUint8ArrayOfArrayBuffer;
+    [_u8array]: TUint8ArrayOfArrayBuffer;
 }
 type TUint8ArrayOfArrayBuffer = ReturnType<TextEncoder["encode"]>;
 declare const BlobE: {
@@ -214,10 +225,10 @@ declare const BlobE: {
     prototype: Blob;
 };
 
-declare const state$4: unique symbol;
+declare const state$b: unique symbol;
 declare class FileP extends BlobP implements File {
     constructor(fileBits: BlobPart[], fileName: string, options?: FilePropertyBag);
-    [state$4]: FileState;
+    [state$b]: FileState;
     get lastModified(): number;
     get name(): string;
     get webkitRelativePath(): string;
@@ -236,13 +247,13 @@ declare const FileE: {
     prototype: File;
 };
 
-declare const state$3: unique symbol;
+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;
     constructor();
-    [state$3]: FileReaderState;
+    [state$a]: FileReaderState;
     get readyState(): 0 | 1 | 2;
     get result(): string | ArrayBuffer | null;
     readonly EMPTY = 0;
@@ -272,27 +283,27 @@ 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;
-    read(kind: string, blob: Blob, setResult: () => void): void;
-    emitProcessEvent(type: string, loaded?: number, total?: number): void;
-    attach(type: keyof FileReaderEventMap): void;
+    [_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;
-    _onabort: (ev: ProgressEvent<FileReader>) => void;
     onerror: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
-    _onerror: (ev: ProgressEvent<FileReader>) => void;
     onload: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
-    _onload: (ev: ProgressEvent<FileReader>) => void;
     onloadend: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
-    _onloadend: (ev: ProgressEvent<FileReader>) => void;
     onloadstart: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
-    _onloadstart: (ev: ProgressEvent<FileReader>) => void;
     onprogress: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
-    _onprogress: (ev: ProgressEvent<FileReader>) => void;
 }
 declare const FileReaderE: {
     new (): FileReader;
@@ -302,9 +313,11 @@ declare const FileReaderE: {
     readonly DONE: 2;
 };
 
+declare const state$9: unique symbol;
+
 declare class FormDataP implements FormData {
     constructor(form?: HTMLFormElement, submitter?: HTMLElement | null);
-    [state$8]: FormDataState;
+    [state$9]: FormDataState;
     append(name: string, value: string | Blob, filename?: string): void;
     delete(name: string): void;
     get(name: string): FormDataEntryValue | null;
@@ -322,8 +335,9 @@ declare class FormDataP implements FormData {
         hierarchy: string[];
     };
 }
+declare const _formData: unique symbol;
 declare class FormDataState {
-    _data: [string, FormDataEntryValue][];
+    [_formData]: [string, FormDataEntryValue][];
     toBlob(): BlobP;
 }
 declare const FormDataE: {
@@ -331,6 +345,7 @@ declare const FormDataE: {
     prototype: FormData;
 };
 
+declare const state$8: unique symbol;
 declare class URLSearchParamsP implements URLSearchParams {
     constructor(init?: string[][] | Record<string, string> | string | URLSearchParams);
     [state$8]: URLSearchParamsState;
@@ -353,20 +368,23 @@ declare class URLSearchParamsP implements URLSearchParams {
         hierarchy: string[];
     };
 }
+declare const _urlspDict: unique symbol;
 declare class URLSearchParamsState {
-    _dict: Record<string, string[]>;
+    [_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$8]: AbortSignalState;
+    [state$7]: AbortSignalState;
     get aborted(): boolean;
     get reason(): any;
     throwIfAborted(): void;
@@ -378,14 +396,16 @@ 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;
-    abort(reason: any, notify?: boolean, isTrusted?: boolean): void;
+    [_handlers$2]: {
+        onabort: (ev: Event) => void;
+    };
     onabort: ((this: AbortSignal, ev: Event) => any) | null;
-    _onabort: (ev: Event) => void;
 }
 declare const AbortSignalE: {
     new (): AbortSignal;
@@ -395,10 +415,10 @@ declare const AbortSignalE: {
     timeout(milliseconds: number): AbortSignal;
 };
 
-declare const state$2: unique symbol;
+declare const state$6: unique symbol;
 declare class AbortControllerP implements AbortController {
     constructor();
-    [state$2]: AbortControllerState;
+    [state$6]: AbortControllerState;
     get signal(): AbortSignal;
     abort(reason?: any): void;
     toString(): string;
@@ -415,9 +435,11 @@ declare const AbortControllerE: {
     prototype: AbortController;
 };
 
+declare const state$5: unique symbol;
+
 declare class XMLHttpRequestEventTargetP extends EventTargetP implements XMLHttpRequestEventTarget {
     constructor();
-    [state$8]: XMLHttpRequestEventTargetState;
+    [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;
@@ -438,27 +460,29 @@ 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;
-    attach(type: keyof XMLHttpRequestEventTargetEventMap): void;
+    [_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;
-    _onabort: (ev: ProgressEvent) => void;
     onerror: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
-    _onerror: (ev: ProgressEvent) => void;
     onload: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
-    _onload: (ev: ProgressEvent) => void;
     onloadend: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
-    _onloadend: (ev: ProgressEvent) => void;
     onloadstart: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
-    _onloadstart: (ev: ProgressEvent) => void;
     onprogress: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
-    _onprogress: (ev: ProgressEvent) => void;
     ontimeout: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
-    _ontimeout: (ev: ProgressEvent) => void;
 }
 
 declare class XMLHttpRequestUploadP extends XMLHttpRequestEventTargetP implements XMLHttpRequestUpload {
@@ -470,83 +494,6 @@ declare class XMLHttpRequestUploadP extends XMLHttpRequestEventTargetP implement
     };
 }
 
-interface IGeneralCallbackResult {
-    /**
-     * 网络请求过程中的一些异常信息，例如httpdns超时等
-     */
-    exception: {
-        /**
-         * 本次请求底层重试次数
-         */
-        retryCount: number;
-        /**
-         * 本次请求底层失败信息，所有失败信息均符合Errno错误码
-         */
-        reasons: Array<{
-            /**
-             * 错误原因
-             */
-            errMsg: string;
-            /**
-             * 错误码
-             */
-            errno: number;
-        }>;
-    };
-    /**
-     * 最终请求是否使用了HttpDNS解析的IP。仅当enableHttpDNS传true时返回此字段。如果开启enableHttpDNS但最终请求未使用HttpDNS解析的IP，可在exception查看原因。
-     */
-    useHttpDNS: boolean;
-}
-interface IRequestSuccessCallbackBaseResult {
-    /**
-     * 开发者服务器返回的数据
-     */
-    data: string | object | ArrayBuffer;
-    /**
-     * 开发者服务器返回的 HTTP 状态码
-     */
-    statusCode: number;
-    /**
-     * 开发者服务器返回的 HTTP Response Header
-     */
-    header: object;
-}
-interface IRequestFailCallbackResult extends IGeneralCallbackResult {
-    /**
-     * 错误信息
-     */
-    errMsg: string;
-    /**
-     * errno 错误码
-     */
-    errno: number;
-}
-interface IAliRequestFailCallbackResult {
-    /**
-     * 错误码
-     */
-    error: number;
-    /**
-     * 错误信息
-     */
-    errorMessage: string;
-    /**
-     * 开发者服务器返回的数据，格式取决于请求时的 dataType 参数。
-     * 注意：当错误码为 14 或 19 时才会返回此字段
-     */
-    data?: string | object | ArrayBuffer;
-    /**
-     * 开发者服务器返回的 HTTP 状态码
-     * 注意：当错误码为 14 或 19 时才会返回此字段
-     */
-    status?: number;
-    /**
-     * 开发者服务器返回的 HTTP Response Header
-     * 注意：当错误码为 14 或 19 时才会返回此字段
-     */
-    headers?: object;
-}
 interface IRequestTask {
     /**
      * 中断请求任务
@@ -588,7 +535,7 @@ interface IRequestTask {
     offChunkReceived: (listener: Function) => void;
 }
 
-declare const state$1: unique symbol;
+declare const state$4: unique symbol;
 
 declare class XMLHttpRequestP extends XMLHttpRequestEventTargetP implements XMLHttpRequest {
     static readonly UNSENT = 0;
@@ -597,7 +544,7 @@ declare class XMLHttpRequestP extends XMLHttpRequestEventTargetP implements XMLH
     static readonly LOADING = 3;
     static readonly DONE = 4;
     constructor();
-    [state$1]: XMLHttpRequestState;
+    [state$4]: XMLHttpRequestState;
     readonly UNSENT = 0;
     readonly OPENED = 1;
     readonly HEADERS_RECEIVED = 2;
@@ -614,7 +561,7 @@ declare class XMLHttpRequestP extends XMLHttpRequestEventTargetP implements XMLH
     get statusText(): string;
     get timeout(): number;
     set timeout(value: number);
-    get upload(): XMLHttpRequestUploadP;
+    get upload(): XMLHttpRequestUpload;
     get withCredentials(): boolean;
     set withCredentials(value: boolean);
     abort(): void;
@@ -632,6 +579,16 @@ 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;
@@ -644,27 +601,19 @@ declare class XMLHttpRequestState {
     timeout: number;
     upload: XMLHttpRequestUploadP;
     withCredentials: boolean;
-    _reqCanSend: boolean;
-    _resetPending: boolean;
-    _timeoutId: number;
-    _reqURL: string;
-    _method: string;
-    _reqHeaders: Record<string, string>;
-    _resHeaders: Record<string, string> | null;
-    _resContLen: number;
-    _requestTask: IRequestTask | null;
-    execRequest(body?: Document | XMLHttpRequestBodyInit | null): void;
-    requestSuccess({ statusCode, header, data }: IRequestSuccessCallbackBaseResult): void;
-    requestFail(err: IRequestFailCallbackResult | IAliRequestFailCallbackResult): void;
-    requestComplete(): void;
-    clearRequest(delay?: boolean): void;
-    checkRequestTimeout(): void;
-    resetXHR(): void;
-    resetRequestTimeout(): void;
-    emitProcessEvent(type: string, loaded?: number, total?: number, target?: XMLHttpRequestEventTargetP): void;
-    setReadyStateAndNotify(value: number): void;
+    [_handlers]: {
+        onreadystatechange: (ev: Event) => void;
+    };
     onreadystatechange: ((this: XMLHttpRequest, ev: Event) => any) | null;
-    _onreadystatechange: (ev: Event) => void;
+    [_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;
@@ -679,9 +628,10 @@ 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$8]: HeadersState;
+    [state$3]: HeadersState;
     append(name: string, value: string): void;
     delete(name: string): void;
     get(name: string): string | null;
@@ -699,19 +649,20 @@ declare class HeadersP implements Headers {
         hierarchy: string[];
     };
 }
+declare const _headersMap: unique symbol;
 declare class HeadersState {
-    _map: Map<string, [string, string]>;
+    [_headersMap]: Map<string, [string, string]>;
 }
 declare const HeadersE: {
     new (init?: HeadersInit): Headers;
     prototype: Headers;
 };
 
-declare const state: unique symbol;
+declare const state$2: unique symbol;
 
 declare class BodyP implements Body {
     constructor();
-    [state]: BodyState;
+    [state$2]: BodyState;
     get body(): ReadableStream<TUint8ArrayOfArrayBuffer> | null;
     get bodyUsed(): boolean;
     arrayBuffer(): Promise<ArrayBuffer>;
@@ -726,23 +677,18 @@ 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;
-    init(body?: ConstructorParameters<typeof Response>[0], headers?: Headers): void;
-    read(k: "arrayBuffer"): Promise<ArrayBuffer>;
-    read(k: "blob"): Promise<Blob>;
-    read(k: "bytes"): Promise<TUint8ArrayOfArrayBuffer>;
-    read(k: "formData"): Promise<FormData>;
-    read(k: "json"): Promise<any>;
-    read(k: "text"): Promise<string>;
-    consumed(kind: string): Promise<never> | undefined;
+    [_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$8]: RequestState;
+    [state$1]: RequestState;
     get cache(): RequestCache;
     get credentials(): RequestCredentials;
     get destination(): RequestDestination;
@@ -767,7 +713,7 @@ declare class RequestState {
     cache: RequestCache;
     credentials: RequestCredentials;
     destination: RequestDestination;
-    headers: Headers;
+    headers?: Headers;
     integrity: string;
     keepalive: boolean;
     method: string;
@@ -775,7 +721,7 @@ declare class RequestState {
     redirect: RequestRedirect;
     referrer: string;
     referrerPolicy: ReferrerPolicy;
-    signal: AbortSignal;
+    signal?: AbortSignal;
     url: string;
 }
 declare const RequestE: {
@@ -783,9 +729,11 @@ declare const RequestE: {
     prototype: Request;
 };
 
+declare const state: unique symbol;
+
 declare class ResponseP extends BodyP implements Response {
     constructor(body?: BodyInit | null, init?: ResponseInit);
-    [state$8]: ResponseState;
+    [state]: ResponseState;
     get headers(): Headers;
     get ok(): boolean;
     get redirected(): boolean;
@@ -804,7 +752,7 @@ declare class ResponseP extends BodyP implements Response {
     };
 }
 declare class ResponseState {
-    headers: Headers;
+    headers?: Headers;
     ok: boolean;
     redirected: boolean;
     status: number;