@wevu/web-apis 1.0.0

package/dist/shared.mjs

@@ -0,0 +1,73 @@
+//#region src/shared.ts
+var RequestGlobalsEventTarget = class {
+	listeners = /* @__PURE__ */ new Map();
+	addEventListener(type, listener) {
+		const set = this.listeners.get(type) ?? /* @__PURE__ */ new Set();
+		set.add(listener);
+		this.listeners.set(type, set);
+	}
+	removeEventListener(type, listener) {
+		this.listeners.get(type)?.delete(listener);
+	}
+	dispatchEvent(event) {
+		const payload = {
+			...event,
+			target: event.target ?? this,
+			currentTarget: event.currentTarget ?? this
+		};
+		for (const listener of this.listeners.get(event.type) ?? []) listener(payload);
+		const handlerKey = `on${event.type}`;
+		const handler = this[handlerKey];
+		if (typeof handler === "function") handler(payload);
+		return true;
+	}
+};
+function resolveRequestGlobalsHost() {
+	if (typeof globalThis !== "undefined") return globalThis;
+	return {};
+}
+function resolveRequestGlobalsHosts() {
+	const hosts = [];
+	const primaryHost = resolveRequestGlobalsHost();
+	hosts.push(primaryHost);
+	for (const key of [
+		"wx",
+		"my",
+		"tt"
+	]) {
+		const candidate = primaryHost[key];
+		if (candidate && typeof candidate === "object" && !hosts.includes(candidate)) hosts.push(candidate);
+	}
+	return hosts;
+}
+function installRequestGlobalBinding(name, value) {
+	if (!name) return;
+	try {
+		Function("__weappRequestGlobalValue__", `${name} = __weappRequestGlobalValue__`)(value);
+	} catch {}
+}
+function cloneArrayBuffer(buffer) {
+	return buffer.slice(0);
+}
+function cloneArrayBufferView(view) {
+	const copied = new Uint8Array(view.byteLength);
+	copied.set(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+	return copied.buffer;
+}
+function encodeText(value) {
+	if (typeof TextEncoder === "function") return new TextEncoder().encode(value).buffer;
+	const bytes = new Uint8Array(value.length);
+	for (let i = 0; i < value.length; i++) bytes[i] = value.charCodeAt(i) & 255;
+	return bytes.buffer;
+}
+function decodeText(value) {
+	if (typeof TextDecoder === "function") return new TextDecoder().decode(value);
+	let text = "";
+	for (const byte of new Uint8Array(value)) text += String.fromCharCode(byte);
+	return text;
+}
+function normalizeHeaderName(name) {
+	return name.trim().toLowerCase();
+}
+//#endregion
+export { RequestGlobalsEventTarget, cloneArrayBuffer, cloneArrayBufferView, decodeText, encodeText, installRequestGlobalBinding, normalizeHeaderName, resolveRequestGlobalsHost, resolveRequestGlobalsHosts };

package/dist/url.d.mts

@@ -0,0 +1,46 @@
+//#region src/url.d.ts
+type URLSearchParamValue = string | readonly string[];
+declare class URLSearchParamsPolyfill {
+  private readonly onChange?;
+  private readonly entriesStore;
+  constructor(init?: string | URLSearchParamsPolyfill | Record<string, URLSearchParamValue> | Iterable<[string, string]>, onChange?: (() => void) | undefined);
+  append(key: string, value: string): void;
+  delete(key: string): void;
+  get(key: string): string | null;
+  getAll(key: string): string[];
+  has(key: string): boolean;
+  set(key: string, value: string): void;
+  forEach(callback: (value: string, key: string) => void): void;
+  entries(): ArrayIterator<[string, string]>;
+  keys(): ArrayIterator<string>;
+  values(): ArrayIterator<string>;
+  toString(): string;
+  [Symbol.iterator](): ArrayIterator<[string, string]>;
+}
+declare class URLPolyfill {
+  private hashValue;
+  private hrefValue;
+  private searchValue;
+  host: string;
+  hostname: string;
+  origin: string;
+  password: string;
+  pathname: string;
+  port: string;
+  protocol: string;
+  username: string;
+  readonly searchParams: URLSearchParamsPolyfill;
+  constructor(input: string | URLPolyfill, base?: string | URLPolyfill);
+  get hash(): string;
+  set hash(value: string);
+  get href(): string;
+  get search(): string;
+  set search(value: string);
+  toString(): string;
+  toJSON(): string;
+  private resetSearchParams;
+  private updateHref;
+  private syncSearchFromParams;
+}
+//#endregion
+export { URLPolyfill, URLSearchParamsPolyfill };

package/dist/url.mjs

@@ -0,0 +1,209 @@
+//#region src/url.ts
+const PLUS_REGEXP = /\+/g;
+const LEADING_QUERY_REGEXP = /^\?/;
+const ABSOLUTE_URL_REGEXP = /^([a-z][a-z\d+.-]*:)?\/\/([^/?#]+)(\/[^?#]*)?(\?[^#]*)?(#.*)?$/i;
+const ABSOLUTE_URL_PREFIX_REGEXP = /^[a-z][a-z\d+.-]*:\/\//i;
+const ENCODED_SPACE_REGEXP = /%20/g;
+const HOST_WITH_PORT_REGEXP = /^([^:]*)(?::(.*))?$/;
+function encodeSearchParam(value) {
+	return encodeURIComponent(value).replace(ENCODED_SPACE_REGEXP, "+");
+}
+function decodeSearchParam(value) {
+	return decodeURIComponent(value.replace(PLUS_REGEXP, " "));
+}
+function normalizeSearchSource(input) {
+	return input.replace(LEADING_QUERY_REGEXP, "");
+}
+function parseSearchEntries(input) {
+	if (!input) return [];
+	return normalizeSearchSource(input).split("&").filter(Boolean).map((segment) => {
+		const separatorIndex = segment.indexOf("=");
+		if (separatorIndex === -1) return [decodeSearchParam(segment), ""];
+		return [decodeSearchParam(segment.slice(0, separatorIndex)), decodeSearchParam(segment.slice(separatorIndex + 1))];
+	});
+}
+function serializeSearchEntries(entries) {
+	return entries.map(([key, value]) => `${encodeSearchParam(key)}=${encodeSearchParam(value)}`).join("&");
+}
+function parseAbsoluteUrl(input) {
+	const match = input.match(ABSOLUTE_URL_REGEXP);
+	if (!match) return null;
+	const protocol = match[1] ?? "";
+	const host = match[2] ?? "";
+	const pathname = match[3] || "/";
+	const search = match[4] ?? "";
+	const hash = match[5] ?? "";
+	const hostnameMatch = host.match(HOST_WITH_PORT_REGEXP);
+	return {
+		protocol,
+		host,
+		hostname: hostnameMatch?.[1] ?? host,
+		port: hostnameMatch?.[2] ?? "",
+		pathname,
+		search,
+		hash,
+		origin: protocol && host ? `${protocol}//${host}` : "",
+		href: `${protocol}//${host}${pathname}${search}${hash}`
+	};
+}
+function resolveRelativeUrl(input, base) {
+	const parsedBase = parseAbsoluteUrl(base);
+	if (!parsedBase) throw new TypeError(`Failed to construct URL from base ${base}`);
+	if (input.startsWith("//")) return `${parsedBase.protocol}${input}`;
+	if (input.startsWith("/")) return `${parsedBase.origin}${input}`;
+	if (input.startsWith("?") || input.startsWith("#")) {
+		const pathname = parsedBase.pathname || "/";
+		return `${`${parsedBase.origin}${pathname}`}${input}`;
+	}
+	const basePathSegments = parsedBase.pathname.split("/").slice(0, -1);
+	for (const segment of input.split("/")) {
+		if (!segment || segment === ".") continue;
+		if (segment === "..") {
+			basePathSegments.pop();
+			continue;
+		}
+		basePathSegments.push(segment);
+	}
+	return `${parsedBase.origin}/${basePathSegments.join("/")}`;
+}
+var URLSearchParamsPolyfill = class {
+	entriesStore = [];
+	constructor(init, onChange) {
+		this.onChange = onChange;
+		if (!init) return;
+		if (typeof init === "string") {
+			this.entriesStore.push(...parseSearchEntries(init));
+			return;
+		}
+		if (typeof init[Symbol.iterator] === "function") {
+			for (const [key, value] of init) this.append(key, value);
+			return;
+		}
+		for (const [key, value] of Object.entries(init)) {
+			if (Array.isArray(value)) {
+				for (const item of value) this.append(key, item);
+				continue;
+			}
+			this.append(key, value);
+		}
+	}
+	append(key, value) {
+		this.entriesStore.push([String(key), String(value)]);
+		this.onChange?.();
+	}
+	delete(key) {
+		const normalizedKey = String(key);
+		let changed = false;
+		for (let i = this.entriesStore.length - 1; i >= 0; i--) if (this.entriesStore[i]?.[0] === normalizedKey) {
+			this.entriesStore.splice(i, 1);
+			changed = true;
+		}
+		if (changed) this.onChange?.();
+	}
+	get(key) {
+		const normalizedKey = String(key);
+		return this.entriesStore.find(([entryKey]) => entryKey === normalizedKey)?.[1] ?? null;
+	}
+	getAll(key) {
+		const normalizedKey = String(key);
+		return this.entriesStore.filter(([entryKey]) => entryKey === normalizedKey).map(([, value]) => value);
+	}
+	has(key) {
+		return this.entriesStore.some(([entryKey]) => entryKey === String(key));
+	}
+	set(key, value) {
+		this.delete(key);
+		this.append(key, value);
+	}
+	forEach(callback) {
+		for (const [key, value] of this.entriesStore) callback(value, key);
+	}
+	entries() {
+		return this.entriesStore[Symbol.iterator]();
+	}
+	keys() {
+		return this.entriesStore.map(([key]) => key)[Symbol.iterator]();
+	}
+	values() {
+		return this.entriesStore.map(([, value]) => value)[Symbol.iterator]();
+	}
+	toString() {
+		return serializeSearchEntries(this.entriesStore);
+	}
+	[Symbol.iterator]() {
+		return this.entries();
+	}
+};
+var URLPolyfill = class {
+	hashValue = "";
+	hrefValue = "";
+	searchValue = "";
+	host = "";
+	hostname = "";
+	origin = "";
+	password = "";
+	pathname = "/";
+	port = "";
+	protocol = "";
+	username = "";
+	searchParams;
+	constructor(input, base) {
+		const inputString = typeof input === "string" ? input : input.toString();
+		const baseString = typeof base === "string" ? base : base ? base.toString() : void 0;
+		const parsed = parseAbsoluteUrl(ABSOLUTE_URL_PREFIX_REGEXP.test(inputString) ? inputString : baseString ? resolveRelativeUrl(inputString, baseString) : inputString);
+		if (!parsed) throw new TypeError(`Failed to construct URL from ${inputString}`);
+		this.protocol = parsed.protocol;
+		this.host = parsed.host;
+		this.hostname = parsed.hostname;
+		this.port = parsed.port;
+		this.pathname = parsed.pathname;
+		this.searchValue = parsed.search;
+		this.hashValue = parsed.hash;
+		this.origin = parsed.origin;
+		this.searchParams = new URLSearchParamsPolyfill(parsed.search, () => {
+			this.syncSearchFromParams();
+		});
+		this.updateHref();
+	}
+	get hash() {
+		return this.hashValue;
+	}
+	set hash(value) {
+		this.hashValue = value ? value.startsWith("#") ? value : `#${value}` : "";
+		this.updateHref();
+	}
+	get href() {
+		return this.hrefValue;
+	}
+	get search() {
+		return this.searchValue;
+	}
+	set search(value) {
+		this.searchValue = value ? value.startsWith("?") ? value : `?${value}` : "";
+		this.resetSearchParams(this.searchValue);
+		this.updateHref();
+	}
+	toString() {
+		return this.hrefValue;
+	}
+	toJSON() {
+		return this.toString();
+	}
+	resetSearchParams(value) {
+		const nextParams = new URLSearchParamsPolyfill(value);
+		this.searchParams.entriesStore.splice(0, this.searchParams.entriesStore.length);
+		nextParams.forEach((entryValue, entryKey) => {
+			this.searchParams.entriesStore.push([entryKey, entryValue]);
+		});
+	}
+	updateHref() {
+		this.hrefValue = `${this.protocol}//${this.host}${this.pathname}${this.searchValue}${this.hashValue}`;
+	}
+	syncSearchFromParams() {
+		const search = this.searchParams.toString();
+		this.searchValue = search ? `?${search}` : "";
+		this.updateHref();
+	}
+};
+//#endregion
+export { URLPolyfill, URLSearchParamsPolyfill };

package/dist/web.d.mts

@@ -0,0 +1,30 @@
+//#region src/web.d.ts
+type BlobPart = ArrayBuffer | ArrayBufferView | BlobPolyfill | string;
+declare class BlobPolyfill {
+  readonly size: number;
+  readonly type: string;
+  private readonly parts;
+  constructor(parts?: BlobPart[], options?: {
+    type?: string;
+  });
+  arrayBuffer(): Promise<any>;
+  text(): Promise<string>;
+}
+type FormDataEntryValue = BlobPolyfill | string;
+declare class FormDataPolyfill {
+  private readonly entriesList;
+  append(name: string, value: FormDataEntryValue): void;
+  delete(name: string): void;
+  get(name: string): FormDataEntryValue | null;
+  getAll(name: string): FormDataEntryValue[];
+  has(name: string): boolean;
+  set(name: string, value: FormDataEntryValue): void;
+  forEach(callback: (value: FormDataEntryValue, key: string, parent: FormDataPolyfill) => void): void;
+  entries(): Generator<[string, FormDataEntryValue], void, unknown>;
+  keys(): Generator<string, void, unknown>;
+  values(): Generator<FormDataEntryValue, void, unknown>;
+  [Symbol.iterator](): Generator<[string, FormDataEntryValue], void, unknown>;
+  get [Symbol.toStringTag](): string;
+}
+//#endregion
+export { BlobPolyfill, FormDataPolyfill };

package/dist/web.mjs

@@ -0,0 +1,83 @@
+import { cloneArrayBuffer, cloneArrayBufferView, decodeText, encodeText } from "./shared.mjs";
+//#region src/web.ts
+function normalizeBlobPart(part) {
+	if (typeof part === "string") return encodeText(part);
+	if (part && typeof part === "object" && typeof part.arrayBuffer === "function") return part.arrayBuffer();
+	if (part instanceof ArrayBuffer) return Promise.resolve(cloneArrayBuffer(part));
+	if (ArrayBuffer.isView(part)) return Promise.resolve(cloneArrayBufferView(part));
+	return Promise.resolve(encodeText(String(part)));
+}
+var BlobPolyfill = class BlobPolyfill {
+	size;
+	type;
+	parts;
+	constructor(parts = [], options) {
+		this.parts = [...parts];
+		this.type = options?.type ?? "";
+		this.size = parts.reduce((total, part) => {
+			if (typeof part === "string") return total + String(part).length;
+			if (part instanceof BlobPolyfill) return total + part.size;
+			if (part instanceof ArrayBuffer) return total + part.byteLength;
+			if (ArrayBuffer.isView(part)) return total + part.byteLength;
+			return total;
+		}, 0);
+	}
+	async arrayBuffer() {
+		const buffers = await Promise.all(this.parts.map((part) => normalizeBlobPart(part)));
+		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;
+	}
+	async text() {
+		return decodeText(await this.arrayBuffer());
+	}
+};
+var FormDataPolyfill = class {
+	entriesList = [];
+	append(name, value) {
+		this.entriesList.push([String(name), value instanceof BlobPolyfill ? value : String(value)]);
+	}
+	delete(name) {
+		const normalizedName = String(name);
+		let index = this.entriesList.length;
+		while (index-- > 0) if (this.entriesList[index]?.[0] === normalizedName) this.entriesList.splice(index, 1);
+	}
+	get(name) {
+		return this.entriesList.find((entry) => entry[0] === String(name))?.[1] ?? null;
+	}
+	getAll(name) {
+		return this.entriesList.filter((entry) => entry[0] === String(name)).map((entry) => entry[1]);
+	}
+	has(name) {
+		return this.entriesList.some((entry) => entry[0] === String(name));
+	}
+	set(name, value) {
+		this.delete(name);
+		this.append(name, value);
+	}
+	forEach(callback) {
+		for (const [key, value] of this.entriesList) callback(value, key, this);
+	}
+	*entries() {
+		yield* this.entriesList;
+	}
+	*keys() {
+		for (const [key] of this.entriesList) yield key;
+	}
+	*values() {
+		for (const [, value] of this.entriesList) yield value;
+	}
+	[Symbol.iterator]() {
+		return this.entries();
+	}
+	get [Symbol.toStringTag]() {
+		return "FormData";
+	}
+};
+//#endregion
+export { BlobPolyfill, FormDataPolyfill };

package/dist/xhr.d.mts

@@ -0,0 +1,68 @@
+import { RequestGlobalsEventTarget } from "./shared.mjs";
+
+//#region src/xhr.d.ts
+type XhrBody = Document | XMLHttpRequestBodyInit | null | undefined;
+declare class XMLHttpRequestUploadPolyfill extends RequestGlobalsEventTarget {}
+declare class XMLHttpRequestPolyfill extends RequestGlobalsEventTarget {
+  static readonly UNSENT = 0;
+  static readonly OPENED = 1;
+  static readonly HEADERS_RECEIVED = 2;
+  static readonly LOADING = 3;
+  static readonly DONE = 4;
+  readonly UNSENT = 0;
+  readonly OPENED = 1;
+  readonly HEADERS_RECEIVED = 2;
+  readonly LOADING = 3;
+  readonly DONE = 4;
+  readonly upload: XMLHttpRequestUploadPolyfill;
+  readyState: number;
+  response: any;
+  responseText: string;
+  responseType: XMLHttpRequestResponseType;
+  responseURL: string;
+  status: number;
+  statusText: string;
+  timeout: number;
+  withCredentials: boolean;
+  onreadystatechange: ((event: {
+    type: string;
+  }) => void) | null;
+  onabort: ((event: {
+    type: string;
+  }) => void) | null;
+  onerror: ((event: {
+    type: string;
+  }) => void) | null;
+  onload: ((event: {
+    type: string;
+  }) => void) | null;
+  onloadend: ((event: {
+    type: string;
+  }) => void) | null;
+  onloadstart: ((event: {
+    type: string;
+  }) => void) | null;
+  onprogress: ((event: {
+    type: string;
+  }) => void) | null;
+  ontimeout: ((event: {
+    type: string;
+  }) => void) | null;
+  private method;
+  private url;
+  private readonly requestHeaders;
+  private responseHeaders;
+  private requestController;
+  private timeoutId;
+  private sent;
+  open(method: string, url: string): void;
+  setRequestHeader(key: string, value: string): void;
+  getAllResponseHeaders(): string;
+  getResponseHeader(key: string): string | null;
+  abort(): void;
+  send(body?: XhrBody): Promise<void>;
+  private finish;
+  private transitionTo;
+}
+//#endregion
+export { XMLHttpRequestPolyfill, XMLHttpRequestUploadPolyfill };

package/dist/xhr.mjs

@@ -0,0 +1,161 @@
+import { RequestGlobalsEventTarget, resolveRequestGlobalsHost } from "./shared.mjs";
+import { AbortControllerPolyfill } from "./abort.mjs";
+import { HeadersPolyfill, headersToObject } from "./http.mjs";
+import { fetch } from "./fetch.mjs";
+//#region src/xhr.ts
+function createProgressEvent(type) {
+	return {
+		type,
+		lengthComputable: false,
+		loaded: 0,
+		total: 0
+	};
+}
+function createError(type) {
+	const error = new Error(type);
+	error.name = type === "abort" ? "AbortError" : type === "timeout" ? "TimeoutError" : "NetworkError";
+	return error;
+}
+function resolveFetch() {
+	const host = resolveRequestGlobalsHost();
+	return typeof host.fetch === "function" ? host.fetch.bind(host) : fetch;
+}
+var XMLHttpRequestUploadPolyfill = class extends RequestGlobalsEventTarget {};
+var XMLHttpRequestPolyfill = class XMLHttpRequestPolyfill extends RequestGlobalsEventTarget {
+	static UNSENT = 0;
+	static OPENED = 1;
+	static HEADERS_RECEIVED = 2;
+	static LOADING = 3;
+	static DONE = 4;
+	UNSENT = XMLHttpRequestPolyfill.UNSENT;
+	OPENED = XMLHttpRequestPolyfill.OPENED;
+	HEADERS_RECEIVED = XMLHttpRequestPolyfill.HEADERS_RECEIVED;
+	LOADING = XMLHttpRequestPolyfill.LOADING;
+	DONE = XMLHttpRequestPolyfill.DONE;
+	upload = new XMLHttpRequestUploadPolyfill();
+	readyState = XMLHttpRequestPolyfill.UNSENT;
+	response = null;
+	responseText = "";
+	responseType = "";
+	responseURL = "";
+	status = 0;
+	statusText = "";
+	timeout = 0;
+	withCredentials = false;
+	onreadystatechange = null;
+	onabort = null;
+	onerror = null;
+	onload = null;
+	onloadend = null;
+	onloadstart = null;
+	onprogress = null;
+	ontimeout = null;
+	method = "GET";
+	url = "";
+	requestHeaders = new HeadersPolyfill();
+	responseHeaders = new HeadersPolyfill();
+	requestController = null;
+	timeoutId = null;
+	sent = false;
+	open(method, url) {
+		this.method = String(method || "GET").toUpperCase();
+		this.url = url;
+		this.status = 0;
+		this.statusText = "";
+		this.response = null;
+		this.responseText = "";
+		this.responseURL = "";
+		this.responseHeaders = new HeadersPolyfill();
+		this.sent = false;
+		this.transitionTo(XMLHttpRequestPolyfill.OPENED);
+	}
+	setRequestHeader(key, value) {
+		if (this.readyState !== XMLHttpRequestPolyfill.OPENED || this.sent) throw new Error("Failed to execute setRequestHeader: invalid readyState");
+		this.requestHeaders.append(key, value);
+	}
+	getAllResponseHeaders() {
+		if (this.readyState < XMLHttpRequestPolyfill.HEADERS_RECEIVED) return "";
+		let content = "";
+		this.responseHeaders.forEach((value, key) => {
+			content += `${key}: ${value}\r\n`;
+		});
+		return content;
+	}
+	getResponseHeader(key) {
+		if (this.readyState < XMLHttpRequestPolyfill.HEADERS_RECEIVED) return null;
+		return this.responseHeaders.get(key);
+	}
+	abort() {
+		if (!this.requestController) return;
+		this.requestController.abort();
+	}
+	async send(body) {
+		if (this.readyState !== XMLHttpRequestPolyfill.OPENED) throw new Error("Failed to execute send: invalid readyState");
+		this.sent = true;
+		this.dispatchEvent({ type: "loadstart" });
+		this.upload.dispatchEvent(createProgressEvent("loadstart"));
+		const controller = new (typeof AbortController === "function" ? AbortController : AbortControllerPolyfill)();
+		this.requestController = controller;
+		if (this.timeout > 0) this.timeoutId = setTimeout(() => {
+			controller.abort(createError("timeout"));
+		}, this.timeout);
+		try {
+			const response = await resolveFetch()(this.url, {
+				method: this.method,
+				headers: headersToObject(this.requestHeaders),
+				body,
+				signal: controller.signal
+			});
+			this.responseHeaders = typeof Headers === "function" && response.headers instanceof Headers ? response.headers : new HeadersPolyfill(response.headers);
+			this.status = response.status;
+			this.statusText = response.statusText ?? "";
+			this.responseURL = response.url ?? this.url;
+			this.transitionTo(XMLHttpRequestPolyfill.HEADERS_RECEIVED);
+			this.transitionTo(XMLHttpRequestPolyfill.LOADING);
+			if (this.responseType === "arraybuffer") this.response = await response.arrayBuffer();
+			else {
+				const text = await response.text();
+				this.responseText = text;
+				this.response = this.responseType === "json" ? text ? JSON.parse(text) : null : text;
+			}
+			this.finish("load");
+		} catch (error) {
+			const reason = controller.signal && "reason" in controller.signal ? controller.signal.reason : void 0;
+			if (controller.signal?.aborted) {
+				const type = reason instanceof Error && reason.name === "TimeoutError" ? "timeout" : "abort";
+				this.finish(type);
+				return;
+			}
+			this.response = null;
+			this.responseText = "";
+			this.status = 0;
+			this.statusText = "";
+			this.transitionTo(XMLHttpRequestPolyfill.DONE);
+			this.dispatchEvent({ type: "error" });
+			this.dispatchEvent({ type: "loadend" });
+			throw error;
+		} finally {
+			if (this.timeoutId) {
+				clearTimeout(this.timeoutId);
+				this.timeoutId = null;
+			}
+			this.requestController = null;
+		}
+	}
+	finish(type) {
+		this.transitionTo(XMLHttpRequestPolyfill.DONE);
+		if (type === "abort") this.dispatchEvent({ type: "abort" });
+		else if (type === "timeout") this.dispatchEvent({ type: "timeout" });
+		else {
+			this.dispatchEvent(createProgressEvent("progress"));
+			this.dispatchEvent({ type: "load" });
+		}
+		this.dispatchEvent({ type: "loadend" });
+	}
+	transitionTo(nextState) {
+		this.readyState = nextState;
+		this.dispatchEvent({ type: "readystatechange" });
+	}
+};
+//#endregion
+export { XMLHttpRequestPolyfill, XMLHttpRequestUploadPolyfill };