@hina114514/chaite 1.9.3

package/dist/chunks/formdata-node/index.mjs-B2Ji6hC0.mjs

@@ -0,0 +1,92 @@
+import { n as __esm, s as __toESM } from "../../rolldown-runtime-DVriDoez.mjs";
+import { i as init_isFile, o as File, s as init_File } from "../@anthropic-ai/sdk/index.mjs-BBdoshoG.mjs";
+import { o as require_node_domexception } from "../fetch-blob/index.mjs-Pm1zUh3g.mjs";
+import { basename } from "path";
+import { createReadStream, promises } from "fs";
+
+//#region node_modules/.pnpm/formdata-node@4.4.1/node_modules/formdata-node/lib/esm/isPlainObject.js
+function isPlainObject(value) {
+	if (getType(value) !== "object") return false;
+	const pp = Object.getPrototypeOf(value);
+	if (pp === null || pp === void 0) return true;
+	return (pp.constructor && pp.constructor.toString()) === Object.toString();
+}
+var getType, isPlainObject_default;
+var init_isPlainObject = __esm({ "node_modules/.pnpm/formdata-node@4.4.1/node_modules/formdata-node/lib/esm/isPlainObject.js": (() => {
+	getType = (value) => Object.prototype.toString.call(value).slice(8, -1).toLowerCase();
+	isPlainObject_default = isPlainObject;
+}) });
+
+//#endregion
+//#region node_modules/.pnpm/formdata-node@4.4.1/node_modules/formdata-node/lib/esm/fileFromPath.js
+function createFileFromPath(path$1, { mtimeMs, size }, filenameOrOptions, options = {}) {
+	let filename;
+	if (isPlainObject_default(filenameOrOptions)) [options, filename] = [filenameOrOptions, void 0];
+	else filename = filenameOrOptions;
+	const file = new FileFromPath({
+		path: path$1,
+		size,
+		lastModified: mtimeMs
+	});
+	if (!filename) filename = file.name;
+	return new File([file], filename, {
+		...options,
+		lastModified: file.lastModified
+	});
+}
+async function fileFromPath(path$1, filenameOrOptions, options) {
+	return createFileFromPath(path$1, await promises.stat(path$1), filenameOrOptions, options);
+}
+var import_node_domexception, __classPrivateFieldSet, __classPrivateFieldGet, _FileFromPath_path, _FileFromPath_start, MESSAGE, FileFromPath;
+var init_fileFromPath = __esm({ "node_modules/.pnpm/formdata-node@4.4.1/node_modules/formdata-node/lib/esm/fileFromPath.js": (() => {
+	import_node_domexception = /* @__PURE__ */ __toESM(require_node_domexception(), 1);
+	init_File();
+	init_isPlainObject();
+	init_isFile();
+	__classPrivateFieldSet = void 0 && (void 0).__classPrivateFieldSet || function(receiver, state, value, kind, f) {
+		if (kind === "m") throw new TypeError("Private method is not writable");
+		if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+		if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+		return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+	};
+	__classPrivateFieldGet = void 0 && (void 0).__classPrivateFieldGet || function(receiver, state, kind, f) {
+		if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+		if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+		return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+	};
+	;
+	MESSAGE = "The requested file could not be read, typically due to permission problems that have occurred after a reference to a file was acquired.";
+	FileFromPath = class FileFromPath {
+		constructor(input) {
+			_FileFromPath_path.set(this, void 0);
+			_FileFromPath_start.set(this, void 0);
+			__classPrivateFieldSet(this, _FileFromPath_path, input.path, "f");
+			__classPrivateFieldSet(this, _FileFromPath_start, input.start || 0, "f");
+			this.name = basename(__classPrivateFieldGet(this, _FileFromPath_path, "f"));
+			this.size = input.size;
+			this.lastModified = input.lastModified;
+		}
+		slice(start, end) {
+			return new FileFromPath({
+				path: __classPrivateFieldGet(this, _FileFromPath_path, "f"),
+				lastModified: this.lastModified,
+				size: end - start,
+				start
+			});
+		}
+		async *stream() {
+			const { mtimeMs } = await promises.stat(__classPrivateFieldGet(this, _FileFromPath_path, "f"));
+			if (mtimeMs > this.lastModified) throw new import_node_domexception.default(MESSAGE, "NotReadableError");
+			if (this.size) yield* createReadStream(__classPrivateFieldGet(this, _FileFromPath_path, "f"), {
+				start: __classPrivateFieldGet(this, _FileFromPath_start, "f"),
+				end: __classPrivateFieldGet(this, _FileFromPath_start, "f") + this.size - 1
+			});
+		}
+		get [(_FileFromPath_path = /* @__PURE__ */ new WeakMap(), _FileFromPath_start = /* @__PURE__ */ new WeakMap(), Symbol.toStringTag)]() {
+			return "File";
+		}
+	};
+}) });
+
+//#endregion
+export { init_fileFromPath as n, fileFromPath as t };

package/dist/chunks/formdata-polyfill/index.mjs-BTkafjCT.mjs

@@ -0,0 +1,87 @@
+import { n as __esm } from "../../rolldown-runtime-DVriDoez.mjs";
+import { a as init_fetch_blob, i as fetch_blob_default, n as file_default, r as init_file } from "../fetch-blob/index.mjs-Pm1zUh3g.mjs";
+
+//#region node_modules/.pnpm/formdata-polyfill@4.0.10/node_modules/formdata-polyfill/esm.min.js
+/** @param {FormData} F */
+function formDataToBlob(F, B = fetch_blob_default) {
+	var b = `${r()}${r()}`.replace(/\./g, "").slice(-28).padStart(32, "-"), c = [], p = `--${b}\r\nContent-Disposition: form-data; name="`;
+	F.forEach((v, n) => typeof v == "string" ? c.push(p + e(n) + `"\r\n\r\n${v.replace(/\r(?!\n)|(?<!\r)\n/g, "\r\n")}\r\n`) : c.push(p + e(n) + `"; filename="${e(v.name, 1)}"\r\nContent-Type: ${v.type || "application/octet-stream"}\r\n\r\n`, v, "\r\n"));
+	c.push(`--${b}--`);
+	return new B(c, { type: "multipart/form-data; boundary=" + b });
+}
+var t, i, h, r, m, f, e, x, FormData;
+var init_esm_min = __esm({ "node_modules/.pnpm/formdata-polyfill@4.0.10/node_modules/formdata-polyfill/esm.min.js": (() => {
+	init_fetch_blob();
+	init_file();
+	({toStringTag: t, iterator: i, hasInstance: h} = Symbol), r = Math.random, m = "append,set,get,getAll,delete,keys,values,entries,forEach,constructor".split(","), f = (a, b, c) => (a += "", /^(Blob|File)$/.test(b && b[t]) ? [(c = c !== void 0 ? c + "" : b[t] == "File" ? b.name : "blob", a), b.name !== c || b[t] == "blob" ? new file_default([b], c, b) : b] : [a, b + ""]), e = (c, f$1) => (f$1 ? c : c.replace(/\r?\n|\r/g, "\r\n")).replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22"), x = (n, a, e$1) => {
+		if (a.length < e$1) throw new TypeError(`Failed to execute '${n}' on 'FormData': ${e$1} arguments required, but only ${a.length} present.`);
+	};
+	FormData = class FormData$1 {
+		#d = [];
+		constructor(...a) {
+			if (a.length) throw new TypeError(`Failed to construct 'FormData': parameter 1 is not of type 'HTMLFormElement'.`);
+		}
+		get [t]() {
+			return "FormData";
+		}
+		[i]() {
+			return this.entries();
+		}
+		static [h](o) {
+			return o && typeof o === "object" && o[t] === "FormData" && !m.some((m$1) => typeof o[m$1] != "function");
+		}
+		append(...a) {
+			x("append", arguments, 2);
+			this.#d.push(f(...a));
+		}
+		delete(a) {
+			x("delete", arguments, 1);
+			a += "";
+			this.#d = this.#d.filter(([b]) => b !== a);
+		}
+		get(a) {
+			x("get", arguments, 1);
+			a += "";
+			for (var b = this.#d, l = b.length, c = 0; c < l; c++) if (b[c][0] === a) return b[c][1];
+			return null;
+		}
+		getAll(a, b) {
+			x("getAll", arguments, 1);
+			b = [];
+			a += "";
+			this.#d.forEach((c) => c[0] === a && b.push(c[1]));
+			return b;
+		}
+		has(a) {
+			x("has", arguments, 1);
+			a += "";
+			return this.#d.some((b) => b[0] === a);
+		}
+		forEach(a, b) {
+			x("forEach", arguments, 1);
+			for (var [c, d] of this) a.call(b, d, c, this);
+		}
+		set(...a) {
+			x("set", arguments, 2);
+			var b = [], c = !0;
+			a = f(...a);
+			this.#d.forEach((d) => {
+				d[0] === a[0] ? c && (c = !b.push(a)) : b.push(d);
+			});
+			c && b.push(a);
+			this.#d = b;
+		}
+		*entries() {
+			yield* this.#d;
+		}
+		*keys() {
+			for (var [a] of this) yield a;
+		}
+		*values() {
+			for (var [, a] of this) yield a;
+		}
+	};
+}) });
+
+//#endregion
+export { formDataToBlob as n, init_esm_min as r, FormData as t };

package/dist/chunks/https-proxy-agent/index.mjs-DTZuZn-J.mjs

@@ -0,0 +1,239 @@
+import { i as __require, t as __commonJS } from "../../rolldown-runtime-DVriDoez.mjs";
+import { t as require_src } from "../debug/index.mjs-BgKBSuIO.mjs";
+import { t as require_dist$1 } from "../agent-base/index.mjs-BZ87hIEB.mjs";
+
+//#region node_modules/.pnpm/https-proxy-agent@7.0.6/node_modules/https-proxy-agent/dist/parse-proxy-response.js
+var require_parse_proxy_response = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/https-proxy-agent@7.0.6/node_modules/https-proxy-agent/dist/parse-proxy-response.js": ((exports) => {
+	var __importDefault$1 = exports && exports.__importDefault || function(mod) {
+		return mod && mod.__esModule ? mod : { "default": mod };
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.parseProxyResponse = void 0;
+	const debug$1 = (0, __importDefault$1(require_src()).default)("https-proxy-agent:parse-proxy-response");
+	function parseProxyResponse(socket) {
+		return new Promise((resolve, reject) => {
+			let buffersLength = 0;
+			const buffers = [];
+			function read() {
+				const b = socket.read();
+				if (b) ondata(b);
+				else socket.once("readable", read);
+			}
+			function cleanup() {
+				socket.removeListener("end", onend);
+				socket.removeListener("error", onerror);
+				socket.removeListener("readable", read);
+			}
+			function onend() {
+				cleanup();
+				debug$1("onend");
+				reject(/* @__PURE__ */ new Error("Proxy connection ended before receiving CONNECT response"));
+			}
+			function onerror(err) {
+				cleanup();
+				debug$1("onerror %o", err);
+				reject(err);
+			}
+			function ondata(b) {
+				buffers.push(b);
+				buffersLength += b.length;
+				const buffered = Buffer.concat(buffers, buffersLength);
+				const endOfHeaders = buffered.indexOf("\r\n\r\n");
+				if (endOfHeaders === -1) {
+					debug$1("have not received end of HTTP headers yet...");
+					read();
+					return;
+				}
+				const headerParts = buffered.slice(0, endOfHeaders).toString("ascii").split("\r\n");
+				const firstLine = headerParts.shift();
+				if (!firstLine) {
+					socket.destroy();
+					return reject(/* @__PURE__ */ new Error("No header received from proxy CONNECT response"));
+				}
+				const firstLineParts = firstLine.split(" ");
+				const statusCode = +firstLineParts[1];
+				const statusText = firstLineParts.slice(2).join(" ");
+				const headers = {};
+				for (const header of headerParts) {
+					if (!header) continue;
+					const firstColon = header.indexOf(":");
+					if (firstColon === -1) {
+						socket.destroy();
+						return reject(/* @__PURE__ */ new Error(`Invalid header from proxy CONNECT response: "${header}"`));
+					}
+					const key = header.slice(0, firstColon).toLowerCase();
+					const value = header.slice(firstColon + 1).trimStart();
+					const current = headers[key];
+					if (typeof current === "string") headers[key] = [current, value];
+					else if (Array.isArray(current)) current.push(value);
+					else headers[key] = value;
+				}
+				debug$1("got proxy server response: %o %o", firstLine, headers);
+				cleanup();
+				resolve({
+					connect: {
+						statusCode,
+						statusText,
+						headers
+					},
+					buffered
+				});
+			}
+			socket.on("error", onerror);
+			socket.on("end", onend);
+			read();
+		});
+	}
+	exports.parseProxyResponse = parseProxyResponse;
+}) });
+
+//#endregion
+//#region node_modules/.pnpm/https-proxy-agent@7.0.6/node_modules/https-proxy-agent/dist/index.js
+var require_dist = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/https-proxy-agent@7.0.6/node_modules/https-proxy-agent/dist/index.js": ((exports) => {
+	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		var desc = Object.getOwnPropertyDescriptor(m, k);
+		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
+			enumerable: true,
+			get: function() {
+				return m[k];
+			}
+		};
+		Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		o[k2] = m[k];
+	}));
+	var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+		Object.defineProperty(o, "default", {
+			enumerable: true,
+			value: v
+		});
+	}) : function(o, v) {
+		o["default"] = v;
+	});
+	var __importStar = exports && exports.__importStar || function(mod) {
+		if (mod && mod.__esModule) return mod;
+		var result = {};
+		if (mod != null) {
+			for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+		}
+		__setModuleDefault(result, mod);
+		return result;
+	};
+	var __importDefault = exports && exports.__importDefault || function(mod) {
+		return mod && mod.__esModule ? mod : { "default": mod };
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.HttpsProxyAgent = void 0;
+	const net = __importStar(__require("net"));
+	const tls = __importStar(__require("tls"));
+	const assert_1 = __importDefault(__require("assert"));
+	const debug_1 = __importDefault(require_src());
+	const agent_base_1 = require_dist$1();
+	const url_1 = __require("url");
+	const parse_proxy_response_1 = require_parse_proxy_response();
+	const debug = (0, debug_1.default)("https-proxy-agent");
+	const setServernameFromNonIpHost = (options) => {
+		if (options.servername === void 0 && options.host && !net.isIP(options.host)) return {
+			...options,
+			servername: options.host
+		};
+		return options;
+	};
+	/**
+	* The `HttpsProxyAgent` implements an HTTP Agent subclass that connects to
+	* the specified "HTTP(s) proxy server" in order to proxy HTTPS requests.
+	*
+	* Outgoing HTTP requests are first tunneled through the proxy server using the
+	* `CONNECT` HTTP request method to establish a connection to the proxy server,
+	* and then the proxy server connects to the destination target and issues the
+	* HTTP request from the proxy server.
+	*
+	* `https:` requests have their socket connection upgraded to TLS once
+	* the connection to the proxy server has been established.
+	*/
+	var HttpsProxyAgent = class extends agent_base_1.Agent {
+		constructor(proxy, opts) {
+			super(opts);
+			this.options = { path: void 0 };
+			this.proxy = typeof proxy === "string" ? new url_1.URL(proxy) : proxy;
+			this.proxyHeaders = opts?.headers ?? {};
+			debug("Creating new HttpsProxyAgent instance: %o", this.proxy.href);
+			const host = (this.proxy.hostname || this.proxy.host).replace(/^\[|\]$/g, "");
+			const port = this.proxy.port ? parseInt(this.proxy.port, 10) : this.proxy.protocol === "https:" ? 443 : 80;
+			this.connectOpts = {
+				ALPNProtocols: ["http/1.1"],
+				...opts ? omit(opts, "headers") : null,
+				host,
+				port
+			};
+		}
+		/**
+		* Called when the node-core HTTP client library is creating a
+		* new HTTP request.
+		*/
+		async connect(req, opts) {
+			const { proxy } = this;
+			if (!opts.host) throw new TypeError("No \"host\" provided");
+			let socket;
+			if (proxy.protocol === "https:") {
+				debug("Creating `tls.Socket`: %o", this.connectOpts);
+				socket = tls.connect(setServernameFromNonIpHost(this.connectOpts));
+			} else {
+				debug("Creating `net.Socket`: %o", this.connectOpts);
+				socket = net.connect(this.connectOpts);
+			}
+			const headers = typeof this.proxyHeaders === "function" ? this.proxyHeaders() : { ...this.proxyHeaders };
+			const host = net.isIPv6(opts.host) ? `[${opts.host}]` : opts.host;
+			let payload = `CONNECT ${host}:${opts.port} HTTP/1.1\r\n`;
+			if (proxy.username || proxy.password) {
+				const auth = `${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`;
+				headers["Proxy-Authorization"] = `Basic ${Buffer.from(auth).toString("base64")}`;
+			}
+			headers.Host = `${host}:${opts.port}`;
+			if (!headers["Proxy-Connection"]) headers["Proxy-Connection"] = this.keepAlive ? "Keep-Alive" : "close";
+			for (const name of Object.keys(headers)) payload += `${name}: ${headers[name]}\r\n`;
+			const proxyResponsePromise = (0, parse_proxy_response_1.parseProxyResponse)(socket);
+			socket.write(`${payload}\r\n`);
+			const { connect, buffered } = await proxyResponsePromise;
+			req.emit("proxyConnect", connect);
+			this.emit("proxyConnect", connect, req);
+			if (connect.statusCode === 200) {
+				req.once("socket", resume);
+				if (opts.secureEndpoint) {
+					debug("Upgrading socket connection to TLS");
+					return tls.connect({
+						...omit(setServernameFromNonIpHost(opts), "host", "path", "port"),
+						socket
+					});
+				}
+				return socket;
+			}
+			socket.destroy();
+			const fakeSocket = new net.Socket({ writable: false });
+			fakeSocket.readable = true;
+			req.once("socket", (s) => {
+				debug("Replaying proxy buffer for failed request");
+				(0, assert_1.default)(s.listenerCount("data") > 0);
+				s.push(buffered);
+				s.push(null);
+			});
+			return fakeSocket;
+		}
+	};
+	HttpsProxyAgent.protocols = ["http", "https"];
+	exports.HttpsProxyAgent = HttpsProxyAgent;
+	function resume(socket) {
+		socket.resume();
+	}
+	function omit(obj, ...keys) {
+		const ret = {};
+		let key;
+		for (key in obj) if (!keys.includes(key)) ret[key] = obj[key];
+		return ret;
+	}
+}) });
+
+//#endregion
+export { require_dist as t };

package/dist/chunks/immediate/index.mjs-CkWjI_b-.mjs

@@ -0,0 +1,59 @@
+import { t as __commonJS } from "../../rolldown-runtime-DVriDoez.mjs";
+
+//#region node_modules/.pnpm/immediate@3.0.6/node_modules/immediate/lib/index.js
+var require_lib = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/immediate@3.0.6/node_modules/immediate/lib/index.js": ((exports, module) => {
+	var Mutation = global.MutationObserver || global.WebKitMutationObserver;
+	var scheduleDrain;
+	if (process.browser) if (Mutation) {
+		var called = 0;
+		var observer = new Mutation(nextTick);
+		var element = global.document.createTextNode("");
+		observer.observe(element, { characterData: true });
+		scheduleDrain = function() {
+			element.data = called = ++called % 2;
+		};
+	} else if (!global.setImmediate && typeof global.MessageChannel !== "undefined") {
+		var channel = new global.MessageChannel();
+		channel.port1.onmessage = nextTick;
+		scheduleDrain = function() {
+			channel.port2.postMessage(0);
+		};
+	} else if ("document" in global && "onreadystatechange" in global.document.createElement("script")) scheduleDrain = function() {
+		var scriptEl = global.document.createElement("script");
+		scriptEl.onreadystatechange = function() {
+			nextTick();
+			scriptEl.onreadystatechange = null;
+			scriptEl.parentNode.removeChild(scriptEl);
+			scriptEl = null;
+		};
+		global.document.documentElement.appendChild(scriptEl);
+	};
+	else scheduleDrain = function() {
+		setTimeout(nextTick, 0);
+	};
+	else scheduleDrain = function() {
+		process.nextTick(nextTick);
+	};
+	var draining;
+	var queue = [];
+	function nextTick() {
+		draining = true;
+		var i, oldQueue;
+		var len = queue.length;
+		while (len) {
+			oldQueue = queue;
+			queue = [];
+			i = -1;
+			while (++i < len) oldQueue[i]();
+			len = queue.length;
+		}
+		draining = false;
+	}
+	module.exports = immediate;
+	function immediate(task) {
+		if (queue.push(task) === 1 && !draining) scheduleDrain();
+	}
+}) });
+
+//#endregion
+export { require_lib as t };

package/dist/chunks/isarray/index.mjs-DaT02uUW.mjs

@@ -0,0 +1,12 @@
+import { t as __commonJS } from "../../rolldown-runtime-DVriDoez.mjs";
+
+//#region node_modules/.pnpm/isarray@1.0.0/node_modules/isarray/index.js
+var require_isarray = /* @__PURE__ */ __commonJS({ "node_modules/.pnpm/isarray@1.0.0/node_modules/isarray/index.js": ((exports, module) => {
+	var toString = {}.toString;
+	module.exports = Array.isArray || function(arr) {
+		return toString.call(arr) == "[object Array]";
+	};
+}) });
+
+//#endregion
+export { require_isarray as t };