@vibe-lark/larkpal 0.1.85 → 0.1.86

package/dist/config-Bim2pi8a-BQUdfiEi.mjs

@@ -0,0 +1,9 @@
+import "./paths-D92DjaZ--CTOESW2b.mjs";
+import "./bundled-dir-U738ay4K-DXK0q_TV.mjs";
+import "./io-CH2g3vsv-BOGlLlB8.mjs";
+import "./bundled-compat-BpaDaAAu-D7oazKjD.mjs";
+import "node:path";
+import "node:fs/promises";
+import "node:crypto";
+import "node:util";
+export {};

package/dist/delivery-context.shared-j5hC5qb1-CI83RXXZ.mjs

@@ -0,0 +1,72 @@
+import { c as normalizeOptionalString } from "./home-dir-C44RaPME-CBRS4HLP.mjs";
+import { r as normalizeOptionalAccountId } from "./account-id-BM1T6029-DYjVxojW.mjs";
+import { n as normalizeMessageChannel } from "./message-channel-core-DTA--Gjh-CY4Tkb7N.mjs";
+//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/delivery-context.shared-j5hC5qb1.js
+function normalizeAccountId(value) {
+	return normalizeOptionalAccountId(value);
+}
+function normalizeDeliveryContext(context) {
+	if (!context) return;
+	const channel = typeof context.channel === "string" ? normalizeMessageChannel(context.channel) ?? context.channel.trim() : void 0;
+	const to = normalizeOptionalString(context.to);
+	const accountId = normalizeAccountId(context.accountId);
+	const threadId = typeof context.threadId === "number" && Number.isFinite(context.threadId) ? Math.trunc(context.threadId) : typeof context.threadId === "string" ? normalizeOptionalString(context.threadId) : void 0;
+	const normalizedThreadId = typeof threadId === "string" ? threadId ? threadId : void 0 : threadId;
+	if (!channel && !to && !accountId && normalizedThreadId == null) return;
+	const normalized = {
+		channel: channel || void 0,
+		to: to || void 0,
+		accountId
+	};
+	if (normalizedThreadId != null) normalized.threadId = normalizedThreadId;
+	return normalized;
+}
+function normalizeSessionDeliveryFields(source) {
+	if (!source) return {
+		deliveryContext: void 0,
+		lastChannel: void 0,
+		lastTo: void 0,
+		lastAccountId: void 0,
+		lastThreadId: void 0
+	};
+	const merged = mergeDeliveryContext(normalizeDeliveryContext({
+		channel: source.lastChannel ?? source.channel,
+		to: source.lastTo,
+		accountId: source.lastAccountId,
+		threadId: source.lastThreadId
+	}), normalizeDeliveryContext(source.deliveryContext));
+	if (!merged) return {
+		deliveryContext: void 0,
+		lastChannel: void 0,
+		lastTo: void 0,
+		lastAccountId: void 0,
+		lastThreadId: void 0
+	};
+	return {
+		deliveryContext: merged,
+		lastChannel: merged.channel,
+		lastTo: merged.to,
+		lastAccountId: merged.accountId,
+		lastThreadId: merged.threadId
+	};
+}
+function mergeDeliveryContext(primary, fallback) {
+	const normalizedPrimary = normalizeDeliveryContext(primary);
+	const normalizedFallback = normalizeDeliveryContext(fallback);
+	if (!normalizedPrimary && !normalizedFallback) return;
+	const channelsConflict = normalizedPrimary?.channel && normalizedFallback?.channel && normalizedPrimary.channel !== normalizedFallback.channel;
+	return normalizeDeliveryContext({
+		channel: normalizedPrimary?.channel ?? normalizedFallback?.channel,
+		to: channelsConflict ? normalizedPrimary?.to : normalizedPrimary?.to ?? normalizedFallback?.to,
+		accountId: channelsConflict ? normalizedPrimary?.accountId : normalizedPrimary?.accountId ?? normalizedFallback?.accountId,
+		threadId: channelsConflict ? normalizedPrimary?.threadId : normalizedPrimary?.threadId ?? normalizedFallback?.threadId
+	});
+}
+function deliveryContextKey(context) {
+	const normalized = normalizeDeliveryContext(context);
+	if (!normalized?.channel || !normalized?.to) return;
+	const threadId = normalized.threadId != null && normalized.threadId !== "" ? String(normalized.threadId) : "";
+	return `${normalized.channel}|${normalized.to}|${normalized.accountId ?? ""}|${threadId}`;
+}
+//#endregion
+export { normalizeSessionDeliveryFields as i, mergeDeliveryContext as n, normalizeDeliveryContext as r, deliveryContextKey as t };

package/dist/diagnostic-ClMwNnUA-D6nUtLnb.mjs

@@ -0,0 +1,140 @@
+import "./paths-D92DjaZ--CTOESW2b.mjs";
+import "./io-CH2g3vsv-BOGlLlB8.mjs";
+import { St as createSubsystemLogger } from "./bundled-compat-BpaDaAAu-D7oazKjD.mjs";
+import "./config-Bim2pi8a-BQUdfiEi.mjs";
+import "node:fs";
+import "node:path";
+import "node:process";
+//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/diagnostic-events-DU0Yv8MX.js
+function getDiagnosticEventsState() {
+	const globalStore = globalThis;
+	if (!globalStore.__openclawDiagnosticEventsState) globalStore.__openclawDiagnosticEventsState = {
+		enabled: true,
+		seq: 0,
+		listeners: /* @__PURE__ */ new Set(),
+		dispatchDepth: 0
+	};
+	return globalStore.__openclawDiagnosticEventsState;
+}
+function areDiagnosticsEnabledForProcess() {
+	return getDiagnosticEventsState().enabled;
+}
+function emitDiagnosticEvent(event) {
+	const state = getDiagnosticEventsState();
+	if (!state.enabled) return;
+	if (state.dispatchDepth > 100) {
+		console.error(`[diagnostic-events] recursion guard tripped at depth=${state.dispatchDepth}, dropping type=${event.type}`);
+		return;
+	}
+	const enriched = {
+		...event,
+		seq: state.seq += 1,
+		ts: Date.now()
+	};
+	state.dispatchDepth += 1;
+	for (const listener of state.listeners) try {
+		listener(enriched);
+	} catch (err) {
+		const errorMessage = err instanceof Error ? err.stack ?? err.message : typeof err === "string" ? err : String(err);
+		console.error(`[diagnostic-events] listener error type=${enriched.type} seq=${enriched.seq}: ${errorMessage}`);
+	}
+	state.dispatchDepth -= 1;
+}
+const diagnosticLogger = createSubsystemLogger("diagnostic");
+function markDiagnosticActivity() {}
+//#endregion
+//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/diagnostic-session-state-CnRAerRs.js
+const diagnosticSessionStates = /* @__PURE__ */ new Map();
+const SESSION_STATE_TTL_MS = 1800 * 1e3;
+const SESSION_STATE_PRUNE_INTERVAL_MS = 60 * 1e3;
+const SESSION_STATE_MAX_ENTRIES = 2e3;
+let lastSessionPruneAt = 0;
+function pruneDiagnosticSessionStates(now = Date.now(), force = false) {
+	const shouldPruneForSize = diagnosticSessionStates.size > SESSION_STATE_MAX_ENTRIES;
+	if (!force && !shouldPruneForSize && now - lastSessionPruneAt < SESSION_STATE_PRUNE_INTERVAL_MS) return;
+	lastSessionPruneAt = now;
+	for (const [key, state] of diagnosticSessionStates.entries()) {
+		const ageMs = now - state.lastActivity;
+		if (state.state === "idle" && state.queueDepth <= 0 && ageMs > SESSION_STATE_TTL_MS) diagnosticSessionStates.delete(key);
+	}
+	if (diagnosticSessionStates.size <= SESSION_STATE_MAX_ENTRIES) return;
+	const excess = diagnosticSessionStates.size - SESSION_STATE_MAX_ENTRIES;
+	const ordered = Array.from(diagnosticSessionStates.entries()).toSorted((a, b) => a[1].lastActivity - b[1].lastActivity);
+	for (let i = 0; i < excess; i += 1) {
+		const key = ordered[i]?.[0];
+		if (!key) break;
+		diagnosticSessionStates.delete(key);
+	}
+}
+function resolveSessionKey({ sessionKey, sessionId }) {
+	return sessionKey ?? sessionId ?? "unknown";
+}
+function findStateBySessionId(sessionId) {
+	for (const state of diagnosticSessionStates.values()) if (state.sessionId === sessionId) return state;
+}
+function getDiagnosticSessionState(ref) {
+	pruneDiagnosticSessionStates();
+	const key = resolveSessionKey(ref);
+	const existing = diagnosticSessionStates.get(key) ?? (ref.sessionId && findStateBySessionId(ref.sessionId));
+	if (existing) {
+		if (ref.sessionId) existing.sessionId = ref.sessionId;
+		if (ref.sessionKey) existing.sessionKey = ref.sessionKey;
+		return existing;
+	}
+	const created = {
+		sessionId: ref.sessionId,
+		sessionKey: ref.sessionKey,
+		lastActivity: Date.now(),
+		state: "idle",
+		queueDepth: 0
+	};
+	diagnosticSessionStates.set(key, created);
+	pruneDiagnosticSessionStates(Date.now(), true);
+	return created;
+}
+//#endregion
+//#region node_modules/.pnpm/openclaw@2026.4.22_@napi-rs+canvas@0.1.99/node_modules/openclaw/dist/diagnostic-ClMwNnUA.js
+const MB = 1024 * 1024;
+1536 * MB;
+3072 * MB;
+1024 * MB;
+2048 * MB;
+512 * MB;
+1024 * MB;
+function logMessageQueued(params) {
+	if (!areDiagnosticsEnabledForProcess()) return;
+	const state = getDiagnosticSessionState(params);
+	state.queueDepth += 1;
+	state.lastActivity = Date.now();
+	if (diagnosticLogger.isEnabled("debug")) diagnosticLogger.debug(`message queued: sessionId=${state.sessionId ?? "unknown"} sessionKey=${state.sessionKey ?? "unknown"} source=${params.source} queueDepth=${state.queueDepth} sessionState=${state.state}`);
+	emitDiagnosticEvent({
+		type: "message.queued",
+		sessionId: state.sessionId,
+		sessionKey: state.sessionKey,
+		channel: params.channel,
+		source: params.source,
+		queueDepth: state.queueDepth
+	});
+	markDiagnosticActivity();
+}
+function logToolLoopAction(params) {
+	if (!areDiagnosticsEnabledForProcess()) return;
+	const payload = `tool loop: sessionId=${params.sessionId ?? "unknown"} sessionKey=${params.sessionKey ?? "unknown"} tool=${params.toolName} level=${params.level} action=${params.action} detector=${params.detector} count=${params.count}${params.pairedToolName ? ` pairedTool=${params.pairedToolName}` : ""} message="${params.message}"`;
+	if (params.level === "critical") diagnosticLogger.error(payload);
+	else diagnosticLogger.warn(payload);
+	emitDiagnosticEvent({
+		type: "tool.loop",
+		sessionId: params.sessionId,
+		sessionKey: params.sessionKey,
+		toolName: params.toolName,
+		level: params.level,
+		action: params.action,
+		detector: params.detector,
+		count: params.count,
+		message: params.message,
+		pairedToolName: params.pairedToolName
+	});
+	markDiagnosticActivity();
+}
+//#endregion
+export { diagnosticLogger as i, logToolLoopAction as n, getDiagnosticSessionState as r, logMessageQueued as t };

package/dist/dist-CEGw8-2W.mjs

@@ -0,0 +1,429 @@
+import { i as __require, t as __commonJSMin } from "./chunk-D6SyT4dJ.mjs";
+import { t as require_src } from "./src-BgCX0MLG.mjs";
+//#region node_modules/.pnpm/agent-base@7.1.4/node_modules/agent-base/dist/helpers.js
+var require_helpers = /* @__PURE__ */ __commonJSMin(((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;
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.req = exports.json = exports.toBuffer = void 0;
+	const http$1 = __importStar(__require("http"));
+	const https = __importStar(__require("https"));
+	async function toBuffer(stream) {
+		let length = 0;
+		const chunks = [];
+		for await (const chunk of stream) {
+			length += chunk.length;
+			chunks.push(chunk);
+		}
+		return Buffer.concat(chunks, length);
+	}
+	exports.toBuffer = toBuffer;
+	async function json(stream) {
+		const str = (await toBuffer(stream)).toString("utf8");
+		try {
+			return JSON.parse(str);
+		} catch (_err) {
+			const err = _err;
+			err.message += ` (input: ${str})`;
+			throw err;
+		}
+	}
+	exports.json = json;
+	function req(url, opts = {}) {
+		const req = ((typeof url === "string" ? url : url.href).startsWith("https:") ? https : http$1).request(url, opts);
+		const promise = new Promise((resolve, reject) => {
+			req.once("response", resolve).once("error", reject).end();
+		});
+		req.then = promise.then.bind(promise);
+		return req;
+	}
+	exports.req = req;
+}));
+//#endregion
+//#region node_modules/.pnpm/agent-base@7.1.4/node_modules/agent-base/dist/index.js
+var require_dist$1 = /* @__PURE__ */ __commonJSMin(((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 __exportStar = exports && exports.__exportStar || function(m, exports$1) {
+		for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$1, p)) __createBinding(exports$1, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.Agent = void 0;
+	const net$1 = __importStar(__require("net"));
+	const http = __importStar(__require("http"));
+	const https_1 = __require("https");
+	__exportStar(require_helpers(), exports);
+	const INTERNAL = Symbol("AgentBaseInternalState");
+	var Agent = class extends http.Agent {
+		constructor(opts) {
+			super(opts);
+			this[INTERNAL] = {};
+		}
+		/**
+		* Determine whether this is an `http` or `https` request.
+		*/
+		isSecureEndpoint(options) {
+			if (options) {
+				if (typeof options.secureEndpoint === "boolean") return options.secureEndpoint;
+				if (typeof options.protocol === "string") return options.protocol === "https:";
+			}
+			const { stack } = /* @__PURE__ */ new Error();
+			if (typeof stack !== "string") return false;
+			return stack.split("\n").some((l) => l.indexOf("(https.js:") !== -1 || l.indexOf("node:https:") !== -1);
+		}
+		incrementSockets(name) {
+			if (this.maxSockets === Infinity && this.maxTotalSockets === Infinity) return null;
+			if (!this.sockets[name]) this.sockets[name] = [];
+			const fakeSocket = new net$1.Socket({ writable: false });
+			this.sockets[name].push(fakeSocket);
+			this.totalSocketCount++;
+			return fakeSocket;
+		}
+		decrementSockets(name, socket) {
+			if (!this.sockets[name] || socket === null) return;
+			const sockets = this.sockets[name];
+			const index = sockets.indexOf(socket);
+			if (index !== -1) {
+				sockets.splice(index, 1);
+				this.totalSocketCount--;
+				if (sockets.length === 0) delete this.sockets[name];
+			}
+		}
+		getName(options) {
+			if (this.isSecureEndpoint(options)) return https_1.Agent.prototype.getName.call(this, options);
+			return super.getName(options);
+		}
+		createSocket(req, options, cb) {
+			const connectOpts = {
+				...options,
+				secureEndpoint: this.isSecureEndpoint(options)
+			};
+			const name = this.getName(connectOpts);
+			const fakeSocket = this.incrementSockets(name);
+			Promise.resolve().then(() => this.connect(req, connectOpts)).then((socket) => {
+				this.decrementSockets(name, fakeSocket);
+				if (socket instanceof http.Agent) try {
+					return socket.addRequest(req, connectOpts);
+				} catch (err) {
+					return cb(err);
+				}
+				this[INTERNAL].currentSocket = socket;
+				super.createSocket(req, options, cb);
+			}, (err) => {
+				this.decrementSockets(name, fakeSocket);
+				cb(err);
+			});
+		}
+		createConnection() {
+			const socket = this[INTERNAL].currentSocket;
+			this[INTERNAL].currentSocket = void 0;
+			if (!socket) throw new Error("No socket was returned in the `connect()` function");
+			return socket;
+		}
+		get defaultPort() {
+			return this[INTERNAL].defaultPort ?? (this.protocol === "https:" ? 443 : 80);
+		}
+		set defaultPort(v) {
+			if (this[INTERNAL]) this[INTERNAL].defaultPort = v;
+		}
+		get protocol() {
+			return this[INTERNAL].protocol ?? (this.isSecureEndpoint() ? "https:" : "http:");
+		}
+		set protocol(v) {
+			if (this[INTERNAL]) this[INTERNAL].protocol = v;
+		}
+	};
+	exports.Agent = Agent;
+}));
+//#endregion
+//#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__ */ __commonJSMin(((exports) => {
+	var __importDefault = exports && exports.__importDefault || function(mod) {
+		return mod && mod.__esModule ? mod : { "default": mod };
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.parseProxyResponse = void 0;
+	const debug = (0, __importDefault(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("onend");
+				reject(/* @__PURE__ */ new Error("Proxy connection ended before receiving CONNECT response"));
+			}
+			function onerror(err) {
+				cleanup();
+				debug("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("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("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__ */ __commonJSMin(((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 };