@wevu/web-apis 1.3.5 → 1.4.0

package/README.md

@@ -2,7 +2,7 @@
 
 ## 1. 简介
 
-`@wevu/web-apis` 为小程序运行时提供一组 Web API 兼容层，重点解决第三方库在小程序环境中缺失 `fetch`、`Request`、`Response`、`AbortController`、`XMLHttpRequest`、`URL`、`WebSocket`、`TextEncoder`、`TextDecoder`、`atob`、`btoa`、`queueMicrotask`、`performance.now`、`crypto.getRandomValues`、`Event`、`CustomEvent` 等全局对象的问题。
+`@wevu/web-apis` 为小程序运行时提供一组 Web API 兼容层，重点解决第三方库在小程序环境中缺失 `fetch`、`Request`、`Response`、`AbortController`、`XMLHttpRequest`、`URL`、`WebSocket`、Web Streams、`TextEncoder`、`TextDecoder`、`TextDecoderStream`、`EventSource`、`atob`、`btoa`、`queueMicrotask`、`performance.now`、`crypto.getRandomValues`、`Event`、`CustomEvent` 等全局对象的问题。
 
 它主要服务于：
 
@@ -15,6 +15,7 @@
 - 按需安装 `fetch`、`Headers`、`Request`、`Response`
 - 提供 `AbortController` / `AbortSignal` 兼容层
 - 提供 `XMLHttpRequest`、`URL`、`URLSearchParams`、`Blob`、`FormData`、`WebSocket` 兼容层
+- 提供 Fetch 响应流、UTF-8 增量解码与标准 GET EventSource；网络增量交付要求宿主提供分块监听和早期真实状态码
 - 提供 `atob`、`btoa`、`queueMicrotask`、`performance.now`、`crypto.getRandomValues`、`Event`、`CustomEvent` 兼容层
 - 自动把能力安装到可用的小程序宿主全局对象
 - 默认基于 `@wevu/api` 的请求能力完成底层转发
@@ -31,6 +32,7 @@ pnpm add @wevu/web-apis
 
 ```ts
 import { installWebRuntimeGlobals } from '@wevu/web-apis'
+import { fetch } from '@wevu/web-apis/fetch'
 
 installWebRuntimeGlobals()
 
@@ -38,14 +40,16 @@ const response = await fetch('https://request-globals.invalid/data')
 console.log(await response.json())
 ```
 
+在 `weapp-vite` 项目中，希望直接使用自由变量 `fetch`、`EventSource` 等 Web 写法时，应配置 `weapp.appPrelude.webRuntime`。编译器会在模块执行前安装构造器并生成局部绑定，避免微信模块包装器中的同名参数遮蔽全局对象；单独调用安装器不能提供这项编译能力。
+
 ### 4.2 仅安装 Abort 相关能力
 
 ```ts
 import { installAbortGlobals } from '@wevu/web-apis'
 
-installAbortGlobals()
+const runtime = installAbortGlobals()
 
-const controller = new AbortController()
+const controller = new runtime.AbortController()
 controller.abort()
 ```
 
@@ -64,7 +68,7 @@ installWebRuntimeGlobals({
 ```ts
 import { installWebRuntimeGlobals } from '@wevu/web-apis'
 
-installWebRuntimeGlobals({
+const { btoa, atob, performance, crypto, CustomEvent } = installWebRuntimeGlobals({
   targets: ['atob', 'btoa', 'queueMicrotask', 'performance', 'crypto', 'Event', 'CustomEvent'],
 })
 
@@ -80,7 +84,7 @@ const event = new CustomEvent('payload', { detail: { ok: true } })
 ```ts
 import { installWebRuntimeGlobals } from '@wevu/web-apis'
 
-installWebRuntimeGlobals({
+const { WebSocket } = installWebRuntimeGlobals({
   targets: ['WebSocket'],
 })
 
@@ -109,6 +113,9 @@ socket.onclose = (event) => {
 | `fetch`                                                    | 基于小程序请求能力适配的 `fetch` 实现           |
 | `HeadersPolyfill` / `RequestPolyfill` / `ResponsePolyfill` | HTTP 相关兼容类                                 |
 | `TextEncoderPolyfill` / `TextDecoderPolyfill`              | 文本编解码兼容类                                |
+| `ReadableStreamPolyfill` / `WritableStreamPolyfill` / `TransformStreamPolyfill` | Web Streams 兼容构造器 |
+| `TextDecoderStreamPolyfill`                               | UTF-8 流式解码器                                |
+| `EventSourcePolyfill`                                     | GET SSE 客户端，支持事件监听与自动重连          |
 | `URLPolyfill` / `URLSearchParamsPolyfill`                  | URL 相关兼容类                                  |
 | `WebSocketPolyfill`                                        | 基于小程序 `SocketTask` 的 `WebSocket` 兼容实现 |
 | `XMLHttpRequestPolyfill`                                   | XHR 兼容实现                                    |
@@ -118,6 +125,7 @@ socket.onclose = (event) => {
 - 在小程序环境中运行 `axios` 的 `fetch` 适配器
 - 在小程序环境中运行 `graphql-request`
 - 在小程序环境中直接复用浏览器风格的 `WebSocket` 客户端代码
+- 在具备所需宿主能力的微信环境中复用 Fetch SSE 消费链路或标准 `EventSource`
 - 在小程序环境中运行依赖 `atob` / `btoa` / `queueMicrotask` / `performance.now` / `crypto.getRandomValues` 的工具库
 - 给依赖 `URL` / `FormData` / `Blob` 的库补齐基础全局对象
 
@@ -149,7 +157,7 @@ pnpm --filter @wevu/web-apis typecheck
 
 ## 11. Body 与 Blob 契约
 
-`RequestPolyfill` 和 `ResponsePolyfill` 提供 `bytes()`、`arrayBuffer()`、`text()`、`json()`、`blob()`。非 null body 只能消费一次；读取开始时 `bodyUsed` 就会变成 `true`，重复或并发读取会拒绝为 `TypeError`，读取后调用 `clone()` 也会抛错。需要多种读取方式时，请在消费前 clone：
+`RequestPolyfill` 和 `ResponsePolyfill` 提供可读 `body`，以及 `bytes()`、`arrayBuffer()`、`text()`、`json()`、`blob()`。非 null body 只能消费一次；调用消费方法或开始读取、取消 body 流时，`bodyUsed` 会变成 `true`。仅获取 reader 会锁定流，但不改变 `bodyUsed`。body 已消费或锁定时，重复读取和 `clone()` 都会以 `TypeError` 失败。需要多种读取方式时，请在消费前 clone：
 
 ```ts
 import { ResponsePolyfill } from '@wevu/web-apis'
@@ -166,11 +174,31 @@ null body 读取为空且保持未消费；空字符串和零长度二进制属
 
 | 能力              | 支持范围                                                                                                   |
 | ----------------- | ---------------------------------------------------------------------------------------------------------- |
-| Body 读取与 clone | 缓冲 body 的单次消费、独立 clone、MIME 传递；ponyfill 的 `blob()` 不要求先安装全局 Blob                    |
+| Body 读取与 clone | 缓冲与流式 body 共享单次消费状态，通过 `tee()` 提供 clone 分支，保留错误与取消传播；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()` |
+| Streams           | 支持标准响应流、`getReader()`、`pipeThrough()` 与 `clone()/tee()`；Fetch 网络增量需开启 `enableChunked` 且宿主提供早期真实状态码；未提供流式上传和 `Blob.stream()` |
 | formData()        | 未支持响应解析；FormData 请求上传继续支持 multipart 编码                                                   |
 
 这些是本包 ponyfill 的能力边界。安装器保留可用的宿主实现，宿主对象的方法完整性应按目标基础库确认。
+
+## SSE 与响应流
+
+微信端可以保持 Web 消费方式。项目启用 Web Runtime 并设置
+`weapp.appPrelude.webRuntime.networkDefaults.request.enableChunked: true` 后，
+`fetch()` 在收到真实 HTTP 状态码和响应头时返回，后续字节通过 `Response.body` 交付。
+`wevu/fetch` 复用同一实现。普通缓冲请求也提供可读 body，但不表示网络增量交付。
+
+`@wevu/web-apis/streams` 导出作为一组选择的 `ReadableStream`、`WritableStream`、`TransformStream`，保留可用的原生实现，否则使用 `web-streams-polyfill@4.3.0` ponyfill。该入口也导出三个 `*Polyfill` 构造器和 `TextDecoderStreamPolyfill`。
+`@wevu/web-apis/eventsource` 导出 `EventSourcePolyfill`、其别名 `EventSource` 与 `MessageEventPolyfill`，也可以由构建器注入全局 `EventSource`。
+EventSource 自动启用分块请求，支持 GET、命名事件、`Last-Event-ID`、`retry` 与自动重连。
+POST、自定义鉴权头使用 Fetch；Fetch 不自动重试请求。
+
+缺少 chunk API 或早期 `statusCode` 时，流式 Fetch 以 `NotSupportedError` 失败，
+EventSource 发出 error 并关闭，不推断 HTTP 200。开发者工具和真机能力需要分别验证。
+`withCredentials: true` 不受支持；小程序域名白名单、TLS、超时和后台运行限制仍由宿主管理。
+宿主没有已验证的暂停接收接口，JS 队列不代表网络级反压；慢消费和 clone 分支可能增加内存占用。
+
+`AbortSignal` 在 Response 返回后仍能终止读取；`reader.cancel()` 取消请求。
+页面卸载时需清理 EventSource 或中止 Fetch。对 clone 的单个分支取消不会取消另一分支。

package/dist/abort.d.mts

@@ -1,5 +1,4 @@
-import { i as RequestGlobalsEventTarget } from "./shared-Dc42USJC.mjs";
-//#region src/abort.d.ts
+import { i as RequestGlobalsEventTarget } from "./shared-DfU0oEwy.mjs";
 export declare class AbortSignalPolyfill extends RequestGlobalsEventTarget {
   aborted: boolean;
   reason: unknown;
@@ -11,5 +10,4 @@ export declare class AbortSignalPolyfill extends RequestGlobalsEventTarget {
 export declare class AbortControllerPolyfill {
   readonly signal: AbortSignalPolyfill;
   abort(reason?: unknown): void;
-}
-//#endregion
+}

package/dist/abort.mjs

@@ -1,5 +1,5 @@
-import { t as RequestGlobalsEventTarget } from "./shared-85INNxXV.mjs";
-//#region src/abort.ts
+import { t as RequestGlobalsEventTarget } from "./shared-CARmZrDA.mjs";
+// src/abort.ts
 function createAbortError(reason) {
 	if (reason instanceof Error) return reason;
 	if (typeof DOMException === "function") return new DOMException("The operation was aborted.", "AbortError");
@@ -24,5 +24,4 @@ var AbortControllerPolyfill = class {
 		this.signal.dispatchEvent({ type: "abort" });
 	}
 };
-//#endregion
 export { AbortControllerPolyfill, AbortSignalPolyfill };

package/dist/eventsource-DUCc1iHv.d.mts

@@ -0,0 +1,82 @@
+interface EventInitPolyfill {
+  bubbles?: boolean;
+  cancelable?: boolean;
+  composed?: boolean;
+}
+interface CustomEventInitPolyfill<T = any> extends EventInitPolyfill {
+  detail?: T;
+}
+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;
+}
+declare class CustomEventPolyfill<T = any> extends EventPolyfill {
+  readonly detail: T | null;
+  constructor(type: string, init?: CustomEventInitPolyfill<T>);
+}
+/** 区分停止冒泡与停止同一目标上的后续监听。 */
+declare class EventSourceEvent extends EventPolyfill {
+  immediatePropagationStopped: boolean;
+  stopImmediatePropagation(): void;
+}
+/** 提供事件流消息需要的标准 MessageEvent 字段。 */
+declare class MessageEventPolyfill<T = unknown> extends EventSourceEvent {
+  readonly data: T;
+  readonly origin: string;
+  readonly lastEventId: string;
+  readonly source: null;
+  readonly ports: MessagePort[];
+  constructor(type: string, init?: MessageEventInit<T>);
+}
+/** 事件监听错误独立报告，避免把业务异常当作传输错误并触发重连。 */
+declare class EventSourceEventTarget {
+  private readonly listeners;
+  addEventListener<K extends keyof EventSourceEventMap>(type: K, callback: ((event: EventSourceEventMap[K]) => void) | null, options?: boolean | AddEventListenerOptions): void;
+  addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
+  removeEventListener<K extends keyof EventSourceEventMap>(type: K, callback: ((event: EventSourceEventMap[K]) => void) | null, options?: boolean | EventListenerOptions): void;
+  removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): void;
+  dispatchEvent(event: Event): boolean;
+  private invoke;
+}
+/** 以标准 Fetch 响应流实现 EventSource；宿主缺失流式元数据时明确失败。 */
+declare class EventSourcePolyfill extends EventSourceEventTarget {
+  static readonly CONNECTING = 0;
+  static readonly OPEN = 1;
+  static readonly CLOSED = 2;
+  readonly CONNECTING = 0;
+  readonly OPEN = 1;
+  readonly CLOSED = 2;
+  readonly url: string;
+  readonly withCredentials = false;
+  readonly [Symbol.toStringTag] = "EventSource";
+  onopen: ((this: EventSourcePolyfill, event: Event) => unknown) | null;
+  onmessage: ((this: EventSourcePolyfill, event: MessageEvent<string>) => unknown) | null;
+  onerror: ((this: EventSourcePolyfill, event: Event) => unknown) | null;
+  private state;
+  private generation;
+  private lastEventId;
+  private retryDelay;
+  private retryTimer;
+  private controller;
+  constructor(url: string | URL, init?: EventSourceInit);
+  get readyState(): number;
+  close(): void;
+  private isActive;
+  private failConnection;
+  private reconnect;
+  private connect;
+}
+export { EventPolyfill as i, MessageEventPolyfill as n, CustomEventPolyfill as r, EventSourcePolyfill as t };

package/dist/eventsource-ojngrwBI.mjs

@@ -0,0 +1,340 @@
+import { t as URLPolyfill } from "./url-DjMmeEth.mjs";
+import { AbortControllerPolyfill } from "./abort.mjs";
+import { t as TextDecoderPolyfill } from "./textCodec-muWByCAW.mjs";
+import { t as fetch } from "./fetch-CQoQx3mz.mjs";
+// src/events.ts
+var EventPolyfill = class {
+	bubbles;
+	cancelable;
+	composed;
+	isTrusted = false;
+	timeStamp = Date.now();
+	type;
+	currentTarget = null;
+	target = null;
+	defaultPrevented = false;
+	cancelBubble = false;
+	constructor(type, init = {}) {
+		this.type = String(type);
+		this.bubbles = init.bubbles === true;
+		this.cancelable = init.cancelable === true;
+		this.composed = init.composed === true;
+	}
+	composedPath() {
+		return this.target == null ? [] : [this.target];
+	}
+	preventDefault() {
+		if (this.cancelable) this.defaultPrevented = true;
+	}
+	stopImmediatePropagation() {
+		this.cancelBubble = true;
+	}
+	stopPropagation() {
+		this.cancelBubble = true;
+	}
+};
+var CustomEventPolyfill = class extends EventPolyfill {
+	detail;
+	constructor(type, init = {}) {
+		super(type, init);
+		this.detail = init.detail ?? null;
+	}
+};
+// src/eventsource/events.ts
+/** 区分停止冒泡与停止同一目标上的后续监听。 */
+var EventSourceEvent = class extends EventPolyfill {
+	immediatePropagationStopped = false;
+	stopImmediatePropagation() {
+		super.stopImmediatePropagation();
+		this.immediatePropagationStopped = true;
+	}
+};
+/** 提供事件流消息需要的标准 MessageEvent 字段。 */
+var MessageEventPolyfill = class extends EventSourceEvent {
+	data;
+	origin;
+	lastEventId;
+	source = null;
+	ports = [];
+	constructor(type, init = {}) {
+		super(type, init);
+		this.data = init.data;
+		this.origin = init.origin ?? "";
+		this.lastEventId = init.lastEventId ?? "";
+	}
+};
+function reportListenerError(error) {
+	const host = globalThis;
+	if (typeof host.reportError === "function") host.reportError(error);
+	else setTimeout(() => {
+		throw error;
+	}, 0);
+}
+/** 事件监听错误独立报告，避免把业务异常当作传输错误并触发重连。 */
+var EventSourceEventTarget = class {
+	listeners = /* @__PURE__ */ new Map();
+	addEventListener(type, callback, options = false) {
+		if (!callback) return;
+		const capture = typeof options === "boolean" ? options : options.capture === true;
+		const signal = typeof options === "boolean" ? void 0 : options.signal;
+		const listeners = this.listeners.get(type) ?? [];
+		if (signal?.aborted || listeners.some((entry) => entry.callback === callback && entry.capture === capture)) return;
+		const entry = {
+			callback,
+			capture,
+			once: typeof options === "object" && options.once === true,
+			signal
+		};
+		if (signal) {
+			entry.onAbort = () => this.removeEventListener(type, callback, capture);
+			signal.addEventListener("abort", entry.onAbort, { once: true });
+		}
+		listeners.push(entry);
+		this.listeners.set(type, listeners);
+	}
+	removeEventListener(type, callback, options = false) {
+		const capture = typeof options === "boolean" ? options : options.capture === true;
+		const listeners = this.listeners.get(type);
+		const index = listeners?.findIndex((entry) => entry.callback === callback && entry.capture === capture) ?? -1;
+		if (listeners && index !== -1) {
+			const [entry] = listeners.splice(index, 1);
+			if (entry?.onAbort) entry.signal?.removeEventListener("abort", entry.onAbort);
+		}
+	}
+	dispatchEvent(event) {
+		const payload = event;
+		Object.defineProperties(payload, {
+			target: {
+				configurable: true,
+				writable: true,
+				value: this
+			},
+			currentTarget: {
+				configurable: true,
+				writable: true,
+				value: this
+			}
+		});
+		for (const entry of [...this.listeners.get(event.type) ?? []]) {
+			if (!this.listeners.get(event.type)?.includes(entry)) continue;
+			if (entry.once) this.removeEventListener(event.type, entry.callback, entry.capture);
+			this.invoke(() => {
+				if (typeof entry.callback === "function") entry.callback.call(this, event);
+				else entry.callback.handleEvent(event);
+			});
+			if (payload.immediatePropagationStopped) break;
+		}
+		if (!payload.immediatePropagationStopped) {
+			const handler = this[`on${event.type}`];
+			if (typeof handler === "function") this.invoke(() => handler.call(this, event));
+		}
+		payload.currentTarget = null;
+		return !event.defaultPrevented;
+	}
+	invoke(callback) {
+		try {
+			callback();
+		} catch (error) {
+			reportListenerError(error);
+		}
+	}
+};
+// src/eventsource/parser.ts
+/** 增量解析事件流；仅空行提交事件，连接结束时丢弃未完成的数据。 */
+var EventStreamParser = class {
+	callbacks;
+	fragments = [];
+	data = [];
+	eventType = "";
+	lastEventId;
+	firstCharacter = true;
+	skipLf = false;
+	constructor(callbacks, lastEventId = "") {
+		this.callbacks = callbacks;
+		this.lastEventId = lastEventId;
+	}
+	feed(chunk) {
+		let start = 0;
+		if (this.firstCharacter && chunk.length > 0) {
+			this.firstCharacter = false;
+			if (chunk.charCodeAt(0) === 65279) start = 1;
+		}
+		for (let index = start; index < chunk.length; index++) {
+			const code = chunk.charCodeAt(index);
+			if (this.skipLf) {
+				this.skipLf = false;
+				if (code === 10) {
+					start = index + 1;
+					continue;
+				}
+			}
+			if (code !== 10 && code !== 13) continue;
+			this.fragments.push(chunk.slice(start, index));
+			const line = this.fragments.join("");
+			this.fragments = [];
+			start = index + 1;
+			this.skipLf = code === 13;
+			this.line(line);
+		}
+		if (start < chunk.length) this.fragments.push(chunk.slice(start));
+	}
+	line(line) {
+		if (line === "") {
+			this.callbacks.onId(this.lastEventId);
+			const event = this.data.length > 0 ? {
+				type: this.eventType || "message",
+				data: this.data.join("\n"),
+				lastEventId: this.lastEventId
+			} : null;
+			this.data = [];
+			this.eventType = "";
+			if (event) this.callbacks.onEvent(event);
+			return;
+		}
+		if (line.startsWith(":")) return;
+		const separator = line.indexOf(":");
+		const field = separator === -1 ? line : line.slice(0, separator);
+		let value = separator === -1 ? "" : line.slice(separator + 1);
+		if (value.startsWith(" ")) value = value.slice(1);
+		switch (field) {
+			case "data":
+				this.data.push(value);
+				break;
+			case "event":
+				this.eventType = value;
+				break;
+			case "id":
+				if (!value.includes("\0")) this.lastEventId = value;
+				break;
+			case "retry": if (/^\d+$/.test(value)) {
+				const delay = Number(value);
+				if (Number.isFinite(delay)) this.callbacks.onRetry(Math.min(delay, 2147483647));
+			}
+		}
+	}
+};
+// src/eventsource.ts
+function notSupported(message) {
+	const error = new Error(message);
+	error.name = "NotSupportedError";
+	return error;
+}
+function event(type) {
+	return new EventSourceEvent(type);
+}
+/** 以标准 Fetch 响应流实现 EventSource；宿主缺失流式元数据时明确失败。 */
+var EventSourcePolyfill = class EventSourcePolyfill extends EventSourceEventTarget {
+	static CONNECTING = 0;
+	static OPEN = 1;
+	static CLOSED = 2;
+	CONNECTING = 0;
+	OPEN = 1;
+	CLOSED = 2;
+	url;
+	withCredentials = false;
+	[Symbol.toStringTag] = "EventSource";
+	onopen = null;
+	onmessage = null;
+	onerror = null;
+	state = EventSourcePolyfill.CONNECTING;
+	generation = 0;
+	lastEventId = "";
+	retryDelay = 3e3;
+	retryTimer;
+	controller;
+	constructor(url, init = {}) {
+		super();
+		if (init.withCredentials) throw notSupported("EventSource withCredentials is not supported by this mini-program transport");
+		const base = globalThis.location?.href;
+		this.url = new URLPolyfill(String(url), base).href;
+		Promise.resolve().then(() => this.connect());
+	}
+	get readyState() {
+		return this.state;
+	}
+	close() {
+		this.state = EventSourcePolyfill.CLOSED;
+		this.generation++;
+		clearTimeout(this.retryTimer);
+		this.retryTimer = void 0;
+		this.controller?.abort();
+		this.controller = void 0;
+	}
+	isActive(generation) {
+		return this.generation === generation && this.state !== EventSourcePolyfill.CLOSED;
+	}
+	failConnection() {
+		this.close();
+		this.dispatchEvent(event("error"));
+	}
+	reconnect(generation) {
+		if (!this.isActive(generation)) return;
+		this.state = EventSourcePolyfill.CONNECTING;
+		this.dispatchEvent(event("error"));
+		if (this.isActive(generation)) this.retryTimer = setTimeout(() => {
+			this.retryTimer = void 0;
+			this.connect();
+		}, this.retryDelay);
+	}
+	async connect() {
+		if (this.state === EventSourcePolyfill.CLOSED) return;
+		const generation = ++this.generation;
+		const controller = new AbortControllerPolyfill();
+		this.controller = controller;
+		let reader;
+		try {
+			const headers = { Accept: "text/event-stream" };
+			if (this.lastEventId) headers["Last-Event-ID"] = this.lastEventId;
+			const response = await fetch(this.url, {
+				headers,
+				signal: controller.signal,
+				miniProgram: { enableChunked: true }
+			});
+			if (!this.isActive(generation)) {
+				await response.body?.cancel();
+				return;
+			}
+			const contentType = response.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase();
+			if (response.status !== 200 || contentType !== "text/event-stream" || !response.body) {
+				this.failConnection();
+				return;
+			}
+			const origin = new URLPolyfill(response.url || this.url).origin;
+			const parser = new EventStreamParser({
+				onEvent: (message) => {
+					if (this.isActive(generation)) this.dispatchEvent(new MessageEventPolyfill(message.type, {
+						...message,
+						origin
+					}));
+				},
+				onId: (id) => {
+					this.lastEventId = id;
+				},
+				onRetry: (delay) => {
+					this.retryDelay = delay;
+				}
+			}, this.lastEventId);
+			const decoder = new TextDecoderPolyfill("utf-8", { ignoreBOM: true });
+			reader = response.body.getReader();
+			this.state = EventSourcePolyfill.OPEN;
+			this.dispatchEvent(event("open"));
+			while (this.isActive(generation)) {
+				const chunk = await reader.read();
+				if (chunk.done) {
+					parser.feed(decoder.decode());
+					break;
+				}
+				parser.feed(decoder.decode(chunk.value, { stream: true }));
+			}
+			this.reconnect(generation);
+		} catch (error) {
+			if (!this.isActive(generation)) return;
+			if (error instanceof Error && error.name === "NotSupportedError") this.failConnection();
+			else this.reconnect(generation);
+		} finally {
+			reader?.releaseLock();
+			if (this.controller === controller) this.controller = void 0;
+		}
+	}
+};
+export { EventPolyfill as i, MessageEventPolyfill as n, CustomEventPolyfill as r, EventSourcePolyfill as t };

package/dist/eventsource.d.mts

@@ -0,0 +1,2 @@
+import { n as MessageEventPolyfill, t as EventSourcePolyfill } from "./eventsource-DUCc1iHv.mjs";
+export { EventSourcePolyfill as EventSource, EventSourcePolyfill, MessageEventPolyfill };

package/dist/eventsource.mjs

@@ -0,0 +1,2 @@
+import "./abort.mjs";
+export { t as EventSource, t as EventSourcePolyfill, n as MessageEventPolyfill } from "./eventsource-ojngrwBI.mjs";