@npy/fetch 0.1.0 → 0.1.1

package/fetch.cjs

@@ -0,0 +1,117 @@
+const require_tcp = require("./dialers/tcp.cjs");
+const require_error_adapters = require("./_internal/error-adapters.cjs");
+const require_http_client = require("./http-client.cjs");
+//#region src/fetch.ts
+function createDefaultHttpClient(options = {}) {
+	return new require_http_client.HttpClient({
+		...options,
+		dialer: options.dialer ?? new require_tcp.AutoDialer()
+	});
+}
+function normalizeHeaders(headers) {
+	if (headers instanceof Headers) return headers;
+	const normalized = new Headers();
+	if (Array.isArray(headers)) {
+		headers.forEach(([key, value]) => {
+			normalized.append(key, value);
+		});
+		return normalized;
+	}
+	if (headers) Object.entries(headers).forEach(([key, value]) => {
+		if (Array.isArray(value)) value.forEach((entry) => {
+			normalized.append(key, entry);
+		});
+		else if (value !== void 0) normalized.append(key, value);
+	});
+	return normalized;
+}
+function resolveUrl(input) {
+	if (input instanceof URL) return input;
+	if (input instanceof Request) return new URL(input.url);
+	return new URL(String(input));
+}
+function resolveMethod(input, init) {
+	if (init.method != null) return init.method.toUpperCase();
+	if (input instanceof Request) return input.method.toUpperCase();
+	return "GET";
+}
+function resolveHeaders(input, init) {
+	if (init.headers !== void 0) return normalizeHeaders(init.headers);
+	if (input instanceof Request) return normalizeHeaders(input.headers);
+	return new Headers();
+}
+function resolveSignal(input, init) {
+	return init.signal ?? (input instanceof Request ? input.signal : void 0);
+}
+function resolveBody(input, init) {
+	if (init.body !== void 0) return init.body;
+	if (!(input instanceof Request)) return;
+	if (input.bodyUsed) throw new TypeError("Request body has already been used");
+	return input.body;
+}
+function assertValidFetchUrl(url) {
+	if (url.username || url.password) throw new TypeError("Request URL must not include embedded credentials");
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new TypeError(`fetch failed: unsupported scheme ${url.protocol}`);
+}
+function assertValidFetchBody(method, body) {
+	if (body == null) return;
+	if (method === "GET" || method === "HEAD") throw new TypeError(`Request with ${method} method cannot have a body`);
+}
+async function fetchImpl(input, init) {
+	const url = resolveUrl(input);
+	assertValidFetchUrl(url);
+	const method = resolveMethod(input, init);
+	const headers = resolveHeaders(input, init);
+	const body = resolveBody(input, init);
+	const signal = resolveSignal(input, init);
+	assertValidFetchBody(method, body);
+	try {
+		return require_error_adapters.wrapResponseBodyErrors(await init.client.send({
+			url,
+			method,
+			headers,
+			body: body ?? null,
+			signal
+		}), (error) => require_error_adapters.toWebBodyReadError(error, signal));
+	} catch (error) {
+		throw require_error_adapters.toWebFetchError(error, signal);
+	}
+}
+function createFetch(client) {
+	const defaultHttpClient = client ?? createDefaultHttpClient();
+	const fetchLike = (async (input, init = {}) => {
+		return fetchImpl(input, init.client == null ? {
+			...init,
+			client: defaultHttpClient
+		} : init);
+	});
+	const close = async () => {
+		if (client == null) await defaultHttpClient.close();
+	};
+	Object.defineProperties(fetchLike, {
+		client: {
+			configurable: false,
+			enumerable: false,
+			value: defaultHttpClient,
+			writable: false
+		},
+		close: {
+			configurable: false,
+			enumerable: false,
+			value: close,
+			writable: false
+		},
+		[Symbol.asyncDispose]: {
+			configurable: false,
+			enumerable: false,
+			value: close,
+			writable: false
+		}
+	});
+	return fetchLike;
+}
+var fetch = createFetch();
+//#endregion
+exports.createFetch = createFetch;
+exports.default = fetch;
+exports.normalizeHeaders = normalizeHeaders;

package/fetch.js

@@ -0,0 +1,115 @@
+import { AutoDialer } from "./dialers/tcp.js";
+import { toWebBodyReadError, toWebFetchError, wrapResponseBodyErrors } from "./_internal/error-adapters.js";
+import { HttpClient } from "./http-client.js";
+//#region src/fetch.ts
+function createDefaultHttpClient(options = {}) {
+	return new HttpClient({
+		...options,
+		dialer: options.dialer ?? new AutoDialer()
+	});
+}
+function normalizeHeaders(headers) {
+	if (headers instanceof Headers) return headers;
+	const normalized = new Headers();
+	if (Array.isArray(headers)) {
+		headers.forEach(([key, value]) => {
+			normalized.append(key, value);
+		});
+		return normalized;
+	}
+	if (headers) Object.entries(headers).forEach(([key, value]) => {
+		if (Array.isArray(value)) value.forEach((entry) => {
+			normalized.append(key, entry);
+		});
+		else if (value !== void 0) normalized.append(key, value);
+	});
+	return normalized;
+}
+function resolveUrl(input) {
+	if (input instanceof URL) return input;
+	if (input instanceof Request) return new URL(input.url);
+	return new URL(String(input));
+}
+function resolveMethod(input, init) {
+	if (init.method != null) return init.method.toUpperCase();
+	if (input instanceof Request) return input.method.toUpperCase();
+	return "GET";
+}
+function resolveHeaders(input, init) {
+	if (init.headers !== void 0) return normalizeHeaders(init.headers);
+	if (input instanceof Request) return normalizeHeaders(input.headers);
+	return new Headers();
+}
+function resolveSignal(input, init) {
+	return init.signal ?? (input instanceof Request ? input.signal : void 0);
+}
+function resolveBody(input, init) {
+	if (init.body !== void 0) return init.body;
+	if (!(input instanceof Request)) return;
+	if (input.bodyUsed) throw new TypeError("Request body has already been used");
+	return input.body;
+}
+function assertValidFetchUrl(url) {
+	if (url.username || url.password) throw new TypeError("Request URL must not include embedded credentials");
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new TypeError(`fetch failed: unsupported scheme ${url.protocol}`);
+}
+function assertValidFetchBody(method, body) {
+	if (body == null) return;
+	if (method === "GET" || method === "HEAD") throw new TypeError(`Request with ${method} method cannot have a body`);
+}
+async function fetchImpl(input, init) {
+	const url = resolveUrl(input);
+	assertValidFetchUrl(url);
+	const method = resolveMethod(input, init);
+	const headers = resolveHeaders(input, init);
+	const body = resolveBody(input, init);
+	const signal = resolveSignal(input, init);
+	assertValidFetchBody(method, body);
+	try {
+		return wrapResponseBodyErrors(await init.client.send({
+			url,
+			method,
+			headers,
+			body: body ?? null,
+			signal
+		}), (error) => toWebBodyReadError(error, signal));
+	} catch (error) {
+		throw toWebFetchError(error, signal);
+	}
+}
+function createFetch(client) {
+	const defaultHttpClient = client ?? createDefaultHttpClient();
+	const fetchLike = (async (input, init = {}) => {
+		return fetchImpl(input, init.client == null ? {
+			...init,
+			client: defaultHttpClient
+		} : init);
+	});
+	const close = async () => {
+		if (client == null) await defaultHttpClient.close();
+	};
+	Object.defineProperties(fetchLike, {
+		client: {
+			configurable: false,
+			enumerable: false,
+			value: defaultHttpClient,
+			writable: false
+		},
+		close: {
+			configurable: false,
+			enumerable: false,
+			value: close,
+			writable: false
+		},
+		[Symbol.asyncDispose]: {
+			configurable: false,
+			enumerable: false,
+			value: close,
+			writable: false
+		}
+	});
+	return fetchLike;
+}
+var fetch = createFetch();
+//#endregion
+export { createFetch, fetch as default, normalizeHeaders };

package/http-client.cjs

@@ -0,0 +1,33 @@
+const require_agent_pool = require("./agent-pool.cjs");
+//#region src/http-client.ts
+var HttpClient = class {
+	#agentPools = /* @__PURE__ */ new Map();
+	#agentPoolOptions;
+	constructor(options = {}) {
+		this.#agentPoolOptions = { ...options };
+	}
+	async send(options) {
+		return this.#getOrCreateAgentPool(options.url).send(options);
+	}
+	async close() {
+		const entries = Array.from(this.#agentPools.entries());
+		const failed = (await Promise.allSettled(entries.map(([origin, agentPool]) => agentPool.close().then(() => {
+			this.#agentPools.delete(origin);
+		})))).find((r) => r.status === "rejected");
+		if (failed) throw failed.reason;
+	}
+	async [Symbol.asyncDispose]() {
+		await this.close();
+	}
+	#getOrCreateAgentPool(url) {
+		const origin = typeof url === "string" ? new URL(url).origin : url.origin;
+		let agentPool = this.#agentPools.get(origin);
+		if (!agentPool) {
+			agentPool = require_agent_pool.createAgentPool(origin, this.#agentPoolOptions);
+			this.#agentPools.set(origin, agentPool);
+		}
+		return agentPool;
+	}
+};
+//#endregion
+exports.HttpClient = HttpClient;

package/http-client.js

@@ -0,0 +1,33 @@
+import { createAgentPool } from "./agent-pool.js";
+//#region src/http-client.ts
+var HttpClient = class {
+	#agentPools = /* @__PURE__ */ new Map();
+	#agentPoolOptions;
+	constructor(options = {}) {
+		this.#agentPoolOptions = { ...options };
+	}
+	async send(options) {
+		return this.#getOrCreateAgentPool(options.url).send(options);
+	}
+	async close() {
+		const entries = Array.from(this.#agentPools.entries());
+		const failed = (await Promise.allSettled(entries.map(([origin, agentPool]) => agentPool.close().then(() => {
+			this.#agentPools.delete(origin);
+		})))).find((r) => r.status === "rejected");
+		if (failed) throw failed.reason;
+	}
+	async [Symbol.asyncDispose]() {
+		await this.close();
+	}
+	#getOrCreateAgentPool(url) {
+		const origin = typeof url === "string" ? new URL(url).origin : url.origin;
+		let agentPool = this.#agentPools.get(origin);
+		if (!agentPool) {
+			agentPool = createAgentPool(origin, this.#agentPoolOptions);
+			this.#agentPools.set(origin, agentPool);
+		}
+		return agentPool;
+	}
+};
+//#endregion
+export { HttpClient };

package/index.cjs

@@ -0,0 +1,45 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_net = require("./_internal/net.cjs");
+const require_body = require("./body.cjs");
+const require_proxy = require("./dialers/proxy.cjs");
+const require_tcp = require("./dialers/tcp.cjs");
+const require_encoding = require("./encoding.cjs");
+const require_errors = require("./errors.cjs");
+const require_http_client = require("./http-client.cjs");
+const require_fetch = require("./fetch.cjs");
+exports.AgentBusyError = require_errors.AgentBusyError;
+exports.AgentClosedError = require_errors.AgentClosedError;
+exports.AutoDialer = require_tcp.AutoDialer;
+exports.Body = require_body.Body;
+exports.ConnectTimeoutError = require_errors.ConnectTimeoutError;
+exports.ConnectionError = require_errors.ConnectionError;
+exports.ErrorType = require_errors.ErrorType;
+exports.FetchError = require_errors.FetchError;
+exports.FetchErrorCode = require_errors.FetchErrorCode;
+exports.HttpClient = require_http_client.HttpClient;
+exports.HttpStatusError = require_errors.HttpStatusError;
+exports.OriginMismatchError = require_errors.OriginMismatchError;
+exports.ProxyDialer = require_proxy.ProxyDialer;
+exports.RequestAbortedError = require_errors.RequestAbortedError;
+exports.RequestWriteError = require_errors.RequestWriteError;
+exports.ResponseBodyError = require_errors.ResponseBodyError;
+exports.ResponseDecodeError = require_errors.ResponseDecodeError;
+exports.ResponseHeaderError = require_errors.ResponseHeaderError;
+exports.TcpDialer = require_tcp.TcpDialer;
+exports.TlsDialer = require_tcp.TlsDialer;
+exports.UnsupportedAlpnProtocolError = require_errors.UnsupportedAlpnProtocolError;
+exports.UnsupportedMethodError = require_errors.UnsupportedMethodError;
+exports.UnsupportedProtocolError = require_errors.UnsupportedProtocolError;
+exports.connectTcp = require_net.connectTcp;
+exports.connectTls = require_net.connectTls;
+exports.createDecoders = require_encoding.createDecoders;
+exports.createEncoders = require_encoding.createEncoders;
+exports.createFetch = require_fetch.createFetch;
+exports.decodeStream = require_encoding.decodeStream;
+exports.encodeStream = require_encoding.encodeStream;
+exports.extractBody = require_body.extractBody;
+exports.fetch = require_fetch;
+exports.getFormDataLength = require_body.getFormDataLength;
+exports.normalizeHeaders = require_fetch.normalizeHeaders;
+exports.resolveHostPort = require_tcp.resolveHostPort;
+exports.upgradeTls = require_net.upgradeTls;

package/index.d.cts

@@ -0,0 +1 @@
+export * from "./src/index.js"

package/index.d.ts

@@ -0,0 +1 @@
+export * from "./src/index.js"

package/index.js

@@ -0,0 +1,9 @@
+import { connectTcp, connectTls, upgradeTls } from "./_internal/net.js";
+import { Body, extractBody, getFormDataLength } from "./body.js";
+import { ProxyDialer } from "./dialers/proxy.js";
+import { AutoDialer, TcpDialer, TlsDialer, resolveHostPort } from "./dialers/tcp.js";
+import { createDecoders, createEncoders, decodeStream, encodeStream } from "./encoding.js";
+import { AgentBusyError, AgentClosedError, ConnectTimeoutError, ConnectionError, ErrorType, FetchError, FetchErrorCode, HttpStatusError, OriginMismatchError, RequestAbortedError, RequestWriteError, ResponseBodyError, ResponseDecodeError, ResponseHeaderError, UnsupportedAlpnProtocolError, UnsupportedMethodError, UnsupportedProtocolError } from "./errors.js";
+import { HttpClient } from "./http-client.js";
+import fetch, { createFetch, normalizeHeaders } from "./fetch.js";
+export { AgentBusyError, AgentClosedError, AutoDialer, Body, ConnectTimeoutError, ConnectionError, ErrorType, FetchError, FetchErrorCode, HttpClient, HttpStatusError, OriginMismatchError, ProxyDialer, RequestAbortedError, RequestWriteError, ResponseBodyError, ResponseDecodeError, ResponseHeaderError, TcpDialer, TlsDialer, UnsupportedAlpnProtocolError, UnsupportedMethodError, UnsupportedProtocolError, connectTcp, connectTls, createDecoders, createEncoders, createFetch, decodeStream, encodeStream, extractBody, fetch, getFormDataLength, normalizeHeaders, resolveHostPort, upgradeTls };

package/io/_utils.cjs

@@ -0,0 +1,56 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+let bytes = require("bytes");
+bytes = require_runtime.__toESM(bytes);
+//#region src/io/_utils.ts
+function parseMaxBytes(value) {
+	if (value === void 0) return null;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value) || value < 0) throw new Error(`invalid max size: ${String(value)}`);
+		return Math.floor(value);
+	}
+	const parsed = bytes.default.parse(value);
+	if (parsed == null || !Number.isFinite(parsed) || parsed < 0) throw new Error(`invalid max size: ${String(value)}`);
+	return parsed;
+}
+function splitTokens(v) {
+	if (!v) return [];
+	return v.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
+}
+function parseTransferEncoding(headers) {
+	const raw = headers.get("transfer-encoding");
+	const tks = splitTokens(raw);
+	if (tks.length === 0) return {
+		has: false,
+		chunked: false,
+		codings: []
+	};
+	const chunkedIdx = tks.lastIndexOf("chunked");
+	const hasChunked = chunkedIdx !== -1;
+	if (hasChunked && chunkedIdx !== tks.length - 1) throw new Error(`Invalid transfer-encoding order: ${raw ?? ""}`);
+	if (hasChunked && tks.indexOf("chunked") !== chunkedIdx) throw new Error(`Invalid transfer-encoding (duplicate chunked): ${raw ?? ""}`);
+	return {
+		has: true,
+		chunked: hasChunked,
+		codings: tks.filter((t) => t !== "chunked" && t !== "identity")
+	};
+}
+function parseContentLength(headers) {
+	const raw = headers.get("content-length");
+	if (!raw) return null;
+	const parts = raw.split(",").map((s) => s.trim()).filter(Boolean);
+	if (parts.length === 0) return null;
+	let value = null;
+	for (const p of parts) {
+		if (!/^\d+$/.test(p)) throw new Error(`Invalid content-length: ${raw}`);
+		const n = Number.parseInt(p, 10);
+		if (!Number.isFinite(n) || n < 0) throw new Error(`Invalid content-length: ${raw}`);
+		if (value === null) value = n;
+		else if (value !== n) throw new Error(`Conflicting content-length values: ${raw}`);
+	}
+	return value;
+}
+//#endregion
+exports.parseContentLength = parseContentLength;
+exports.parseMaxBytes = parseMaxBytes;
+exports.parseTransferEncoding = parseTransferEncoding;
+exports.splitTokens = splitTokens;

package/io/_utils.js

@@ -0,0 +1,51 @@
+import bytes from "bytes";
+//#region src/io/_utils.ts
+function parseMaxBytes(value) {
+	if (value === void 0) return null;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value) || value < 0) throw new Error(`invalid max size: ${String(value)}`);
+		return Math.floor(value);
+	}
+	const parsed = bytes.parse(value);
+	if (parsed == null || !Number.isFinite(parsed) || parsed < 0) throw new Error(`invalid max size: ${String(value)}`);
+	return parsed;
+}
+function splitTokens(v) {
+	if (!v) return [];
+	return v.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
+}
+function parseTransferEncoding(headers) {
+	const raw = headers.get("transfer-encoding");
+	const tks = splitTokens(raw);
+	if (tks.length === 0) return {
+		has: false,
+		chunked: false,
+		codings: []
+	};
+	const chunkedIdx = tks.lastIndexOf("chunked");
+	const hasChunked = chunkedIdx !== -1;
+	if (hasChunked && chunkedIdx !== tks.length - 1) throw new Error(`Invalid transfer-encoding order: ${raw ?? ""}`);
+	if (hasChunked && tks.indexOf("chunked") !== chunkedIdx) throw new Error(`Invalid transfer-encoding (duplicate chunked): ${raw ?? ""}`);
+	return {
+		has: true,
+		chunked: hasChunked,
+		codings: tks.filter((t) => t !== "chunked" && t !== "identity")
+	};
+}
+function parseContentLength(headers) {
+	const raw = headers.get("content-length");
+	if (!raw) return null;
+	const parts = raw.split(",").map((s) => s.trim()).filter(Boolean);
+	if (parts.length === 0) return null;
+	let value = null;
+	for (const p of parts) {
+		if (!/^\d+$/.test(p)) throw new Error(`Invalid content-length: ${raw}`);
+		const n = Number.parseInt(p, 10);
+		if (!Number.isFinite(n) || n < 0) throw new Error(`Invalid content-length: ${raw}`);
+		if (value === null) value = n;
+		else if (value !== n) throw new Error(`Conflicting content-length values: ${raw}`);
+	}
+	return value;
+}
+//#endregion
+export { parseContentLength, parseMaxBytes, parseTransferEncoding, splitTokens };

package/io/buf-writer.cjs

@@ -0,0 +1,149 @@
+require("../_virtual/_rolldown/runtime.cjs");
+let _fuman_utils = require("@fuman/utils");
+//#region src/io/buf-writer.ts
+var DEFAULT_BUF_SIZE = 4096;
+var MIN_BUF_SIZE = 16;
+var BufWriter = class {
+	#buffer;
+	#writable;
+	#writePos = 0;
+	#error = null;
+	#pending = [];
+	#pendingBytes = 0;
+	#lastWrite = null;
+	constructor(writable, size = DEFAULT_BUF_SIZE) {
+		if (size < MIN_BUF_SIZE) size = MIN_BUF_SIZE;
+		this.#buffer = _fuman_utils.u8.alloc(size);
+		this.#writable = writable;
+	}
+	get bufferSize() {
+		return this.#buffer.byteLength;
+	}
+	get buffered() {
+		return this.#pendingBytes + this.#writePos;
+	}
+	get available() {
+		return this.#buffer.byteLength - this.#writePos;
+	}
+	reset(writable) {
+		this.#error = null;
+		this.#writePos = 0;
+		this.#pending.length = 0;
+		this.#pendingBytes = 0;
+		this.#lastWrite = null;
+		this.#writable = writable;
+	}
+	writeSync(bytes) {
+		if (this.#error) throw this.#error;
+		if (bytes < 0) throw new RangeError("bytes must be >= 0");
+		if (this.#lastWrite) throw new Error("disposeWriteSync must be called before the next writeSync");
+		if (bytes === 0) {
+			const empty = this.#buffer.subarray(this.#writePos, this.#writePos);
+			this.#lastWrite = {
+				buf: empty,
+				size: 0,
+				internal: true
+			};
+			return empty;
+		}
+		if (bytes > this.available && this.#writePos > 0) {
+			const copy = _fuman_utils.u8.allocWith(this.#buffer.subarray(0, this.#writePos));
+			this.#pending.push(copy);
+			this.#pendingBytes += copy.length;
+			this.#writePos = 0;
+		}
+		if (bytes <= this.#buffer.byteLength) {
+			if (bytes > this.available) {
+				const copy = _fuman_utils.u8.allocWith(this.#buffer.subarray(0, this.#writePos));
+				this.#pending.push(copy);
+				this.#pendingBytes += copy.length;
+				this.#writePos = 0;
+			}
+			const start = this.#writePos;
+			const end = start + bytes;
+			const slice = this.#buffer.subarray(start, end);
+			this.#writePos = end;
+			this.#lastWrite = {
+				buf: slice,
+				size: bytes,
+				internal: true
+			};
+			return slice;
+		}
+		const chunk = _fuman_utils.u8.alloc(bytes);
+		this.#lastWrite = {
+			buf: chunk,
+			size: bytes,
+			internal: false
+		};
+		return chunk;
+	}
+	disposeWriteSync(written) {
+		const lw = this.#lastWrite;
+		if (!lw) return;
+		const w = written ?? lw.size;
+		if (w < 0 || w > lw.size) throw new RangeError(`written out of bounds: ${w} (0..${lw.size})`);
+		if (lw.internal) this.#writePos -= lw.size - w;
+		else if (w > 0) {
+			const chunk = w === lw.size ? lw.buf : lw.buf.subarray(0, w);
+			this.#pending.push(chunk);
+			this.#pendingBytes += chunk.length;
+		}
+		this.#lastWrite = null;
+	}
+	async #flushPending() {
+		if (this.#error) throw this.#error;
+		if (this.#lastWrite) throw new Error("disposeWriteSync must be called before flush/write");
+		while (this.#pending.length > 0) {
+			const chunk = this.#pending[0];
+			try {
+				await this.#writable.write(chunk);
+			} catch (e) {
+				this.#error = e;
+				throw e;
+			}
+			this.#pending.shift();
+			this.#pendingBytes -= chunk.length;
+		}
+	}
+	async flush() {
+		await this.#flushPending();
+		if (this.#error) throw this.#error;
+		if (this.#writePos === 0) return;
+		try {
+			await this.#writable.write(this.#buffer.subarray(0, this.#writePos));
+		} catch (e) {
+			this.#error = e;
+			throw e;
+		}
+		this.#writePos = 0;
+	}
+	async write(bytes) {
+		if (this.#error) throw this.#error;
+		if (!bytes.length) return;
+		await this.#flushPending();
+		if (this.#writePos === 0 && bytes.length >= this.#buffer.byteLength) {
+			try {
+				await this.#writable.write(bytes);
+			} catch (e) {
+				this.#error = e;
+				throw e;
+			}
+			return;
+		}
+		let off = 0;
+		while (off < bytes.length) {
+			if (this.available === 0) {
+				await this.flush();
+				continue;
+			}
+			const toCopy = Math.min(this.available, bytes.length - off);
+			this.#buffer.set(bytes.subarray(off, off + toCopy), this.#writePos);
+			this.#writePos += toCopy;
+			off += toCopy;
+			if (this.#writePos === this.#buffer.byteLength) await this.flush();
+		}
+	}
+};
+//#endregion
+exports.BufWriter = BufWriter;