@wevu/web-apis 1.3.6 → 1.4.0

package/dist/http-DCCqK1QL.mjs

@@ -0,0 +1,505 @@
+import { d as normalizeHeaderName, h as isUrlSearchParamsInstance, l as isArrayBufferLike, m as isUrlInstance, n as cloneArrayBuffer, o as encodeText, r as cloneArrayBufferView, u as isBlobLike } from "./shared-CARmZrDA.mjs";
+import { l as nativeStreams, n as ReadableStreamPolyfill, t as ReadableStream } from "./streams-6m8eQfZM.mjs";
+import { t as TextDecoderPolyfill } from "./textCodec-muWByCAW.mjs";
+import { r as BlobPolyfill, t as FormDataPolyfill } from "./web-DDzJNeV3.mjs";
+// 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;
+}
+// src/multipart.ts
+const CRLF = "\r\n";
+/** 复用调用者指定的边界，使请求头与编码后的字节保持一致。 */
+function createMultipartBoundary(contentType) {
+	if (contentType && /^multipart\/form-data\s*(?:;|$)/i.test(contentType)) {
+		const match = /(?:^|;)\s*boundary=(?:"([^"]+)"|([^;\s]+))/i.exec(contentType);
+		const boundary = match?.[1] ?? match?.[2];
+		if (boundary) {
+			if (!/^[\w'()+,\-./:=? ]{1,70}$/.test(boundary) || boundary.endsWith(" ")) throw new TypeError("Invalid multipart boundary");
+			return boundary;
+		}
+	}
+	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, 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}`
+	};
+}
+// src/streams/ponyfillState.ts
+function isPonyfillStream(value) {
+	return value instanceof ReadableStreamPolyfill;
+}
+/**
+* web-streams-polyfill 固定为 4.3.0；其公共 API 未提供 disturbed 查询，因此将版本相关读取限制在此处。
+* 品牌与字段形状必须同时匹配；升级依赖时由包版本测试和消费状态回归共同阻止静默漂移。
+*/
+function isPonyfillStreamDisturbed(stream) {
+	if (!isPonyfillStream(stream)) throw new TypeError("Expected a web-streams-polyfill ReadableStream");
+	const disturbed = Reflect.get(stream, "_disturbed");
+	if (typeof disturbed !== "boolean") throw new TypeError("Unsupported web-streams-polyfill state layout; expected version 4.3.0");
+	return disturbed;
+}
+// src/streams/bodyTracking.ts
+const nativeStates = /* @__PURE__ */ new WeakMap();
+/** 只观察已支持流族的内部状态；不修改调用者的流、reader 或其原型。 */
+function observeBodyStream(stream) {
+	if (isPonyfillStream(stream)) {
+		isPonyfillStreamDisturbed(stream);
+		return stream;
+	}
+	if (nativeStates.has(stream)) return stream;
+	if (nativeStreams && stream instanceof nativeStreams.ReadableStream) {
+		const { Response, bodyUsed } = nativeStreams;
+		try {
+			const response = new Response(stream);
+			if (response.body === stream) {
+				nativeStates.set(stream, () => bodyUsed.call(response));
+				return stream;
+			}
+		} catch {
+			nativeStates.set(stream, () => true);
+			return stream;
+		}
+	}
+	throw new TypeError("Body stream must use the supported native or ponyfill ReadableStream constructor");
+}
+function isBodyStreamDisturbed(stream) {
+	if (isPonyfillStream(stream)) return isPonyfillStreamDisturbed(stream);
+	return nativeStates.get(stream)?.() === true;
+}
+// src/streams/readBody.ts
+const typedArrayName = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), Symbol.toStringTag)?.get;
+/** 以内部类型标签识别跨 realm 字节视图，并复制到当前 realm 独占的 ArrayBuffer。 */
+function copyBodyChunk(value) {
+	const tag = typedArrayName ? typedArrayName.call(value) : Object.prototype.toString.call(value).slice(8, -1);
+	if (!ArrayBuffer.isView(value) || tag !== "Uint8Array") throw new TypeError("Body stream chunks must be Uint8Array values");
+	const copy = new Uint8Array(value.byteLength);
+	copy.set(value);
+	return copy;
+}
+async function readBodyStream(stream, signal) {
+	const reason = () => signal && signal.reason !== void 0 ? signal.reason : Object.assign(/* @__PURE__ */ new Error("The operation was aborted."), { name: "AbortError" });
+	if (signal?.aborted) throw reason();
+	const reader = stream.getReader();
+	const chunks = [];
+	let length = 0;
+	let aborted = false;
+	const onAbort = () => {
+		if (!aborted) {
+			aborted = true;
+			reader.cancel(reason()).catch(() => {});
+		}
+	};
+	signal?.addEventListener("abort", onAbort, { once: true });
+	try {
+		if (signal?.aborted) onAbort();
+		while (true) {
+			if (aborted) throw reason();
+			const chunk = await reader.read();
+			if (aborted) throw reason();
+			if (chunk.done) break;
+			const copy = copyBodyChunk(chunk.value);
+			chunks.push(copy);
+			length += copy.byteLength;
+		}
+	} finally {
+		signal?.removeEventListener("abort", onAbort);
+		reader.releaseLock();
+	}
+	const merged = new Uint8Array(length);
+	let offset = 0;
+	for (const chunk of chunks) {
+		merged.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return merged.buffer;
+}
+// src/streams/cloneBody.ts
+/**
+* Body clone 必须隔离两侧的可变字节；普通对象流的 tee 会共享 Uint8Array 引用。
+* 先转换为字节流，再使用 Streams 原生的字节 tee 保留双分支取消与错误传播。
+*/
+function cloneBodyStream(stream) {
+	const reader = stream.getReader();
+	return new ReadableStream({
+		type: "bytes",
+		async pull(controller) {
+			try {
+				while (true) {
+					const chunk = await reader.read();
+					if (chunk.done) {
+						controller.close();
+						return;
+					}
+					const copy = copyBodyChunk(chunk.value);
+					if (copy.byteLength > 0) {
+						controller.enqueue(copy);
+						return;
+					}
+				}
+			} catch (error) {
+				controller.error(error);
+				reader.cancel(error).catch(() => {});
+			}
+		},
+		cancel: (reason) => reader.cancel(reason)
+	}).tee();
+}
+// src/http/body.ts
+const bodies = /* @__PURE__ */ new WeakMap();
+const bufferedStreams = /* @__PURE__ */ new WeakSet();
+function isReadableBodyStream(value) {
+	return typeof value === "object" && value !== null && typeof value.getReader === "function" && typeof value.tee === "function" && typeof value.locked === "boolean";
+}
+function isFormData(value) {
+	return value instanceof FormDataPolyfill || typeof FormData === "function" && value instanceof FormData;
+}
+async function bodyBytes(value, multipartBoundary) {
+	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());
+	if (isReadableBodyStream(value)) return readBodyStream(value);
+	return (await encodeMultipartFormData(value, multipartBoundary)).body;
+}
+function initializeBody(owner, input) {
+	let value;
+	let contentType = "";
+	let multipartBoundary;
+	if (input == null) value = null;
+	else if (isReadableBodyStream(input)) {
+		observeBodyStream(input);
+		if (input.locked || isBodyStreamDisturbed(input)) throw new TypeError("Body stream is locked or has already been consumed");
+		value = input;
+	} 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)) {
+		const snapshot = new FormDataPolyfill();
+		for (const [name, entry] of input) if (typeof entry === "string") snapshot.append(name, entry);
+		else snapshot.append(name, entry);
+		value = snapshot;
+		multipartBoundary = createMultipartBoundary(owner.headers.get("content-type"));
+		contentType = `multipart/form-data; boundary=${multipartBoundary}`;
+	} else if (isUrlSearchParamsInstance(input)) {
+		value = input.toString();
+		contentType = "application/x-www-form-urlencoded;charset=UTF-8";
+	} else {
+		value = String(input).replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDFFF]/g, (scalar) => scalar.length === 2 ? scalar : "�");
+		contentType = "text/plain;charset=UTF-8";
+	}
+	if (contentType && !owner.headers.has("content-type")) owner.headers.set("content-type", contentType);
+	let stream = null;
+	if (isReadableBodyStream(value)) stream = observeBodyStream(value);
+	else if (value !== null) {
+		const buffered = value;
+		stream = observeBodyStream(new ReadableStream({ async pull(controller) {
+			try {
+				const bytes = new Uint8Array(await bodyBytes(buffered, multipartBoundary));
+				if (bytes.byteLength > 0) controller.enqueue(bytes);
+				controller.close();
+			} catch (error) {
+				controller.error(error);
+			}
+		} }, { highWaterMark: 0 }));
+	}
+	const buffered = !isReadableBodyStream(value) || bufferedStreams.has(value);
+	if (stream && buffered) bufferedStreams.add(stream);
+	bodies.set(owner, {
+		value,
+		stream,
+		used: false,
+		buffered
+	});
+}
+function getBodyValue(owner) {
+	return bodies.get(owner)?.value;
+}
+/** 小程序宿主只能发送完整请求体；缓冲 Body 的 clone 分支仍属于有限上传。 */
+function isStreamingRequestBody(owner) {
+	return bodies.get(owner)?.buffered === false;
+}
+function assertBodyUnused(owner) {
+	const state = bodies.get(owner);
+	if (state?.used || state?.stream && (state.stream.locked || isBodyStreamDisturbed(state.stream))) 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;
+		if (!isReadableBodyStream(state.value)) state.stream.getReader().cancel();
+	}
+	return state?.value;
+}
+/** clone 的两条分支独立消费，但保留底层取消与错误传播。 */
+function cloneBodyValue(owner) {
+	assertBodyUnused(owner);
+	const state = bodies.get(owner);
+	if (!state?.stream) return null;
+	const [original, clone] = cloneBodyStream(state.stream);
+	state.stream = observeBodyStream(original);
+	state.value = original;
+	if (state.buffered) {
+		bufferedStreams.add(original);
+		bufferedStreams.add(clone);
+	}
+	return clone;
+}
+/** Request 构造的继承是所有权转移；原请求立即失去读取权，新请求按需拉取。 */
+function transferBodyValue(owner) {
+	const value = consumeBodyValue(owner);
+	if (!isReadableBodyStream(value)) return value;
+	const reader = value.getReader();
+	const transferred = new ReadableStream({
+		async pull(controller) {
+			try {
+				const chunk = await reader.read();
+				if (chunk.done) controller.close();
+				else controller.enqueue(chunk.value);
+			} catch (error) {
+				controller.error(error);
+			}
+		},
+		cancel: (reason) => reader.cancel(reason)
+	}, { highWaterMark: 0 });
+	if (bodies.get(owner)?.buffered) bufferedStreams.add(transferred);
+	return transferred;
+}
+/** 仅供 Request/Response 内部复用，不作为包的公开导出。 */
+var HttpBody = class {
+	get body() {
+		return bodies.get(this)?.stream ?? null;
+	}
+	get bodyUsed() {
+		const state = bodies.get(this);
+		return state?.used === true || Boolean(state?.stream && isBodyStreamDisturbed(state.stream));
+	}
+	async arrayBuffer() {
+		assertBodyUnused(this);
+		const state = bodies.get(this);
+		if (!state?.stream) return /* @__PURE__ */ new ArrayBuffer(0);
+		state.used = true;
+		return readBodyStream(state.stream);
+	}
+	async bytes() {
+		return new Uint8Array(await this.arrayBuffer());
+	}
+	async text() {
+		return new TextDecoderPolyfill().decode(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");
+	}
+};
+// 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;
+		initializeBody(this, inherited ? transferBodyValue(request) : init.body);
+	}
+	clone() {
+		return new RequestPolyfill(this.url, {
+			method: this.method,
+			headers: this.headers,
+			signal: this.signal,
+			body: cloneBodyValue(this)
+		});
+	}
+};
+function getRequestBodyValue(request) {
+	return request ? getBodyValue(request) : void 0;
+}
+// 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() {
+		return new ResponsePolyfill(cloneBodyValue(this), {
+			status: this.status,
+			statusText: this.statusText,
+			headers: this.headers,
+			url: this.url,
+			type: this.type
+		});
+	}
+};
+export { isReadableBodyStream as a, createMultipartBoundary as c, headersToObject as d, consumeBodyValue as i, encodeMultipartFormData as l, RequestPolyfill as n, isStreamingRequestBody as o, getRequestBodyValue as r, readBodyStream as s, ResponsePolyfill as t, HeadersPolyfill as u };

package/dist/{http-CE8-CIHE.d.mts → http-Dd6YCSHK.d.mts}

@@ -1,7 +1,6 @@
-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
+import { t as RequestGlobalsBlobLike } from "./shared-DfU0oEwy.mjs";
+import { t as URLPolyfill } from "./url-CEgyUgm2.mjs";
+import { n as FormDataPolyfill, o as BlobPolyfill } from "./web-DjLufM4u.mjs";
 type HeaderRecord = Record<string, string>;
 declare class HeadersPolyfill {
   private readonly store;
@@ -19,13 +18,11 @@ declare class HeadersPolyfill {
   [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;
+type RequestBodyLike = string | ArrayBuffer | ArrayBufferView | Blob | RequestGlobalsBlobLike | FormData | FormDataPolyfill | ReadableStream<Uint8Array<ArrayBuffer>> | null | undefined;
 /** 仅供 Request/Response 内部复用，不作为包的公开导出。 */
 declare abstract class HttpBody {
   abstract readonly headers: HeadersPolyfill;
-  get body(): ReadableStream<Uint8Array> | null;
+  get body(): ReadableStream<Uint8Array<ArrayBuffer>> | null;
   get bodyUsed(): boolean;
   arrayBuffer(): Promise<ArrayBuffer>;
   bytes(): Promise<Uint8Array<ArrayBuffer>>;
@@ -34,8 +31,6 @@ declare abstract class HttpBody {
   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;
@@ -46,8 +41,6 @@ declare class RequestPolyfill extends HttpBody {
   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;
@@ -57,10 +50,9 @@ declare class ResponsePolyfill extends HttpBody {
   readonly redirected = false;
   readonly type: ResponseType;
   readonly [Symbol.toStringTag] = "Response";
-  constructor(body?: RequestBodyLike, init?: Record<string, any>);
+  constructor(body?: RequestBodyLike | ReadableStream, 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,2 +1,2 @@
-import { a as headersToObject, i as HeadersPolyfill, n as RequestPolyfill, r as getRequestBodyValue, t as ResponsePolyfill } from "./http-CE8-CIHE.mjs";
+import { a as headersToObject, i as HeadersPolyfill, n as RequestPolyfill, r as getRequestBodyValue, t as ResponsePolyfill } from "./http-Dd6YCSHK.mjs";
 export { HeadersPolyfill, RequestPolyfill, ResponsePolyfill, getRequestBodyValue, headersToObject };

package/dist/http.mjs

@@ -1 +1 @@
-export { o as HeadersPolyfill, n as RequestPolyfill, t as ResponsePolyfill, r as getRequestBodyValue, s as headersToObject } from "./http-DFOOhYXD.mjs";
+export { u as HeadersPolyfill, n as RequestPolyfill, t as ResponsePolyfill, r as getRequestBodyValue, d as headersToObject } from "./http-DCCqK1QL.mjs";

package/dist/index.d.mts

@@ -1,79 +1,45 @@
-import { i as RequestGlobalsEventTarget } from "./shared-Dc42USJC.mjs";
+import { i as RequestGlobalsEventTarget } from "./shared-DfU0oEwy.mjs";
 import { AbortControllerPolyfill, AbortSignalPolyfill } from "./abort.mjs";
+import { i as EventPolyfill, r as CustomEventPolyfill, t as EventSourcePolyfill } from "./eventsource-DUCc1iHv.mjs";
 import { MiniProgramNetworkDefaults, RequestGlobalsMiniProgramOptions, WebSocketMiniProgramOptions, getMiniProgramNetworkDefaults, resetMiniProgramNetworkDefaults, setMiniProgramNetworkDefaults } from "./networkDefaults.mjs";
-import { n as URLSearchParamsPolyfill, t as URLPolyfill } from "./url-D0ANYIyk.mjs";
-import { fetch } from "./fetch.mjs";
-import { i as HeadersPolyfill, n as RequestPolyfill, t as ResponsePolyfill } from "./http-CE8-CIHE.mjs";
-import { n as FormDataPolyfill, o as BlobPolyfill, r as FilePolyfill } from "./web-DNBBg6y9.mjs";
+import { n as URLSearchParamsPolyfill, t as URLPolyfill } from "./url-CEgyUgm2.mjs";
+import { t as fetch } from "./fetch-CSESA-oq.mjs";
+import { i as HeadersPolyfill, n as RequestPolyfill, t as ResponsePolyfill } from "./http-Dd6YCSHK.mjs";
+import { n as FormDataPolyfill, o as BlobPolyfill, r as FilePolyfill } from "./web-DjLufM4u.mjs";
+import { ReadableStreamPolyfill, TextDecoderStreamPolyfill, TransformStreamPolyfill, WritableStreamPolyfill } from "./streams.mjs";
 import { WebSocketPolyfill } from "./websocket.mjs";
 import { XMLHttpRequestPolyfill } from "./xhr.mjs";
-//#region src/base64.d.ts
+import { WebRuntimeGlobalTarget } from "@weapp-core/constants";
 export declare function btoaPolyfill(input?: string): string;
 export declare function atobPolyfill(input?: string): string;
-//#endregion
-//#region src/crypto.d.ts
 type IntegerTypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | BigInt64Array | BigUint64Array;
 declare function getRandomValuesPolyfill<T extends IntegerTypedArray>(typedArray: T): (T & Int8Array<ArrayBufferLike>) | (T & Uint8Array<ArrayBufferLike>) | (T & Uint8ClampedArray<ArrayBufferLike>) | (T & Int16Array<ArrayBufferLike>) | (T & Uint16Array<ArrayBufferLike>) | (T & Int32Array<ArrayBufferLike>) | (T & Uint32Array<ArrayBufferLike>) | (T & BigInt64Array<ArrayBufferLike>) | (T & BigUint64Array<ArrayBufferLike>);
 export declare const cryptoPolyfill: {
   getRandomValues: typeof getRandomValuesPolyfill;
 };
-//#endregion
-//#region src/events.d.ts
-interface EventInitPolyfill {
-  bubbles?: boolean;
-  cancelable?: boolean;
-  composed?: boolean;
-}
-interface CustomEventInitPolyfill<T = any> extends EventInitPolyfill {
-  detail?: T;
-}
-export declare class EventPolyfill {
-  readonly bubbles: boolean;
-  readonly cancelable: boolean;
-  readonly composed: boolean;
-  readonly isTrusted = false;
-  readonly timeStamp: number;
-  readonly type: string;
-  currentTarget: unknown;
-  target: unknown;
-  defaultPrevented: boolean;
-  cancelBubble: boolean;
-  constructor(type: string, init?: EventInitPolyfill);
-  composedPath(): {}[];
-  preventDefault(): void;
-  stopImmediatePropagation(): void;
-  stopPropagation(): void;
-}
-export declare class CustomEventPolyfill<T = any> extends EventPolyfill {
-  readonly detail: T | null;
-  constructor(type: string, init?: CustomEventInitPolyfill<T>);
-}
-//#endregion
-//#region src/performance.d.ts
 declare const performancePolyfill: {
   __weappVitePerformancePolyfill: boolean;
   now(): number;
   timeOrigin: number;
 };
-//#endregion
-//#region src/task.d.ts
 export declare function queueMicrotaskPolyfill(callback: () => void): void;
-//#endregion
-//#region src/textCodec.d.ts
-type TextDecoderInput = ArrayBuffer | ArrayBufferView | null | undefined;
+type TextDecoderInput = AllowSharedBufferSource | undefined;
 export declare class TextEncoderPolyfill {
   readonly encoding = "utf-8";
   encode(input?: string): Uint8Array<ArrayBuffer>;
 }
 export declare class TextDecoderPolyfill {
   readonly encoding = "utf-8";
-  readonly fatal = false;
-  readonly ignoreBOM = false;
-  decode(input?: TextDecoderInput): string;
+  readonly fatal: boolean;
+  readonly ignoreBOM: boolean;
+  private pending;
+  private streaming;
+  private bomSeen;
+  constructor(label?: string, options?: TextDecoderOptions);
+  decode(input?: TextDecoderInput, options?: TextDecodeOptions): string;
+  get [Symbol.toStringTag](): string;
 }
-//#endregion
-//#region src/index.d.ts
-export type WeappInjectWebRuntimeGlobalsTarget = 'fetch' | 'Headers' | 'Request' | 'Response' | 'TextEncoder' | 'TextDecoder' | 'AbortController' | 'AbortSignal' | 'XMLHttpRequest' | 'WebSocket' | 'atob' | 'btoa' | 'queueMicrotask' | 'performance' | 'crypto' | 'Event' | 'CustomEvent';
+export type WeappInjectWebRuntimeGlobalsTarget = WebRuntimeGlobalTarget;
 export type WeappInjectRequestGlobalsTarget = WeappInjectWebRuntimeGlobalsTarget;
 export interface InstallWebRuntimeGlobalsOptions {
   targets?: WeappInjectWebRuntimeGlobalsTarget[];
@@ -92,5 +58,4 @@ export declare function installRequestGlobals(options?: InstallRequestGlobalsOpt
  * @description 仅安装 AbortController 与 AbortSignal 兼容层。
  */
 export declare function installAbortGlobals(): Record<string, any>;
-//#endregion
-export { AbortControllerPolyfill, AbortSignalPolyfill, BlobPolyfill, FilePolyfill, FormDataPolyfill, HeadersPolyfill, type MiniProgramNetworkDefaults, RequestGlobalsEventTarget, type RequestGlobalsMiniProgramOptions, RequestPolyfill, ResponsePolyfill, URLPolyfill, URLSearchParamsPolyfill, type WebSocketMiniProgramOptions, WebSocketPolyfill, XMLHttpRequestPolyfill, fetch, getMiniProgramNetworkDefaults, performancePolyfill, resetMiniProgramNetworkDefaults, setMiniProgramNetworkDefaults };
+export { AbortControllerPolyfill, AbortSignalPolyfill, BlobPolyfill, CustomEventPolyfill, EventPolyfill, EventSourcePolyfill, FilePolyfill, FormDataPolyfill, HeadersPolyfill, type MiniProgramNetworkDefaults, ReadableStreamPolyfill, RequestGlobalsEventTarget, type RequestGlobalsMiniProgramOptions, RequestPolyfill, ResponsePolyfill, TextDecoderStreamPolyfill, TransformStreamPolyfill, URLPolyfill, URLSearchParamsPolyfill, type WebSocketMiniProgramOptions, WebSocketPolyfill, WritableStreamPolyfill, XMLHttpRequestPolyfill, fetch, getMiniProgramNetworkDefaults, performancePolyfill, resetMiniProgramNetworkDefaults, setMiniProgramNetworkDefaults };