@npy/fetch 0.1.0 → 0.1.1

package/io/readers.cjs

@@ -0,0 +1,377 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_consts = require("../_internal/consts.cjs");
+const require__utils = require("./_utils.cjs");
+let _fuman_io = require("@fuman/io");
+let _fuman_net = require("@fuman/net");
+//#region src/io/readers.ts
+var invalidHeaderCharRegex = /[^\t\x20-\x7e\x80-\xff]/g;
+function sanitizeHeaderValue(v) {
+	return v.replace(invalidHeaderCharRegex, (m) => encodeURI(m));
+}
+/**
+* CRLF-delimited reader that preserves over-reads in an internal buffer.
+*
+* Key property: once you finish reading headers, any bytes already read beyond
+* the header terminator stay buffered and will be returned by read().
+*/
+var LineReader = class {
+	#src;
+	#buf;
+	#codec = new _fuman_io.DelimiterCodec(require_consts.CRLF_BYTES, { strategy: "discard" });
+	#eof = false;
+	#highWaterMark;
+	#maxBufferedBytes;
+	#maxLineSize;
+	#closed = false;
+	close;
+	/**
+	* LineReader configuration.
+	*
+	* @namespace LineReader
+	*/
+	static Options;
+	constructor(src, opts = {}) {
+		this.#src = src;
+		this.#buf = _fuman_io.Bytes.alloc(opts.bufferSize);
+		this.#highWaterMark = opts.highWaterMark ?? 16 * 1024;
+		this.#maxBufferedBytes = opts.maxBufferedBytes ?? 256 * 1024;
+		this.#maxLineSize = opts.maxLineSize ?? 64 * 1024;
+		this.close = this.#close.bind(this);
+	}
+	async read(into) {
+		if (this.#closed) return 0;
+		if (this.#buf.available > 0) {
+			const n = Math.min(into.length, this.#buf.available);
+			into.set(this.#buf.readSync(n));
+			this.#buf.reclaim();
+			return n;
+		}
+		if (this.#eof) return 0;
+		try {
+			return await this.#src.read(into);
+		} catch (e) {
+			if (e instanceof _fuman_net.ConnectionClosedError) {
+				this.#eof = true;
+				return 0;
+			}
+			throw e;
+		}
+	}
+	async readLine() {
+		if (this.#closed) return null;
+		for (;;) {
+			const frame = this.#codec.decode(this.#buf, this.#eof);
+			if (frame !== null) {
+				this.#buf.reclaim();
+				return _fuman_io.read.rawString(frame, frame.length);
+			}
+			if (this.#eof) return null;
+			if (this.#buf.available > this.#maxLineSize) throw new Error(`line too large (> ${this.#maxLineSize} bytes)`);
+			if (this.#buf.available > this.#maxBufferedBytes) throw new Error(`buffer too large while searching for delimiter (> ${this.#maxBufferedBytes} bytes)`);
+			await this.#pull();
+		}
+	}
+	async readHeaders(opts = {}) {
+		const maxHeaderSize = opts.maxHeaderSize ?? 64 * 1024;
+		const acc = /* @__PURE__ */ new Map();
+		const validator = new Headers();
+		let lastKey = null;
+		let firstLine = true;
+		let consumed = 0;
+		for (;;) {
+			const line = await this.readLine();
+			if (line === null) throw new Error("Unexpected EOF while reading HTTP headers");
+			consumed += line.length + 2;
+			if (consumed > maxHeaderSize) throw new Error(`HTTP headers too large (> ${maxHeaderSize} bytes)`);
+			if (line === "") break;
+			if (firstLine && (line[0] === " " || line[0] === "	")) throw new Error(`malformed HTTP header initial line: ${line}`);
+			firstLine = false;
+			if (line[0] === " " || line[0] === "	") {
+				if (!lastKey) throw new Error(`malformed HTTP header continuation line: ${line}`);
+				const arr = acc.get(lastKey);
+				if (!arr || arr.length === 0) throw new Error(`malformed HTTP header continuation line: ${line}`);
+				const piece = sanitizeHeaderValue(line.trim());
+				arr[arr.length - 1] = `${arr[arr.length - 1]} ${piece}`.trim();
+				continue;
+			}
+			const idx = line.indexOf(":");
+			if (idx === -1) throw new Error(`malformed HTTP header line: ${line}`);
+			const rawName = line.slice(0, idx).trim();
+			if (rawName === "") {
+				lastKey = null;
+				continue;
+			}
+			const name = rawName.toLowerCase();
+			const value = sanitizeHeaderValue(line.slice(idx + 1).trim());
+			try {
+				validator.append(name, value);
+			} catch {
+				lastKey = null;
+				continue;
+			}
+			const arr = acc.get(name);
+			if (arr) arr.push(value);
+			else acc.set(name, [value]);
+			lastKey = name;
+		}
+		const headers = new Headers();
+		for (const [k, values] of acc) for (const v of values) try {
+			headers.append(k, v);
+		} catch {}
+		return headers;
+	}
+	async #pull() {
+		const into = this.#buf.writeSync(this.#highWaterMark);
+		try {
+			const n = await this.#src.read(into);
+			this.#buf.disposeWriteSync(n);
+			if (n === 0) this.#eof = true;
+		} catch (e) {
+			this.#buf.disposeWriteSync(0);
+			if (e instanceof _fuman_net.ConnectionClosedError) {
+				this.#eof = true;
+				return;
+			}
+			throw e;
+		} finally {
+			this.#buf.reclaim();
+		}
+	}
+	async #close() {
+		if (this.#closed) return;
+		this.#closed = true;
+		try {
+			await this.#src.close();
+		} finally {
+			this.#closed = true;
+		}
+	}
+};
+/**
+* Body reader that streams bytes with either a fixed Content-Length or until EOF.
+*/
+var BodyReader = class {
+	#src;
+	#remaining;
+	#maxResponseSize;
+	#readSoFar = 0;
+	#closed = false;
+	close;
+	/**
+	* BodyReader configuration.
+	*
+	* @namespace BodyReader
+	*/
+	static Options;
+	constructor(src, contentLength, opts = {}) {
+		this.#src = src;
+		this.#remaining = contentLength >= 0 ? contentLength : null;
+		this.#maxResponseSize = require__utils.parseMaxBytes(opts.maxBodySize);
+		if (this.#maxResponseSize != null && this.#remaining != null && this.#remaining > this.#maxResponseSize) throw new Error(`body too large: content-length=${this.#remaining} > maxResponseSize=${this.#maxResponseSize}`);
+		this.close = this.#close.bind(this);
+	}
+	async read(into) {
+		if (this.#closed) return 0;
+		if (this.#remaining === 0) return 0;
+		let max = into.length;
+		if (this.#remaining != null) max = Math.min(max, this.#remaining);
+		if (this.#maxResponseSize != null) {
+			const remainingLimit = this.#maxResponseSize - this.#readSoFar;
+			if (remainingLimit <= 0) throw new Error(`body too large (> ${this.#maxResponseSize} bytes)`);
+			max = Math.min(max, remainingLimit);
+		}
+		if (max === 0) return 0;
+		const view = max === into.length ? into : into.subarray(0, max);
+		let n = 0;
+		try {
+			n = await this.#src.read(view);
+		} catch (e) {
+			if (e instanceof _fuman_net.ConnectionClosedError) n = 0;
+			else throw e;
+		}
+		if (n === 0) {
+			if (this.#remaining != null) throw new Error("Unexpected EOF while reading fixed-length body");
+			return 0;
+		}
+		this.#readSoFar += n;
+		if (this.#remaining != null) this.#remaining -= n;
+		return n;
+	}
+	async #close() {
+		if (this.#closed) return;
+		this.#closed = true;
+		try {
+			await this.#src.close();
+		} finally {
+			this.#closed = true;
+		}
+	}
+};
+/**
+* RFC 7230 chunked transfer-coding decoder.
+*/
+var ChunkedBodyReader = class {
+	#src;
+	#buf;
+	#codec = new _fuman_io.DelimiterCodec(require_consts.CRLF_BYTES, { strategy: "discard" });
+	#highWaterMark;
+	#maxLineSize;
+	#maxChunkSize;
+	#maxResponseSize;
+	#readSoFar = 0;
+	#eof = false;
+	#closed = false;
+	#state = { kind: "size" };
+	close;
+	/**
+	* ChunkedBodyReader configuration.
+	*
+	* @namespace ChunkedBodyReader
+	*/
+	static Options;
+	constructor(src, opts = {}) {
+		this.#src = src;
+		this.#buf = _fuman_io.Bytes.alloc(opts.bufferSize);
+		this.#highWaterMark = opts.highWaterMark ?? 16 * 1024;
+		this.#maxLineSize = opts.maxLineSize ?? 64 * 1024;
+		this.#maxChunkSize = opts.maxChunkSize ?? 16 * 1024 * 1024;
+		this.#maxResponseSize = require__utils.parseMaxBytes(opts.maxBodySize);
+		this.close = this.#close.bind(this);
+	}
+	async read(into) {
+		if (this.#closed) return 0;
+		for (;;) {
+			if (this.#state.kind === "done") return 0;
+			let view = into;
+			if (this.#maxResponseSize != null) {
+				const remainingLimit = this.#maxResponseSize - this.#readSoFar;
+				if (remainingLimit <= 0) throw new Error(`body too large (> ${this.#maxResponseSize} bytes)`);
+				if (view.length > remainingLimit) view = view.subarray(0, remainingLimit);
+			}
+			if (view.length === 0) return 0;
+			if (this.#state.kind === "data") {
+				if (this.#state.remaining === 0) {
+					this.#state = { kind: "crlf" };
+					continue;
+				}
+				if (this.#buf.available > 0) {
+					const n = Math.min(view.length, this.#state.remaining, this.#buf.available);
+					view.set(this.#buf.readSync(n));
+					this.#buf.reclaim();
+					this.#readSoFar += n;
+					this.#state = {
+						kind: "data",
+						remaining: this.#state.remaining - n
+					};
+					return n;
+				}
+				const max = Math.min(view.length, this.#state.remaining);
+				const slice = max === view.length ? view : view.subarray(0, max);
+				const n = await this.#readFromSrc(slice);
+				if (n === 0) throw new Error("Unexpected EOF while reading chunked body");
+				this.#readSoFar += n;
+				this.#state = {
+					kind: "data",
+					remaining: this.#state.remaining - n
+				};
+				return n;
+			}
+			if (this.#state.kind === "size") {
+				const line = await this.#readLine();
+				if (line === null) throw new Error("Unexpected EOF while reading chunk size");
+				const semi = line.indexOf(";");
+				const token = (semi === -1 ? line : line.slice(0, semi)).trim();
+				if (token === "") throw new Error(`invalid chunk size line: ${line}`);
+				const size = Number.parseInt(token, 16);
+				if (!Number.isFinite(size) || Number.isNaN(size) || size < 0) throw new Error(`invalid chunk size: ${token}`);
+				if (size > this.#maxChunkSize) throw new Error(`chunk too large (> ${this.#maxChunkSize} bytes)`);
+				if (this.#maxResponseSize != null) {
+					if (size > this.#maxResponseSize - this.#readSoFar) throw new Error(`body too large (> ${this.#maxResponseSize} bytes)`);
+				}
+				this.#state = size === 0 ? { kind: "trailers" } : {
+					kind: "data",
+					remaining: size
+				};
+				continue;
+			}
+			if (this.#state.kind === "crlf") {
+				await this.#consumeCrlf();
+				this.#state = { kind: "size" };
+				continue;
+			}
+			if (this.#state.kind === "trailers") for (;;) {
+				const line = await this.#readLine();
+				if (line === null) throw new Error("Unexpected EOF while reading chunked trailers");
+				if (line === "") {
+					this.#state = { kind: "done" };
+					return 0;
+				}
+			}
+		}
+	}
+	async #readFromSrc(into) {
+		if (this.#eof) return 0;
+		try {
+			const n = await this.#src.read(into);
+			if (n === 0) this.#eof = true;
+			return n;
+		} catch (e) {
+			if (e instanceof _fuman_net.ConnectionClosedError) {
+				this.#eof = true;
+				return 0;
+			}
+			throw e;
+		}
+	}
+	async #pull() {
+		const into = this.#buf.writeSync(this.#highWaterMark);
+		try {
+			const n = await this.#readFromSrc(into);
+			this.#buf.disposeWriteSync(n);
+		} catch (e) {
+			this.#buf.disposeWriteSync(0);
+			if (e instanceof _fuman_net.ConnectionClosedError) {
+				this.#eof = true;
+				return;
+			}
+			throw e;
+		} finally {
+			this.#buf.reclaim();
+		}
+	}
+	async #readLine() {
+		for (;;) {
+			const frame = this.#codec.decode(this.#buf, this.#eof);
+			if (frame !== null) {
+				this.#buf.reclaim();
+				return _fuman_io.read.rawString(frame, frame.length);
+			}
+			if (this.#eof) return null;
+			if (this.#buf.available > this.#maxLineSize) throw new Error(`chunk line too large (> ${this.#maxLineSize} bytes)`);
+			await this.#pull();
+		}
+	}
+	async #consumeCrlf() {
+		while (this.#buf.available < 2) {
+			if (this.#eof) throw new Error("Unexpected EOF while reading chunk terminator");
+			await this.#pull();
+		}
+		const two = this.#buf.readSync(2);
+		this.#buf.reclaim();
+		if (two[0] !== require_consts.CRLF_BYTES[0] || two[1] !== require_consts.CRLF_BYTES[1]) throw new Error("Invalid chunked encoding: missing CRLF after chunk data");
+	}
+	async #close() {
+		if (this.#closed) return;
+		this.#closed = true;
+		try {
+			await this.#src.close();
+		} finally {
+			this.#closed = true;
+		}
+	}
+};
+//#endregion
+exports.BodyReader = BodyReader;
+exports.ChunkedBodyReader = ChunkedBodyReader;
+exports.LineReader = LineReader;
+exports.sanitizeHeaderValue = sanitizeHeaderValue;