rsshub/dist-lib/app-B8RpBkYX.mjs

Make RSS Great Again!

import "./esm-shims-CzJ_djXG.mjs";
import { t as config } from "./config-C37vj7VH.mjs";
import { t as Xe } from "./dist-BInvbO1W.mjs";
import { t as logger_default } from "./logger-Czu8UMNd.mjs";
import { n as generateHeaders, r as generatedHeaders } from "./header-generator-BYLlSJoA.mjs";
import { t as proxy_default } from "./proxy-Db7uGcYb.mjs";
import v, { FormData, Headers, Request, Response } from "undici";
import http from "node:http";
import https from "node:https";
import { RateLimiterMemory, RateLimiterQueue } from "rate-limiter-flexible";

//#region lib/utils/request-rewriter/fetch.ts
const limiterQueue = new RateLimiterQueue(new RateLimiterMemory({
	points: 10,
	duration: 1,
	execEvenly: true
}), { maxQueueSize: 4800 });
const useCustomHeader = (headers) => {
	process.env.NODE_ENV === "dev" && Xe((req) => {
		for (const [key, value] of headers.entries()) req.requestHeaders[key] = value;
		return req;
	});
};
const wrappedFetch = async (input, init) => {
	const request = new Request(input, init);
	const options = {};
	logger_default.debug(`Outgoing request: ${request.method} ${request.url}`);
	const generatedHeaders$1 = generateHeaders(init?.headerGeneratorOptions);
	if (!request.headers.has("user-agent")) request.headers.set("user-agent", config.ua);
	for (const header of generatedHeaders) if (!request.headers.has(header) && generatedHeaders$1[header]) request.headers.set(header, generatedHeaders$1[header]);
	if (!request.headers.get("referer")) try {
		const urlHandler = new URL(request.url);
		request.headers.set("referer", urlHandler.origin);
	} catch {}
	let isRetry = false;
	if (request.headers.get("x-prefer-proxy")) {
		isRetry = true;
		request.headers.delete("x-prefer-proxy");
	}
	config.enableRemoteDebugging && useCustomHeader(request.headers);
	if (!init?.dispatcher && (proxy_default.proxyObj.strategy !== "on_retry" || isRetry)) {
		const proxyRegex = new RegExp(proxy_default.proxyObj.url_regex);
		let urlHandler;
		try {
			urlHandler = new URL(request.url);
		} catch {}
		if (proxyRegex.test(request.url) && request.url.startsWith("http") && !(urlHandler && urlHandler.host === proxy_default.proxyUrlHandler?.host)) {
			const currentProxy = proxy_default.getCurrentProxy();
			if (currentProxy) {
				const dispatcher = proxy_default.getDispatcherForProxy(currentProxy);
				if (dispatcher) {
					options.dispatcher = dispatcher;
					logger_default.debug(`Proxying request via ${currentProxy.uri}: ${request.url}`);
				}
			}
		}
	}
	await limiterQueue.removeTokens(1);
	const maxRetries = proxy_default.multiProxy?.allProxies.length || 1;
	const attemptRequest = async (attempt) => {
		try {
			return await v.fetch(request, options);
		} catch (error) {
			if (options.dispatcher && proxy_default.multiProxy && attempt < maxRetries - 1) {
				const currentProxy = proxy_default.getCurrentProxy();
				if (currentProxy) {
					logger_default.warn(`Request failed with proxy ${currentProxy.uri}, trying next proxy: ${error}`);
					proxy_default.markProxyFailed(currentProxy.uri);
					const nextProxy = proxy_default.getCurrentProxy();
					if (nextProxy && nextProxy.uri !== currentProxy.uri) {
						const nextDispatcher = proxy_default.getDispatcherForProxy(nextProxy);
						if (nextDispatcher) options.dispatcher = nextDispatcher;
						logger_default.debug(`Retrying request with proxy ${nextProxy.uri}: ${request.url}`);
						return attemptRequest(attempt + 1);
					} else {
						logger_default.warn("No more proxies available, trying without proxy");
						delete options.dispatcher;
						return attemptRequest(attempt + 1);
					}
				}
			}
			throw error;
		}
	};
	return attemptRequest(0);
};
var fetch_default = wrappedFetch;

//#endregion
//#region lib/utils/request-rewriter/get.ts
const getWrappedGet = (origin) => function(...args) {
	let url;
	let options = {};
	let callback;
	if (typeof args[0] === "string" || args[0] instanceof URL) {
		url = new URL(args[0]);
		if (typeof args[1] === "object") {
			options = args[1];
			callback = args[2];
		} else if (typeof args[1] === "function") {
			options = {};
			callback = args[1];
		}
	} else {
		options = args[0];
		try {
			url = new URL(options.href || `${options.protocol || "http:"}//${options.hostname || options.host}${options.path}${options.search || (options.query ? `?${options.query}` : "")}`);
		} catch {
			url = null;
		}
		if (typeof args[1] === "function") callback = args[1];
	}
	if (!url) return Reflect.apply(origin, this, args);
	logger_default.debug(`Outgoing request: ${options.method || "GET"} ${url}`);
	options.headers = options.headers || {};
	const headersLowerCaseKeys = new Set(Object.keys(options.headers).map((key) => key.toLowerCase()));
	const generatedHeaders$1 = generateHeaders(options.headerGeneratorOptions);
	if (!headersLowerCaseKeys.has("user-agent")) options.headers["user-agent"] = config.ua;
	for (const header of generatedHeaders) if (!headersLowerCaseKeys.has(header) && generatedHeaders$1[header]) options.headers[header] = generatedHeaders$1[header];
	if (!headersLowerCaseKeys.has("referer")) options.headers.referer = url.origin;
	if (!options.agent && proxy_default.agent) {
		if (new RegExp(proxy_default.proxyObj.url_regex).test(url.toString()) && url.protocol.startsWith("http") && url.host !== proxy_default.proxyUrlHandler?.host && url.host !== "localhost" && !url.host.startsWith("127.") && !(config.puppeteerWSEndpoint?.includes(url.host) ?? false)) options.agent = proxy_default.agent;
	}
	const { headerGeneratorOptions, ...cleanOptions } = options;
	return Reflect.apply(origin, this, [
		url,
		cleanOptions,
		callback
	]);
};
var get_default = getWrappedGet;

//#endregion
//#region lib/utils/request-rewriter/index.ts
Object.defineProperties(globalThis, {
	fetch: { value: fetch_default },
	Headers: { value: Headers },
	FormData: { value: FormData },
	Request: { value: Request },
	Response: { value: Response }
});
http.get = get_default(http.get);
http.request = get_default(http.request);
https.get = get_default(https.get);
https.request = get_default(https.request);

//#endregion
//#region lib/app.ts
var app_default = (await import("./app-bootstrap-BuyhTBHV.mjs")).default;

//#endregion
export { app_default as default };