@wevu/web-apis 1.2.42 → 1.3.1

package/README.md

@@ -146,3 +146,31 @@ pnpm --filter @wevu/web-apis typecheck
 
 - 新项目建议使用 `installWebRuntimeGlobals()`
 - `installRequestGlobals()` 仍保留为兼容别名，后续会逐步淡出文档主叙事
+
+## 11. Body 与 Blob 契约
+
+`RequestPolyfill` 和 `ResponsePolyfill` 提供 `bytes()`、`arrayBuffer()`、`text()`、`json()`、`blob()`。非 null body 只能消费一次；读取开始时 `bodyUsed` 就会变成 `true`，重复或并发读取会拒绝为 `TypeError`，读取后调用 `clone()` 也会抛错。需要多种读取方式时，请在消费前 clone：
+
+```ts
+import { ResponsePolyfill } from '@wevu/web-apis'
+
+const response = new ResponsePolyfill('{"ok":true}', {
+  headers: { 'content-type': 'application/json' },
+})
+const copy = response.clone()
+const payload = await response.json()
+const bytes = await copy.bytes()
+```
+
+null body 读取为空且保持未消费；空字符串和零长度二进制属于非 null body。JSON 解析失败或底层读取失败后，非 null body 仍保持已消费。`fetch(request)` 消费被继承的请求 body；`new RequestPolyfill(request)` 转移该 body，消费前 `request.clone()` 则保留两份独立的读取状态。
+
+| 能力              | 支持范围                                                                                                   |
+| ----------------- | ---------------------------------------------------------------------------------------------------------- |
+| Body 读取与 clone | 缓冲 body 的单次消费、独立 clone、MIME 传递；ponyfill 的 `blob()` 不要求先安装全局 Blob                    |
+| Blob / File       | UTF-8 字节长度、BufferSource 构造快照、独立 `bytes()`、负索引及越界 `slice()`、MIME 规范化                 |
+| Headers.forEach   | 回调参数 `(value, key, headers)` 和可选 `thisArg`                                                          |
+| BlobLike 扩展输入 | 保留异步 `arrayBuffer()` 兼容；无有效 `size` 的自定义对象不保证同步 size/切片语义，也不保证其自身不可变    |
+| Streams           | 未支持；`Request.body` / `Response.body` 仍为 null，不能据此判断缓冲 body 是否为空；未提供 `Blob.stream()` |
+| formData()        | 未支持响应解析；FormData 请求上传继续支持 multipart 编码                                                   |
+
+这些是本包 ponyfill 的能力边界。安装器保留可用的宿主实现，宿主对象的方法完整性应按目标基础库确认。

package/dist/abort.d.mts

@@ -1,4 +1,4 @@
-import { RequestGlobalsEventTarget } from "./shared.mjs";
+import { i as RequestGlobalsEventTarget } from "./shared-Dc42USJC.mjs";
 //#region src/abort.d.ts
 export declare class AbortSignalPolyfill extends RequestGlobalsEventTarget {
   aborted: boolean;

package/dist/fetch.d.mts

@@ -1,5 +1,5 @@
 import { RequestGlobalsMiniProgramOptions } from "./networkDefaults.mjs";
-import { URLPolyfill } from "./url.mjs";
+import { t as URLPolyfill } from "./url-D0ANYIyk.mjs";
 //#region src/fetch.d.ts
 interface RequestLikeInput {
   url: string;

package/dist/fetch.mjs

@@ -1,3 +1,188 @@
-import "./http.mjs";
-import { t as fetch } from "./fetch-BPqcYqI3.mjs";
+import { d as normalizeHeaderName, h as isUrlSearchParamsInstance, l as isArrayBufferLike, m as isUrlInstance, n as cloneArrayBuffer, r as cloneArrayBufferView, u as isBlobLike } from "./shared-BsJRaiBh.mjs";
+import { a as encodeMultipartFormData, i as consumeBodyValue, n as RequestPolyfill, o as HeadersPolyfill, t as ResponsePolyfill } from "./http-C-VyEBss.mjs";
+import { t as FormDataPolyfill } from "./web-kSAO_PSD.mjs";
+import { resolveRequestMiniProgramOptions } from "./networkDefaults.mjs";
+import { wpi } from "@wevu/api";
+//#region src/fetch.ts
+const REQUEST_METHODS = [
+	"GET",
+	"HEAD",
+	"OPTIONS",
+	"POST",
+	"PUT",
+	"DELETE",
+	"TRACE",
+	"CONNECT"
+];
+const hasOwn = Object.prototype.hasOwnProperty;
+function isObject(value) {
+	return typeof value === "object" && value !== null;
+}
+function createAbortError() {
+	if (typeof DOMException === "function") return new DOMException("The operation was aborted.", "AbortError");
+	const error = /* @__PURE__ */ new Error("The operation was aborted.");
+	error.name = "AbortError";
+	return error;
+}
+function normalizeMethod(method) {
+	const normalized = (method ?? "GET").toUpperCase();
+	if (REQUEST_METHODS.includes(normalized)) return normalized;
+	return "GET";
+}
+function setHeader(target, key, value) {
+	const normalizedKey = normalizeHeaderName(key);
+	if (!normalizedKey) return;
+	const nextValue = String(value);
+	for (const currentKey of Object.keys(target)) if (normalizeHeaderName(currentKey) === normalizedKey) delete target[currentKey];
+	target[key] = nextValue;
+}
+function hasHeader(target, key) {
+	const normalizedKey = normalizeHeaderName(key);
+	return Object.keys(target).some((currentKey) => normalizeHeaderName(currentKey) === normalizedKey);
+}
+function mergeHeaderSource(target, source) {
+	if (!source) return;
+	if (typeof source[Symbol.iterator] === "function") {
+		for (const entry of source) {
+			if (!entry || entry.length < 2) continue;
+			setHeader(target, entry[0], entry[1]);
+		}
+		return;
+	}
+	if (typeof source.forEach === "function") {
+		source.forEach((value, key) => {
+			setHeader(target, key, value);
+		});
+		return;
+	}
+	if (!isObject(source)) return;
+	for (const [key, value] of Object.entries(source)) {
+		if (Array.isArray(value)) {
+			setHeader(target, key, value.join(", "));
+			continue;
+		}
+		setHeader(target, key, value);
+	}
+}
+function toHeaderMap(source) {
+	const headers = {};
+	mergeHeaderSource(headers, source);
+	return headers;
+}
+function isRequestLikeInput(input) {
+	return isObject(input) && typeof input.url === "string";
+}
+function isFormDataInstance(value) {
+	return Boolean(value && typeof value === "object" && (typeof FormData !== "undefined" && value instanceof FormData || value instanceof FormDataPolyfill));
+}
+async function extractRequestBodyFromInput(input) {
+	if (!input || typeof input.clone !== "function") return;
+	if (input.bodyUsed) throw new TypeError("Failed to execute fetch: request body is already used");
+	if (input instanceof RequestPolyfill) return consumeBodyValue(input);
+	const body = input;
+	if (body.arrayBuffer) return body.arrayBuffer();
+	if (body.text) return body.text();
+	const cloned = input.clone();
+	if (cloned?.arrayBuffer) return cloned.arrayBuffer();
+	if (cloned?.text) return cloned.text();
+}
+async function normalizeRequestBody(body, headers) {
+	if (body == null) return;
+	if (typeof body === "string") {
+		if (!hasHeader(headers, "content-type")) headers["content-type"] = "text/plain;charset=UTF-8";
+		return body;
+	}
+	if (isUrlSearchParamsInstance(body)) {
+		if (!hasHeader(headers, "content-type")) headers["content-type"] = "application/x-www-form-urlencoded;charset=UTF-8";
+		return body.toString();
+	}
+	if (isArrayBufferLike(body)) return cloneArrayBuffer(body);
+	if (ArrayBuffer.isView(body)) return cloneArrayBufferView(body);
+	if (isBlobLike(body)) {
+		if (body.type && !hasHeader(headers, "content-type")) headers["content-type"] = body.type;
+		return body.arrayBuffer();
+	}
+	if (isFormDataInstance(body)) {
+		const payload = await encodeMultipartFormData(body);
+		if (!hasHeader(headers, "content-type")) headers["content-type"] = payload.contentType;
+		return payload.body;
+	}
+	return String(body);
+}
+async function resolveRequestMeta(input, init = {}) {
+	const requestInput = isRequestLikeInput(input) ? input : void 0;
+	const url = typeof input === "string" ? input : isUrlInstance(input) ? input.toString() : requestInput?.url;
+	if (!url) throw new TypeError("Failed to execute fetch: invalid request url");
+	const method = normalizeMethod(init.method ?? requestInput?.method);
+	const headers = toHeaderMap(requestInput?.headers);
+	mergeHeaderSource(headers, init.headers);
+	const hasBodyInInit = hasOwn.call(init, "body");
+	let rawBody = hasBodyInInit ? init.body : await extractRequestBodyFromInput(requestInput);
+	if (!hasBodyInInit && requestInput && (method === "GET" || method === "HEAD")) rawBody = void 0;
+	if ((method === "GET" || method === "HEAD") && rawBody != null) throw new TypeError("Failed to execute fetch: GET/HEAD request cannot have body");
+	return {
+		miniProgram: resolveRequestMiniProgramOptions(init.miniProgram, init.miniprogram),
+		url,
+		method,
+		headers,
+		body: await normalizeRequestBody(rawBody, headers),
+		signal: init.signal ?? requestInput?.signal ?? null
+	};
+}
+function createFetchResponse(data, status, headers, url) {
+	return new ResponsePolyfill(data instanceof Uint8Array ? cloneArrayBufferView(data) : data, {
+		status,
+		headers: new HeadersPolyfill(headers),
+		url
+	});
+}
+function isRequestTask(value) {
+	return isObject(value) && typeof value.abort === "function";
+}
+/**
+* @description 使用 @wevu/api 的 request 能力实现 fetch 语义对齐。
+*/
+function fetch(input, init) {
+	return resolveRequestMeta(input, init).then((meta) => {
+		if (meta.signal?.aborted) return Promise.reject(createAbortError());
+		return new Promise((resolve, reject) => {
+			let settled = false;
+			let requestTask;
+			function onAbort() {
+				if (settled) return;
+				requestTask?.abort();
+				settled = true;
+				if (meta.signal) meta.signal.removeEventListener("abort", onAbort);
+				reject(createAbortError());
+			}
+			function cleanup() {
+				if (meta.signal) meta.signal.removeEventListener("abort", onAbort);
+			}
+			if (meta.signal) meta.signal.addEventListener("abort", onAbort, { once: true });
+			const requestResult = wpi.request({
+				...meta.miniProgram,
+				url: meta.url,
+				method: meta.method,
+				header: meta.headers,
+				data: meta.body,
+				responseType: "arraybuffer",
+				success: (res) => {
+					if (settled) return;
+					settled = true;
+					cleanup();
+					resolve(createFetchResponse(res.data, res.statusCode, toHeaderMap(res.header), meta.url));
+				},
+				fail: (error) => {
+					if (settled) return;
+					settled = true;
+					cleanup();
+					const message = isObject(error) && typeof error.errMsg === "string" ? error.errMsg : String(error);
+					reject(new TypeError(message));
+				}
+			});
+			requestTask = isRequestTask(requestResult) ? requestResult : void 0;
+		});
+	});
+}
+//#endregion
 export { fetch };

package/dist/http-C-VyEBss.mjs

@@ -0,0 +1,303 @@
+import { d as normalizeHeaderName, h as isUrlSearchParamsInstance, i as decodeText, l as isArrayBufferLike, m as isUrlInstance, n as cloneArrayBuffer, o as encodeText, r as cloneArrayBufferView, u as isBlobLike } from "./shared-BsJRaiBh.mjs";
+import { r as BlobPolyfill, t as FormDataPolyfill } from "./web-kSAO_PSD.mjs";
+//#region src/http/headers.ts
+const SET_COOKIE_HEADER_NAME = "set-cookie";
+function isIterableHeaders(input) {
+	return Boolean(input) && typeof input[Symbol.iterator] === "function";
+}
+function isHeaderObject(input) {
+	return typeof input === "object" && input !== null;
+}
+var HeadersPolyfill = class {
+	store = /* @__PURE__ */ new Map();
+	constructor(init) {
+		if (!init) return;
+		if (isIterableHeaders(init)) {
+			for (const [key, value] of init) this.append(key, value);
+			return;
+		}
+		if (typeof init.forEach === "function") {
+			init.forEach((value, key) => {
+				this.set(key, value);
+			});
+			return;
+		}
+		if (isHeaderObject(init)) for (const [key, value] of Object.entries(init)) this.append(key, Array.isArray(value) ? value.join(", ") : String(value));
+	}
+	append(key, value) {
+		const normalized = normalizeHeaderName(key);
+		if (!normalized) return;
+		const item = this.store.get(normalized);
+		if (item) {
+			item.values.push(String(value));
+			return;
+		}
+		this.store.set(normalized, {
+			key,
+			values: [String(value)]
+		});
+	}
+	set(key, value) {
+		const normalized = normalizeHeaderName(key);
+		if (!normalized) return;
+		this.store.set(normalized, {
+			key,
+			values: [String(value)]
+		});
+	}
+	get(key) {
+		return this.store.get(normalizeHeaderName(key))?.values.join(", ") ?? null;
+	}
+	getSetCookie() {
+		return this.store.get(SET_COOKIE_HEADER_NAME)?.values.slice() ?? [];
+	}
+	has(key) {
+		return this.store.has(normalizeHeaderName(key));
+	}
+	delete(key) {
+		this.store.delete(normalizeHeaderName(key));
+	}
+	forEach(callback, thisArg) {
+		for (const { key, values } of this.store.values()) callback.call(thisArg, values.join(", "), key, this);
+	}
+	entries() {
+		return Array.from(this.store.values(), (item) => [item.key, item.values.join(", ")])[Symbol.iterator]();
+	}
+	keys() {
+		return Array.from(this.store.values(), (item) => item.key)[Symbol.iterator]();
+	}
+	values() {
+		return Array.from(this.store.values(), (item) => item.values.join(", "))[Symbol.iterator]();
+	}
+	[Symbol.iterator]() {
+		return this.entries();
+	}
+};
+function headersToObject(headers) {
+	const result = {};
+	headers.forEach((value, key) => {
+		result[key] = value;
+	});
+	return result;
+}
+//#endregion
+//#region src/multipart.ts
+const CRLF = "\r\n";
+function createMultipartBoundary() {
+	return `----weapp-vite-formdata-${Math.random().toString(36).slice(2)}${Date.now().toString(36)}`;
+}
+function escapeMultipartName(value) {
+	return String(value).replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\r/g, "%0D").replace(/\n/g, "%0A");
+}
+function concatArrayBuffers(buffers) {
+	const totalLength = buffers.reduce((sum, buffer) => sum + buffer.byteLength, 0);
+	const merged = new Uint8Array(totalLength);
+	let offset = 0;
+	for (const buffer of buffers) {
+		merged.set(new Uint8Array(buffer), offset);
+		offset += buffer.byteLength;
+	}
+	return merged.buffer;
+}
+function isBlobFormDataValue(value) {
+	return typeof value !== "string" && typeof value?.arrayBuffer === "function";
+}
+function getMultipartFilename(value) {
+	const name = value.name;
+	return typeof name === "string" && name.length > 0 ? name : "blob";
+}
+async function createMultipartPart(name, value) {
+	if (!isBlobFormDataValue(value)) return [
+		encodeText(`Content-Disposition: form-data; name="${escapeMultipartName(name)}"${CRLF}${CRLF}`),
+		encodeText(String(value)),
+		encodeText(CRLF)
+	];
+	const filename = getMultipartFilename(value);
+	const headers = [
+		`Content-Disposition: form-data; name="${escapeMultipartName(name)}"; filename="${escapeMultipartName(filename)}"`,
+		`Content-Type: ${value.type || "application/octet-stream"}`,
+		"",
+		""
+	].join(CRLF);
+	return [
+		encodeText(headers),
+		await value.arrayBuffer(),
+		encodeText(CRLF)
+	];
+}
+async function encodeMultipartFormData(formData) {
+	const boundary = createMultipartBoundary();
+	const buffers = [];
+	for (const [name, value] of formData) {
+		buffers.push(encodeText(`--${boundary}${CRLF}`));
+		buffers.push(...await createMultipartPart(name, value));
+	}
+	buffers.push(encodeText(`--${boundary}--${CRLF}`));
+	return {
+		body: concatArrayBuffers(buffers),
+		contentType: `multipart/form-data; boundary=${boundary}`
+	};
+}
+//#endregion
+//#region src/http/body.ts
+const bodies = /* @__PURE__ */ new WeakMap();
+function isFormData(value) {
+	return value instanceof FormDataPolyfill || typeof FormData === "function" && value instanceof FormData;
+}
+function initializeBody(owner, input) {
+	let value;
+	let contentType = "";
+	if (input == null) value = null;
+	else if (isArrayBufferLike(input)) value = cloneArrayBuffer(input);
+	else if (ArrayBuffer.isView(input)) value = cloneArrayBufferView(input);
+	else if (isBlobLike(input)) {
+		value = input;
+		contentType = input.type ?? "";
+	} else if (isFormData(input)) value = input;
+	else if (isUrlSearchParamsInstance(input)) {
+		value = input.toString();
+		contentType = "application/x-www-form-urlencoded;charset=UTF-8";
+	} else {
+		value = String(input);
+		contentType = "text/plain;charset=UTF-8";
+	}
+	if (contentType && !owner.headers.has("content-type")) owner.headers.set("content-type", contentType);
+	bodies.set(owner, {
+		value,
+		used: false
+	});
+}
+function getBodyValue(owner) {
+	return bodies.get(owner)?.value;
+}
+function assertBodyUnused(owner) {
+	if (bodies.get(owner)?.used) throw new TypeError("Body has already been consumed");
+}
+/** 在异步转换之前同步占用 body，确保并发读取与请求发送共享消费状态。 */
+function consumeBodyValue(owner) {
+	assertBodyUnused(owner);
+	const state = bodies.get(owner);
+	if (state && state.value != null) state.used = true;
+	return state?.value;
+}
+async function bodyBytes(value) {
+	if (value == null) return /* @__PURE__ */ new ArrayBuffer(0);
+	if (typeof value === "string") return encodeText(value);
+	if (isArrayBufferLike(value)) return cloneArrayBuffer(value);
+	if (ArrayBuffer.isView(value)) return cloneArrayBufferView(value);
+	if (isBlobLike(value)) return cloneArrayBuffer(await value.arrayBuffer());
+	return (await encodeMultipartFormData(value)).body;
+}
+/** 仅供 Request/Response 内部复用，不作为包的公开导出。 */
+var HttpBody = class {
+	get body() {
+		return null;
+	}
+	get bodyUsed() {
+		return bodies.get(this)?.used === true;
+	}
+	async arrayBuffer() {
+		return bodyBytes(consumeBodyValue(this));
+	}
+	async bytes() {
+		return new Uint8Array(await this.arrayBuffer());
+	}
+	async text() {
+		return decodeText(await this.arrayBuffer());
+	}
+	async json() {
+		return JSON.parse(await this.text());
+	}
+	async blob() {
+		const bytes = await this.arrayBuffer();
+		const contentType = this.headers.get("content-type") ?? "";
+		const type = /^[!#$%&'*+.^`|~\w-]+\/[!#$%&'*+.^`|~\w-]+(?:\s*;[^\r\n]*)?$/.test(contentType) ? contentType : "";
+		return new (typeof Blob === "function" ? Blob : BlobPolyfill)([bytes], { type });
+	}
+	async formData() {
+		throw new TypeError("formData is not supported in Body polyfill");
+	}
+};
+//#endregion
+//#region src/http/request.ts
+var RequestPolyfill = class RequestPolyfill extends HttpBody {
+	url;
+	method;
+	headers;
+	signal;
+	[Symbol.toStringTag] = "Request";
+	constructor(input, init = {}) {
+		super();
+		const request = input instanceof RequestPolyfill ? input : void 0;
+		this.url = typeof input === "string" ? input : isUrlInstance(input) ? input.toString() : request?.url ?? "";
+		this.method = String(init.method ?? request?.method ?? "GET").toUpperCase();
+		this.headers = new HeadersPolyfill(init.headers ?? request?.headers);
+		this.signal = init.signal ?? request?.signal ?? null;
+		const inherited = init.body == null && request;
+		if (inherited) assertBodyUnused(request);
+		initializeBody(this, init.body ?? (request ? getBodyValue(request) : void 0));
+		if (inherited) consumeBodyValue(request);
+	}
+	clone() {
+		assertBodyUnused(this);
+		return new RequestPolyfill(this.url, {
+			method: this.method,
+			headers: this.headers,
+			signal: this.signal,
+			body: getBodyValue(this)
+		});
+	}
+};
+function getRequestBodyValue(request) {
+	return request ? getBodyValue(request) : void 0;
+}
+//#endregion
+//#region src/http/response.ts
+var ResponsePolyfill = class ResponsePolyfill extends HttpBody {
+	headers;
+	status;
+	statusText;
+	ok;
+	url;
+	redirected = false;
+	type;
+	[Symbol.toStringTag] = "Response";
+	constructor(body, init = {}) {
+		super();
+		this.status = Number.isFinite(init.status) ? init.status : 200;
+		this.statusText = init.statusText ?? "";
+		this.ok = this.status >= 200 && this.status < 300;
+		this.headers = new HeadersPolyfill(init.headers);
+		this.url = init.url ?? "";
+		this.type = init.type ?? "basic";
+		initializeBody(this, body);
+	}
+	static error() {
+		return new ResponsePolyfill(null, {
+			status: 0,
+			type: "error"
+		});
+	}
+	static json(data, init = {}) {
+		const body = JSON.stringify(data);
+		if (body === void 0) throw new TypeError("Failed to execute 'json' on 'Response': data is not JSON serializable");
+		const headers = new HeadersPolyfill(init.headers);
+		if (!headers.has("content-type")) headers.set("content-type", "application/json");
+		return new ResponsePolyfill(body, {
+			...init,
+			headers
+		});
+	}
+	clone() {
+		assertBodyUnused(this);
+		return new ResponsePolyfill(getBodyValue(this), {
+			status: this.status,
+			statusText: this.statusText,
+			headers: this.headers,
+			url: this.url,
+			type: this.type
+		});
+	}
+};
+//#endregion
+export { encodeMultipartFormData as a, consumeBodyValue as i, RequestPolyfill as n, HeadersPolyfill as o, getRequestBodyValue as r, headersToObject as s, ResponsePolyfill as t };

package/dist/http-CE8-CIHE.d.mts

@@ -0,0 +1,66 @@
+import { t as RequestGlobalsBlobLike } from "./shared-Dc42USJC.mjs";
+import { t as URLPolyfill } from "./url-D0ANYIyk.mjs";
+import { n as FormDataPolyfill, o as BlobPolyfill } from "./web-DNBBg6y9.mjs";
+//#region src/http/headers.d.ts
+type HeaderRecord = Record<string, string>;
+declare class HeadersPolyfill {
+  private readonly store;
+  constructor(init?: unknown);
+  append(key: string, value: string): void;
+  set(key: string, value: string): void;
+  get(key: string): string | null;
+  getSetCookie(): string[];
+  has(key: string): boolean;
+  delete(key: string): void;
+  forEach(callback: (value: string, key: string, parent: HeadersPolyfill) => void, thisArg?: unknown): void;
+  entries(): ArrayIterator<[string, string]>;
+  keys(): ArrayIterator<string>;
+  values(): ArrayIterator<string>;
+  [Symbol.iterator](): ArrayIterator<[string, string]>;
+}
+declare function headersToObject(headers: HeadersPolyfill | Headers): HeaderRecord;
+//#endregion
+//#region src/http/body.d.ts
+type RequestBodyLike = string | ArrayBuffer | ArrayBufferView | Blob | RequestGlobalsBlobLike | FormData | FormDataPolyfill | null | undefined;
+/** 仅供 Request/Response 内部复用，不作为包的公开导出。 */
+declare abstract class HttpBody {
+  abstract readonly headers: HeadersPolyfill;
+  get body(): ReadableStream<Uint8Array> | null;
+  get bodyUsed(): boolean;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  bytes(): Promise<Uint8Array<ArrayBuffer>>;
+  text(): Promise<string>;
+  json(): Promise<any>;
+  blob(): Promise<Blob | BlobPolyfill>;
+  formData(): Promise<FormData>;
+}
+//#endregion
+//#region src/http/request.d.ts
+declare class RequestPolyfill extends HttpBody {
+  readonly url: string;
+  readonly method: string;
+  readonly headers: HeadersPolyfill;
+  readonly signal: AbortSignal | null;
+  readonly [Symbol.toStringTag] = "Request";
+  constructor(input: string | URL | URLPolyfill | RequestPolyfill, init?: Record<string, any>);
+  clone(): RequestPolyfill;
+}
+declare function getRequestBodyValue(request?: RequestPolyfill): RequestBodyLike;
+//#endregion
+//#region src/http/response.d.ts
+declare class ResponsePolyfill extends HttpBody {
+  readonly headers: HeadersPolyfill;
+  readonly status: number;
+  readonly statusText: string;
+  readonly ok: boolean;
+  readonly url: string;
+  readonly redirected = false;
+  readonly type: ResponseType;
+  readonly [Symbol.toStringTag] = "Response";
+  constructor(body?: RequestBodyLike, init?: Record<string, any>);
+  static error(): ResponsePolyfill;
+  static json(data: unknown, init?: Record<string, any>): ResponsePolyfill;
+  clone(): ResponsePolyfill;
+}
+//#endregion
+export { headersToObject as a, HeadersPolyfill as i, RequestPolyfill as n, getRequestBodyValue as r, ResponsePolyfill as t };

package/dist/http.d.mts

@@ -1,58 +1,2 @@
-import { RequestGlobalsBlobLike } from "./shared.mjs";
-import { URLPolyfill } from "./url.mjs";
-import { FormDataPolyfill } from "./web.mjs";
-//#region src/http.d.ts
-type HeaderRecord = Record<string, string>;
-export declare class HeadersPolyfill {
-  private readonly store;
-  constructor(init?: unknown);
-  append(key: string, value: string): void;
-  set(key: string, value: string): void;
-  get(key: string): string | null;
-  getSetCookie(): string[];
-  has(key: string): boolean;
-  delete(key: string): void;
-  forEach(callback: (value: string, key: string) => void): void;
-  entries(): ArrayIterator<[string, string]>;
-  keys(): ArrayIterator<string>;
-  values(): ArrayIterator<string>;
-  [Symbol.iterator](): ArrayIterator<[string, string]>;
-}
-type RequestBodyLike = string | ArrayBuffer | ArrayBufferView | Blob | RequestGlobalsBlobLike | FormData | FormDataPolyfill | null | undefined;
-export declare function getRequestBodyValue(request?: RequestPolyfill): RequestBodyLike;
-export declare class RequestPolyfill {
-  readonly url: string;
-  readonly method: string;
-  readonly headers: HeadersPolyfill;
-  readonly signal: AbortSignal | null;
-  readonly [Symbol.toStringTag] = "Request";
-  constructor(input: string | URL | URLPolyfill | RequestPolyfill, init?: Record<string, any>);
-  get body(): ReadableStream<Uint8Array> | null;
-  get bodyUsed(): boolean;
-  arrayBuffer(): Promise<ArrayBuffer>;
-  text(): Promise<string>;
-  clone(): RequestPolyfill;
-}
-export declare class ResponsePolyfill {
-  readonly headers: HeadersPolyfill;
-  readonly status: number;
-  readonly statusText: string;
-  readonly ok: boolean;
-  readonly url: string;
-  readonly redirected = false;
-  readonly type: ResponseType;
-  readonly [Symbol.toStringTag] = "Response";
-  constructor(body?: RequestBodyLike, init?: Record<string, any>);
-  static error(): ResponsePolyfill;
-  static json(data: unknown, init?: Record<string, any>): ResponsePolyfill;
-  get body(): ReadableStream<Uint8Array> | null;
-  get bodyUsed(): boolean;
-  arrayBuffer(): Promise<ArrayBuffer>;
-  blob(): Promise<Blob>;
-  formData(): Promise<void>;
-  json(): Promise<any>;
-  text(): Promise<string>;
-  clone(): ResponsePolyfill;
-}
-export declare function headersToObject(headers: HeadersPolyfill | Headers): HeaderRecord;
-//#endregion
+import { a as headersToObject, i as HeadersPolyfill, n as RequestPolyfill, r as getRequestBodyValue, t as ResponsePolyfill } from "./http-CE8-CIHE.mjs";
+export { HeadersPolyfill, RequestPolyfill, ResponsePolyfill, getRequestBodyValue, headersToObject };