@wevu/web-apis 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 ice breaker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/abort.d.mts

@@ -0,0 +1,17 @@
+import { RequestGlobalsEventTarget } from "./shared.mjs";
+
+//#region src/abort.d.ts
+declare class AbortSignalPolyfill extends RequestGlobalsEventTarget {
+  aborted: boolean;
+  reason: unknown;
+  onabort: ((event: {
+    type: string;
+  }) => void) | null;
+  throwIfAborted(): void;
+}
+declare class AbortControllerPolyfill {
+  readonly signal: AbortSignalPolyfill;
+  abort(reason?: unknown): void;
+}
+//#endregion
+export { AbortControllerPolyfill, AbortSignalPolyfill };

package/dist/abort.mjs

@@ -0,0 +1,28 @@
+import { RequestGlobalsEventTarget } from "./shared.mjs";
+//#region src/abort.ts
+function createAbortError(reason) {
+	if (reason instanceof Error) return reason;
+	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;
+}
+var AbortSignalPolyfill = class extends RequestGlobalsEventTarget {
+	aborted = false;
+	reason;
+	onabort = null;
+	throwIfAborted() {
+		if (this.aborted) throw createAbortError(this.reason);
+	}
+};
+var AbortControllerPolyfill = class {
+	signal = new AbortSignalPolyfill();
+	abort(reason) {
+		if (this.signal.aborted) return;
+		this.signal.aborted = true;
+		this.signal.reason = reason;
+		this.signal.dispatchEvent({ type: "abort" });
+	}
+};
+//#endregion
+export { AbortControllerPolyfill, AbortSignalPolyfill };

package/dist/fetch.d.mts

@@ -0,0 +1,26 @@
+//#region src/fetch.d.ts
+interface RequestLikeInput {
+  url: string;
+  method?: string;
+  headers?: unknown;
+  signal?: AbortSignal | null;
+  bodyUsed?: boolean;
+  clone?: () => {
+    arrayBuffer?: () => Promise<ArrayBuffer>;
+    text?: () => Promise<string>;
+  };
+}
+interface RequestGlobalsFetchInit {
+  method?: string;
+  headers?: unknown;
+  body?: unknown;
+  signal?: AbortSignal | null;
+  [key: string]: unknown;
+}
+type RequestGlobalsFetchInput = string | URL | RequestLikeInput;
+/**
+ * @description 使用 @wevu/api 的 request 能力实现 fetch 语义对齐。
+ */
+declare function fetch(input: RequestGlobalsFetchInput, init?: RequestGlobalsFetchInit): Promise<Response>;
+//#endregion
+export { RequestGlobalsFetchInit, fetch };

package/dist/fetch.mjs

@@ -0,0 +1,182 @@
+import { cloneArrayBuffer, cloneArrayBufferView, normalizeHeaderName } from "./shared.mjs";
+import { HeadersPolyfill, ResponsePolyfill } from "./http.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 isNativeUrlInstance(value) {
+	return typeof URL !== "undefined" && value instanceof URL;
+}
+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.forEach === "function") {
+		source.forEach((value, key) => {
+			setHeader(target, key, value);
+		});
+		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 (!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";
+}
+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");
+	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 (typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams) {
+		if (!hasHeader(headers, "content-type")) headers["content-type"] = "application/x-www-form-urlencoded;charset=UTF-8";
+		return body.toString();
+	}
+	if (body instanceof ArrayBuffer) return cloneArrayBuffer(body);
+	if (ArrayBuffer.isView(body)) return cloneArrayBufferView(body);
+	if (typeof Blob !== "undefined" && body instanceof Blob) {
+		if (body.type && !hasHeader(headers, "content-type")) headers["content-type"] = body.type;
+		return body.arrayBuffer();
+	}
+	if (typeof FormData !== "undefined" && body instanceof FormData) throw new TypeError("Failed to execute fetch: FormData body is not supported in request globals fetch");
+	return String(body);
+}
+async function resolveRequestMeta(input, init = {}) {
+	const requestInput = isRequestLikeInput(input) ? input : void 0;
+	const url = typeof input === "string" ? input : isNativeUrlInstance(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 {
+		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 aborted = false;
+			let requestTask;
+			function onAbort() {
+				if (settled) return;
+				aborted = true;
+				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({
+				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();
+					if (aborted) {
+						reject(createAbortError());
+						return;
+					}
+					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.d.mts

@@ -0,0 +1,53 @@
+//#region src/http.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;
+  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 | null | undefined;
+declare class RequestPolyfill {
+  readonly url: string;
+  readonly method: string;
+  readonly headers: HeadersPolyfill;
+  readonly signal: AbortSignal | null;
+  readonly [Symbol.toStringTag] = "Request";
+  private readonly bodyValue;
+  bodyUsed: boolean;
+  constructor(input: string | URL | RequestPolyfill, init?: Record<string, any>);
+  arrayBuffer(): Promise<ArrayBuffer>;
+  text(): Promise<string>;
+  clone(): RequestPolyfill;
+}
+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 body: ReadableStream<Uint8Array> | null;
+  readonly [Symbol.toStringTag] = "Response";
+  private readonly bodyValue;
+  bodyUsed: boolean;
+  constructor(body?: RequestBodyLike, init?: Record<string, any>);
+  arrayBuffer(): Promise<ArrayBuffer>;
+  blob(): Promise<Blob>;
+  formData(): Promise<void>;
+  json(): Promise<any>;
+  text(): Promise<string>;
+  clone(): ResponsePolyfill;
+}
+declare function headersToObject(headers: HeadersPolyfill | Headers): HeaderRecord;
+//#endregion
+export { HeadersPolyfill, RequestPolyfill, ResponsePolyfill, headersToObject };

package/dist/http.mjs

@@ -0,0 +1,170 @@
+import { cloneArrayBuffer, cloneArrayBufferView, decodeText, encodeText, normalizeHeaderName } from "./shared.mjs";
+//#region src/http.ts
+function isIterableHeaders(input) {
+	return Boolean(input) && typeof input[Symbol.iterator] === "function";
+}
+function isHeaderObject(input) {
+	return typeof input === "object" && input !== null;
+}
+function isNativeUrlInstance(value) {
+	return typeof URL !== "undefined" && value instanceof URL;
+}
+var HeadersPolyfill = class {
+	store = /* @__PURE__ */ new Map();
+	constructor(init) {
+		if (!init) return;
+		if (typeof init.forEach === "function") {
+			init.forEach((value, key) => {
+				this.set(key, value);
+			});
+			return;
+		}
+		if (isIterableHeaders(init)) {
+			for (const [key, value] of init) this.append(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 current = this.get(key);
+		this.set(key, current ? `${current}, ${value}` : value);
+	}
+	set(key, value) {
+		const normalized = normalizeHeaderName(key);
+		if (!normalized) return;
+		this.store.set(normalized, {
+			key,
+			value: String(value)
+		});
+	}
+	get(key) {
+		return this.store.get(normalizeHeaderName(key))?.value ?? null;
+	}
+	has(key) {
+		return this.store.has(normalizeHeaderName(key));
+	}
+	delete(key) {
+		this.store.delete(normalizeHeaderName(key));
+	}
+	forEach(callback) {
+		for (const { key, value } of this.store.values()) callback(value, key);
+	}
+	entries() {
+		return Array.from(this.store.values(), (item) => [item.key, item.value])[Symbol.iterator]();
+	}
+	keys() {
+		return Array.from(this.store.values(), (item) => item.key)[Symbol.iterator]();
+	}
+	values() {
+		return Array.from(this.store.values(), (item) => item.value)[Symbol.iterator]();
+	}
+	[Symbol.iterator]() {
+		return this.entries();
+	}
+};
+function normalizeBody(body) {
+	if (body == null || typeof body === "string" || body instanceof ArrayBuffer || ArrayBuffer.isView(body)) return body;
+	if (typeof Blob !== "undefined" && body instanceof Blob) return body;
+	return String(body);
+}
+async function readBodyAsArrayBuffer(body) {
+	if (body == null) return /* @__PURE__ */ new ArrayBuffer(0);
+	if (typeof body === "string") return encodeText(body);
+	if (body instanceof ArrayBuffer) return cloneArrayBuffer(body);
+	if (ArrayBuffer.isView(body)) return cloneArrayBufferView(body);
+	if (typeof Blob !== "undefined" && body instanceof Blob) return body.arrayBuffer();
+	return encodeText(String(body));
+}
+async function readBodyAsText(body) {
+	if (typeof body === "string") return body;
+	return decodeText(await readBodyAsArrayBuffer(body));
+}
+var RequestPolyfill = class RequestPolyfill {
+	url;
+	method;
+	headers;
+	signal;
+	[Symbol.toStringTag] = "Request";
+	bodyValue;
+	bodyUsed = false;
+	constructor(input, init = {}) {
+		const request = input instanceof RequestPolyfill ? input : void 0;
+		this.url = typeof input === "string" ? input : isNativeUrlInstance(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;
+		this.bodyValue = normalizeBody(init.body ?? request?.bodyValue);
+	}
+	async arrayBuffer() {
+		this.bodyUsed = true;
+		return readBodyAsArrayBuffer(this.bodyValue);
+	}
+	async text() {
+		this.bodyUsed = true;
+		return readBodyAsText(this.bodyValue);
+	}
+	clone() {
+		return new RequestPolyfill(this.url, {
+			method: this.method,
+			headers: this.headers,
+			signal: this.signal,
+			body: this.bodyValue
+		});
+	}
+};
+var ResponsePolyfill = class ResponsePolyfill {
+	headers;
+	status;
+	statusText;
+	ok;
+	url;
+	redirected = false;
+	type = "basic";
+	body = null;
+	[Symbol.toStringTag] = "Response";
+	bodyValue;
+	bodyUsed = false;
+	constructor(body, init = {}) {
+		this.bodyValue = normalizeBody(body);
+		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 ?? "";
+	}
+	async arrayBuffer() {
+		this.bodyUsed = true;
+		return readBodyAsArrayBuffer(this.bodyValue);
+	}
+	async blob() {
+		if (typeof Blob !== "function") throw new TypeError("Blob is unavailable in current runtime");
+		return new Blob([await this.arrayBuffer()]);
+	}
+	async formData() {
+		throw new TypeError("formData is not supported in Response polyfill");
+	}
+	async json() {
+		return JSON.parse(await this.text());
+	}
+	async text() {
+		this.bodyUsed = true;
+		return readBodyAsText(this.bodyValue);
+	}
+	clone() {
+		return new ResponsePolyfill(this.bodyValue, {
+			status: this.status,
+			statusText: this.statusText,
+			headers: this.headers,
+			url: this.url
+		});
+	}
+};
+function headersToObject(headers) {
+	const result = {};
+	headers.forEach((value, key) => {
+		result[key] = value;
+	});
+	return result;
+}
+//#endregion
+export { HeadersPolyfill, RequestPolyfill, ResponsePolyfill, headersToObject };

package/dist/index.d.mts

@@ -0,0 +1,23 @@
+import { RequestGlobalsEventTarget } from "./shared.mjs";
+import { AbortControllerPolyfill, AbortSignalPolyfill } from "./abort.mjs";
+import { fetch } from "./fetch.mjs";
+import { HeadersPolyfill, RequestPolyfill, ResponsePolyfill } from "./http.mjs";
+import { URLPolyfill, URLSearchParamsPolyfill } from "./url.mjs";
+import { BlobPolyfill, FormDataPolyfill } from "./web.mjs";
+import { XMLHttpRequestPolyfill } from "./xhr.mjs";
+
+//#region src/index.d.ts
+type WeappInjectRequestGlobalsTarget = 'fetch' | 'Headers' | 'Request' | 'Response' | 'AbortController' | 'AbortSignal' | 'XMLHttpRequest';
+interface InstallRequestGlobalsOptions {
+  targets?: WeappInjectRequestGlobalsTarget[];
+}
+/**
+ * @description 按需向小程序全局环境注入缺失的请求相关对象。
+ */
+declare function installRequestGlobals(options?: InstallRequestGlobalsOptions): Record<string, any>;
+/**
+ * @description 仅安装 AbortController 与 AbortSignal 兼容层。
+ */
+declare function installAbortGlobals(): Record<string, any>;
+//#endregion
+export { AbortControllerPolyfill, AbortSignalPolyfill, BlobPolyfill, FormDataPolyfill, HeadersPolyfill, InstallRequestGlobalsOptions, RequestGlobalsEventTarget, RequestPolyfill, ResponsePolyfill, URLPolyfill, URLSearchParamsPolyfill, WeappInjectRequestGlobalsTarget, XMLHttpRequestPolyfill, fetch, installAbortGlobals, installRequestGlobals };

package/dist/index.mjs

@@ -0,0 +1,83 @@
+import { RequestGlobalsEventTarget, installRequestGlobalBinding, resolveRequestGlobalsHost, resolveRequestGlobalsHosts } from "./shared.mjs";
+import { AbortControllerPolyfill, AbortSignalPolyfill } from "./abort.mjs";
+import { HeadersPolyfill, RequestPolyfill, ResponsePolyfill } from "./http.mjs";
+import { fetch } from "./fetch.mjs";
+import { URLPolyfill, URLSearchParamsPolyfill } from "./url.mjs";
+import { BlobPolyfill, FormDataPolyfill } from "./web.mjs";
+import { XMLHttpRequestPolyfill } from "./xhr.mjs";
+//#region src/index.ts
+function installSingleTarget(host, target) {
+	if (target === "fetch") {
+		if (typeof host.fetch !== "function") host.fetch = fetch;
+		return;
+	}
+	if (target === "Headers") {
+		if (typeof host.Headers !== "function") host.Headers = HeadersPolyfill;
+		return;
+	}
+	if (target === "Request") {
+		if (typeof host.Request !== "function") host.Request = RequestPolyfill;
+		return;
+	}
+	if (target === "Response") {
+		if (typeof host.Response !== "function") host.Response = ResponsePolyfill;
+		return;
+	}
+	if (target === "AbortController") {
+		if (typeof host.AbortController !== "function") host.AbortController = AbortControllerPolyfill;
+		return;
+	}
+	if (target === "AbortSignal") {
+		if (typeof host.AbortSignal !== "function") host.AbortSignal = AbortSignalPolyfill;
+		return;
+	}
+	if (target === "XMLHttpRequest" && typeof host.XMLHttpRequest !== "function") host.XMLHttpRequest = XMLHttpRequestPolyfill;
+}
+function installUrlGlobals(host) {
+	if (typeof host.URL !== "function") host.URL = URLPolyfill;
+	if (typeof host.URLSearchParams !== "function") host.URLSearchParams = URLSearchParamsPolyfill;
+	if (typeof host.Blob !== "function") host.Blob = BlobPolyfill;
+	if (typeof host.FormData !== "function") host.FormData = FormDataPolyfill;
+}
+function installGlobalBindingIfNeeded(host, target) {
+	const value = host[target];
+	if (value == null) return;
+	installRequestGlobalBinding(target, value);
+}
+/**
+* @description 按需向小程序全局环境注入缺失的请求相关对象。
+*/
+function installRequestGlobals(options = {}) {
+	const targets = options.targets ?? [
+		"fetch",
+		"Headers",
+		"Request",
+		"Response",
+		"AbortController",
+		"AbortSignal",
+		"XMLHttpRequest"
+	];
+	const hosts = resolveRequestGlobalsHosts();
+	const primaryHost = resolveRequestGlobalsHost();
+	const needsUrlGlobals = targets.some((target) => target === "fetch" || target === "Request" || target === "Response" || target === "XMLHttpRequest");
+	for (const host of hosts) {
+		if (needsUrlGlobals) installUrlGlobals(host);
+		for (const target of targets) installSingleTarget(host, target);
+	}
+	if (needsUrlGlobals) {
+		installGlobalBindingIfNeeded(primaryHost, "URL");
+		installGlobalBindingIfNeeded(primaryHost, "URLSearchParams");
+		installGlobalBindingIfNeeded(primaryHost, "Blob");
+		installGlobalBindingIfNeeded(primaryHost, "FormData");
+	}
+	for (const target of targets) installGlobalBindingIfNeeded(primaryHost, target);
+	return hosts[0];
+}
+/**
+* @description 仅安装 AbortController 与 AbortSignal 兼容层。
+*/
+function installAbortGlobals() {
+	return installRequestGlobals({ targets: ["AbortController", "AbortSignal"] });
+}
+//#endregion
+export { AbortControllerPolyfill, AbortSignalPolyfill, BlobPolyfill, FormDataPolyfill, HeadersPolyfill, RequestGlobalsEventTarget, RequestPolyfill, ResponsePolyfill, URLPolyfill, URLSearchParamsPolyfill, XMLHttpRequestPolyfill, fetch, installAbortGlobals, installRequestGlobals };

package/dist/shared.d.mts

@@ -0,0 +1,28 @@
+//#region src/shared.d.ts
+interface RequestGlobalsEventLike {
+  type: string;
+  target?: unknown;
+  currentTarget?: unknown;
+}
+interface RequestGlobalsEventTargetLike {
+  addEventListener: (type: string, listener: (event: RequestGlobalsEventLike) => void) => void;
+  removeEventListener: (type: string, listener: (event: RequestGlobalsEventLike) => void) => void;
+  dispatchEvent: (event: RequestGlobalsEventLike) => boolean;
+}
+type EventListener = (event: RequestGlobalsEventLike) => void;
+declare class RequestGlobalsEventTarget implements RequestGlobalsEventTargetLike {
+  private readonly listeners;
+  addEventListener(type: string, listener: EventListener): void;
+  removeEventListener(type: string, listener: EventListener): void;
+  dispatchEvent(event: RequestGlobalsEventLike): boolean;
+}
+declare function resolveRequestGlobalsHost(): Record<string, any>;
+declare function resolveRequestGlobalsHosts(): Record<string, any>[];
+declare function installRequestGlobalBinding(name: string, value: unknown): void;
+declare function cloneArrayBuffer(buffer: ArrayBuffer): ArrayBuffer;
+declare function cloneArrayBufferView(view: ArrayBufferView): ArrayBuffer;
+declare function encodeText(value: string): ArrayBuffer;
+declare function decodeText(value: ArrayBuffer): string;
+declare function normalizeHeaderName(name: string): string;
+//#endregion
+export { RequestGlobalsEventLike, RequestGlobalsEventTarget, RequestGlobalsEventTargetLike, cloneArrayBuffer, cloneArrayBufferView, decodeText, encodeText, installRequestGlobalBinding, normalizeHeaderName, resolveRequestGlobalsHost, resolveRequestGlobalsHosts };