rsshub 1.0.0-master.fd8463a → 1.0.0-master.fd98be1

package/lib/utils/parse-date.ts

@@ -1,207 +0,0 @@
-import dayjs from 'dayjs';
-import customParseFormat from 'dayjs/plugin/customParseFormat.js';
-import duration from 'dayjs/plugin/duration.js';
-import isSameOrBefore from 'dayjs/plugin/isSameOrBefore.js';
-import weekday from 'dayjs/plugin/weekday.js';
-
-dayjs.extend(customParseFormat);
-dayjs.extend(duration);
-dayjs.extend(isSameOrBefore);
-dayjs.extend(weekday);
-
-const words = [
-    {
-        startAt: dayjs(),
-        regExp: /^(?:今[天日]|to?day?)(.*)/,
-    },
-    {
-        startAt: dayjs().subtract(1, 'days'),
-        regExp: /^(?:昨[天日]|y(?:ester)?day?)(.*)/,
-    },
-    {
-        startAt: dayjs().subtract(2, 'days'),
-        regExp: /^(?:前天|(?:the)?d(?:ay)?b(?:eforeyesterda)?y)(.*)/,
-    },
-    {
-        startAt: dayjs().isSameOrBefore(dayjs().weekday(1)) ? dayjs().weekday(1).subtract(1, 'week') : dayjs().weekday(1),
-        regExp: /^(?:周|星期)一(.*)/,
-    },
-    {
-        startAt: dayjs().isSameOrBefore(dayjs().weekday(2)) ? dayjs().weekday(2).subtract(1, 'week') : dayjs().weekday(2),
-        regExp: /^(?:周|星期)二(.*)/,
-    },
-    {
-        startAt: dayjs().isSameOrBefore(dayjs().weekday(3)) ? dayjs().weekday(3).subtract(1, 'week') : dayjs().weekday(3),
-        regExp: /^(?:周|星期)三(.*)/,
-    },
-    {
-        startAt: dayjs().isSameOrBefore(dayjs().weekday(4)) ? dayjs().weekday(4).subtract(1, 'week') : dayjs().weekday(4),
-        regExp: /^(?:周|星期)四(.*)/,
-    },
-    {
-        startAt: dayjs().isSameOrBefore(dayjs().weekday(5)) ? dayjs().weekday(5).subtract(1, 'week') : dayjs().weekday(5),
-        regExp: /^(?:周|星期)五(.*)/,
-    },
-    {
-        startAt: dayjs().isSameOrBefore(dayjs().weekday(6)) ? dayjs().weekday(6).subtract(1, 'week') : dayjs().weekday(6),
-        regExp: /^(?:周|星期)六(.*)/,
-    },
-    {
-        startAt: dayjs().isSameOrBefore(dayjs().weekday(7)) ? dayjs().weekday(7).subtract(1, 'week') : dayjs().weekday(7),
-        regExp: /^(?:周|星期)[天日](.*)/,
-    },
-    {
-        startAt: dayjs().add(1, 'days'),
-        regExp: /^(?:明[天日]|y(?:ester)?day?)(.*)/,
-    },
-    {
-        startAt: dayjs().add(2, 'days'),
-        regExp: /^(?:[后後][天日]|(?:the)?d(?:ay)?a(?:fter)?t(?:omrrow)?)(.*)/,
-    },
-];
-
-const patterns = [
-    {
-        unit: 'years',
-        regExp: /(\d+)(?:年|y(?:ea)?rs?)/,
-    },
-    {
-        unit: 'months',
-        regExp: /(\d+)(?:[个個]?月|months?)/,
-    },
-    {
-        unit: 'weeks',
-        regExp: /(\d+)(?:周|[个個]?星期|weeks?)/,
-    },
-    {
-        unit: 'days',
-        regExp: /(\d+)(?:天|日|d(?:ay)?s?)/,
-    },
-    {
-        unit: 'hours',
-        regExp: /(\d+)(?:[个個]?(?:小?时|時|点|點)|h(?:(?:ou)?r)?s?)/,
-    },
-    {
-        unit: 'minutes',
-        regExp: /(\d+)(?:分[鐘钟]?|m(?:in(?:ute)?)?s?)/,
-    },
-    {
-        unit: 'seconds',
-        regExp: /(\d+)(?:秒[鐘钟]?|s(?:ec(?:ond)?)?s?)/,
-    },
-];
-
-const patternSize = Object.keys(patterns).length;
-
-/**
- * 预处理日期字符串
- * @param {String} date 原始日期字符串
- */
-const toDate = (date: string) =>
-    date
-        .toLowerCase()
-        .replaceAll(/(^an?\s)|(\san?\s)/g, '1') // 替换 `a` 和 `an` 为 `1`
-        .replaceAll(/几|幾/g, '3') // 如 `几秒钟前` 视作 `3秒钟前`
-        .replaceAll(/[\s,]/g, ''); // 移除所有空格
-
-/**
- * 将 `['\d+时', ..., '\d+秒']` 转换为 `{ hours: \d+, ..., seconds: \d+ }`
- * 用于描述时间长度
- * @param {Array.<String>} matches 所有匹配结果
- */
-const toDurations = (matches: string[]) => {
-    const durations: Record<string, string> = {};
-
-    let p = 0;
-    for (const m of matches) {
-        for (; p <= patternSize; p++) {
-            const match = patterns[p].regExp.exec(m);
-            if (match) {
-                durations[patterns[p].unit] = match[1];
-                break;
-            }
-        }
-    }
-    return durations;
-};
-
-export const parseDate = (date: string | number, ...options: any) => dayjs(date, ...options).toDate();
-
-export const parseRelativeDate = (date: string) => {
-    // 预处理日期字符串 date
-
-    const theDate = toDate(date);
-
-    // 将 `\d+年\d+月...\d+秒前` 分割成 `['\d+年', ..., '\d+秒前']`
-
-    const matches = theDate.match(/(?:\D+)?\d+(?!:|-|\/|(a|p)m)\D+/g);
-
-    if (matches) {
-        // 获得最后的时间单元，如 `\d+秒前`
-
-        const lastMatch = matches.pop();
-
-        if (lastMatch) {
-            // 若最后的时间单元含有 `前`、`以前`、`之前` 等标识字段，减去相应的时间长度
-            // 如 `1分10秒前`
-
-            const beforeMatches = /(.*)(?:[之以]?前|ago)$/.exec(lastMatch);
-            if (beforeMatches) {
-                matches.push(beforeMatches[1]);
-                return dayjs()
-                    .subtract(dayjs.duration(toDurations(matches)))
-                    .toDate();
-            }
-
-            // 若最后的时间单元含有 `后`、`以后`、`之后` 等标识字段，加上相应的时间长度
-            // 如 `1分10秒后`
-
-            const afterMatches = /(?:^in(.*)|(.*)[之以]?[后後])$/.exec(lastMatch);
-            if (afterMatches) {
-                matches.push(afterMatches[1] ?? afterMatches[2]);
-                return dayjs()
-                    .add(dayjs.duration(toDurations(matches)))
-                    .toDate();
-            }
-
-            // 以下处理日期字符串 date 含有特殊词的情形
-            // 如 `今天1点10分`
-
-            matches.push(lastMatch);
-        }
-        const firstMatch = matches.shift();
-
-        if (firstMatch) {
-            for (const w of words) {
-                const wordMatches = w.regExp.exec(firstMatch);
-                if (wordMatches) {
-                    matches.unshift(wordMatches[1]);
-
-                    // 取特殊词对应日零时为起点，加上相应的时间长度
-
-                    return w.startAt
-                        .set('hour', 0)
-                        .set('minute', 0)
-                        .set('second', 0)
-                        .set('millisecond', 0)
-                        .add(dayjs.duration(toDurations(matches)))
-                        .toDate();
-                }
-            }
-        }
-    } else {
-        // 若日期字符串 date 不匹配 patterns 中所有模式，则默认为 `特殊词 + 标准时间格式` 的情形，此时直接将特殊词替换为对应日期
-        // 如今天为 `2022-03-22`，则 `今天 20:00` => `2022-03-22 20:00`
-
-        for (const w of words) {
-            const wordMatches = w.regExp.exec(theDate);
-            if (wordMatches) {
-                // The default parser of dayjs() can parse '8:00 pm' but not '8:00pm'
-                // so we need to insert a space in between
-                return dayjs(`${w.startAt.format('YYYY-MM-DD')} ${/a|pm$/.test(wordMatches[1]) ? wordMatches[1].replace(/a|pm/, ' $&') : wordMatches[1]}`).toDate();
-            }
-        }
-    }
-
-    return date;
-};

package/lib/utils/proxy/index.ts

@@ -1,140 +0,0 @@
-import { config } from '@/config';
-import { PacProxyAgent } from 'pac-proxy-agent';
-import { HttpsProxyAgent } from 'https-proxy-agent';
-import { SocksProxyAgent } from 'socks-proxy-agent';
-import { ProxyAgent } from 'undici';
-import logger from '@/utils/logger';
-
-const proxyIsPAC = config.pacUri || config.pacScript;
-
-import pacProxy from './pac-proxy';
-import unifyProxy from './unify-proxy';
-import createMultiProxy, { type MultiProxyResult, type ProxyState } from './multi-proxy';
-
-interface ProxyExport {
-    agent: PacProxyAgent<string> | HttpsProxyAgent<string> | SocksProxyAgent | null;
-    dispatcher: ProxyAgent | null;
-    proxyUri?: string;
-    proxyObj: Record<string, any>;
-    proxyUrlHandler?: URL | null;
-    multiProxy?: MultiProxyResult;
-    getCurrentProxy: () => ProxyState | null;
-    markProxyFailed: (proxyUri: string) => void;
-    getAgentForProxy: (proxyState: ProxyState) => any;
-    getDispatcherForProxy: (proxyState: ProxyState) => ProxyAgent | null;
-}
-
-let proxyUri: string | undefined;
-let proxyObj: Record<string, any> = {};
-let proxyUrlHandler: URL | null = null;
-let multiProxy: MultiProxyResult | undefined;
-
-const createAgentForProxy = (uri: string, proxyObj: Record<string, any>): any => {
-    if (uri.startsWith('http')) {
-        return new HttpsProxyAgent(uri, {
-            headers: {
-                'proxy-authorization': proxyObj?.auth ? `Basic ${proxyObj.auth}` : undefined,
-            },
-        });
-    } else if (uri.startsWith('socks')) {
-        return new SocksProxyAgent(uri);
-    }
-    return null;
-};
-
-const createDispatcherForProxy = (uri: string, proxyObj: Record<string, any>): ProxyAgent | null => {
-    if (uri.startsWith('http')) {
-        return new ProxyAgent({
-            uri,
-            token: proxyObj?.auth ? `Basic ${proxyObj.auth}` : undefined,
-            requestTls: {
-                rejectUnauthorized: process.env.NODE_TLS_REJECT_UNAUTHORIZED !== '0',
-            },
-        });
-    }
-    return null;
-};
-
-if (proxyIsPAC) {
-    const proxy = pacProxy(config.pacUri, config.pacScript, config.proxy);
-    proxyUri = proxy.proxyUri;
-    proxyObj = proxy.proxyObj;
-    proxyUrlHandler = proxy.proxyUrlHandler;
-} else if (config.proxyUris && config.proxyUris.length > 0) {
-    multiProxy = createMultiProxy(config.proxyUris, config.proxy);
-    proxyObj = multiProxy.proxyObj;
-    const currentProxy = multiProxy.getNextProxy();
-    if (currentProxy) {
-        proxyUri = currentProxy.uri;
-        proxyUrlHandler = currentProxy.urlHandler;
-    }
-    logger.info(`Multi-proxy initialized with ${config.proxyUris.length} proxies`);
-} else {
-    const proxy = unifyProxy(config.proxyUri, config.proxy);
-    proxyUri = proxy.proxyUri;
-    proxyObj = proxy.proxyObj;
-    proxyUrlHandler = proxy.proxyUrlHandler;
-}
-
-let agent: PacProxyAgent<string> | HttpsProxyAgent<string> | SocksProxyAgent | null = null;
-let dispatcher: ProxyAgent | null = null;
-
-if (proxyIsPAC && proxyUri) {
-    agent = new PacProxyAgent(`pac+${proxyUri}`);
-} else if (proxyUri) {
-    agent = createAgentForProxy(proxyUri, proxyObj);
-    dispatcher = createDispatcherForProxy(proxyUri, proxyObj);
-}
-
-const getCurrentProxy = (): ProxyState | null => {
-    if (multiProxy) {
-        return multiProxy.getNextProxy();
-    }
-    if (proxyUri) {
-        return {
-            uri: proxyUri,
-            isActive: true,
-            failureCount: 0,
-            urlHandler: proxyUrlHandler,
-        };
-    }
-    return null;
-};
-
-const markProxyFailed = (failedProxyUri: string) => {
-    if (multiProxy) {
-        multiProxy.markProxyFailed(failedProxyUri);
-        const nextProxy = multiProxy.getNextProxy();
-        if (nextProxy) {
-            proxyUri = nextProxy.uri;
-            proxyUrlHandler = nextProxy.urlHandler || null;
-            agent = createAgentForProxy(nextProxy.uri, proxyObj);
-            dispatcher = createDispatcherForProxy(nextProxy.uri, proxyObj);
-            logger.info(`Switched to proxy: ${nextProxy.uri}`);
-        } else {
-            logger.warn('No available proxies remaining');
-            agent = null;
-            dispatcher = null;
-            proxyUri = undefined;
-        }
-    }
-};
-
-const getAgentForProxy = (proxyState: ProxyState) => createAgentForProxy(proxyState.uri, proxyObj);
-
-const getDispatcherForProxy = (proxyState: ProxyState) => createDispatcherForProxy(proxyState.uri, proxyObj);
-
-const proxyExport: ProxyExport = {
-    agent,
-    dispatcher,
-    proxyUri,
-    proxyObj,
-    proxyUrlHandler,
-    multiProxy,
-    getCurrentProxy,
-    markProxyFailed,
-    getAgentForProxy,
-    getDispatcherForProxy,
-};
-
-export default proxyExport;

package/lib/utils/proxy/multi-proxy.ts

@@ -1,139 +0,0 @@
-import { type Config } from '@/config';
-import logger from '@/utils/logger';
-import unifyProxy from './unify-proxy';
-
-export interface ProxyState {
-    uri: string;
-    isActive: boolean;
-    failureCount: number;
-    lastFailureTime?: number;
-    agent?: any;
-    dispatcher?: any;
-    urlHandler?: URL | null;
-}
-
-export interface MultiProxyResult {
-    currentProxy?: ProxyState | null;
-    allProxies: ProxyState[];
-    proxyObj: Config['proxy'];
-    getNextProxy: () => ProxyState | null;
-    markProxyFailed: (proxyUri: string) => void;
-    resetProxy: (proxyUri: string) => void;
-}
-
-const createMultiProxy = (proxyUris: string[], proxyObj: Config['proxy']): MultiProxyResult => {
-    const proxies: ProxyState[] = [];
-    let currentProxyIndex = 0;
-
-    for (const uri of proxyUris) {
-        const unifiedProxy = unifyProxy(uri, proxyObj);
-        if (unifiedProxy.proxyUri) {
-            proxies.push({
-                uri: unifiedProxy.proxyUri,
-                isActive: true,
-                failureCount: 0,
-                urlHandler: unifiedProxy.proxyUrlHandler,
-            });
-        }
-    }
-
-    if (proxies.length === 0) {
-        logger.warn('No valid proxies found in the provided list');
-        return {
-            allProxies: [],
-            proxyObj: proxyObj || {},
-            getNextProxy: () => null,
-            markProxyFailed: () => {},
-            resetProxy: () => {},
-        };
-    }
-
-    const healthCheckInterval = proxyObj?.healthCheckInterval || 60000;
-    const maxFailures = 3;
-
-    const healthCheck = () => {
-        const now = Date.now();
-        for (const proxy of proxies) {
-            if (!proxy.isActive && proxy.lastFailureTime && now - proxy.lastFailureTime > healthCheckInterval) {
-                proxy.isActive = true;
-                proxy.failureCount = 0;
-                delete proxy.lastFailureTime;
-                logger.info(`Proxy ${proxy.uri} marked as active again after health check`);
-            }
-        }
-    };
-
-    setInterval(healthCheck, healthCheckInterval);
-
-    const getNextProxy = (): ProxyState | null => {
-        const activeProxies = proxies.filter((p) => p.isActive);
-        if (activeProxies.length === 0) {
-            logger.warn('No active proxies available');
-            return null;
-        }
-
-        let nextProxy = activeProxies[currentProxyIndex % activeProxies.length];
-        let attempts = 0;
-
-        while (!nextProxy.isActive && attempts < activeProxies.length) {
-            currentProxyIndex = (currentProxyIndex + 1) % activeProxies.length;
-            nextProxy = activeProxies[currentProxyIndex];
-            attempts++;
-        }
-
-        if (!nextProxy.isActive) {
-            return null;
-        }
-
-        return nextProxy;
-    };
-
-    const markProxyFailed = (proxyUri: string) => {
-        const proxy = proxies.find((p) => p.uri === proxyUri);
-        if (proxy) {
-            proxy.failureCount++;
-            proxy.lastFailureTime = Date.now();
-            if (proxy.failureCount >= maxFailures) {
-                proxy.isActive = false;
-                logger.warn(`Proxy ${proxyUri} marked as inactive after ${maxFailures} failures`);
-            } else {
-                logger.warn(`Proxy ${proxyUri} failed (${proxy.failureCount}/${maxFailures})`);
-            }
-
-            const activeProxies = proxies.filter((p) => p.isActive);
-            if (activeProxies.length > 0) {
-                currentProxyIndex = (currentProxyIndex + 1) % activeProxies.length;
-                const nextProxy = getNextProxy();
-                if (nextProxy) {
-                    logger.info(`Switching to proxy: ${nextProxy.uri}`);
-                }
-            }
-        }
-    };
-
-    const resetProxy = (proxyUri: string) => {
-        const proxy = proxies.find((p) => p.uri === proxyUri);
-        if (proxy) {
-            proxy.isActive = true;
-            proxy.failureCount = 0;
-            delete proxy.lastFailureTime;
-            logger.info(`Proxy ${proxyUri} manually reset`);
-        }
-    };
-
-    const currentProxy = getNextProxy();
-    if (currentProxy) {
-        logger.info(`Initial proxy selected: ${currentProxy.uri}`);
-    }
-
-    return {
-        currentProxy,
-        allProxies: proxies,
-        proxyObj: proxyObj || {},
-        getNextProxy,
-        markProxyFailed,
-        resetProxy,
-    };
-};
-
-export default createMultiProxy;

package/lib/utils/proxy/pac-proxy.test.ts

@@ -1,80 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import pacProxy from '@/utils/proxy/pac-proxy';
-
-const emptyProxyObj = {
-    protocol: undefined,
-    host: undefined,
-    port: undefined,
-    auth: undefined,
-    url_regex: '.*',
-};
-
-const effectiveExpect = ({ proxyUri, proxyObj }, expectUri, expectObj) => {
-    expect(proxyUri).toBe(expectUri);
-    expect(proxyObj).toEqual(expectObj);
-};
-
-describe('pac-proxy', () => {
-    const nullExpect = (pac) => effectiveExpect(pac, undefined, emptyProxyObj);
-    it('pac empty', () => {
-        nullExpect(pacProxy('', '', emptyProxyObj));
-    });
-    it('pac-uri invalid', () => {
-        nullExpect(pacProxy('http://inv ild.test', '', emptyProxyObj));
-    });
-    it('pac-uri invalid protocol', () => {
-        nullExpect(pacProxy('socks://rsshub.proxy', '', emptyProxyObj));
-    });
-
-    const httpUri = 'http://rsshub.proxy/pac.pac';
-    it('pac-uri http', () => {
-        effectiveExpect(pacProxy(httpUri, '', emptyProxyObj), httpUri, emptyProxyObj);
-    });
-
-    const httpsUri = 'https://rsshub.proxy/pac.pac';
-    it('pac-uri https', () => {
-        effectiveExpect(pacProxy(httpsUri, '', emptyProxyObj), httpsUri, emptyProxyObj);
-    });
-
-    const ftpUri = 'ftp://rsshub.proxy:2333';
-    it('pac-uri ftp', () => {
-        effectiveExpect(pacProxy(ftpUri, '', emptyProxyObj), ftpUri, emptyProxyObj);
-    });
-
-    const fileUri = 'file:///path/to/pac.pac';
-    it('pac-uri file', () => {
-        effectiveExpect(pacProxy(fileUri, '', emptyProxyObj), fileUri, emptyProxyObj);
-    });
-
-    const dataPacScript = "function FindProxyForURL(url, host){return 'DIRECT';}";
-    const dataUri = 'data:text/javascript;charset=utf-8,' + encodeURIComponent(dataPacScript);
-    it('pac-script data', () => {
-        effectiveExpect(pacProxy('', dataPacScript, emptyProxyObj), dataUri, emptyProxyObj);
-    });
-
-    const httpsObj = { ...emptyProxyObj, protocol: 'https', host: 'rsshub.proxy', port: '2333' };
-    const httpsAuthUri = 'https://user:pass@rsshub.proxy:2333';
-    it('pac-uri https auth', () => {
-        effectiveExpect(pacProxy(httpsAuthUri, '', emptyProxyObj), httpsAuthUri, httpsObj);
-    });
-
-    const httpsAuthObj = { ...httpsObj, auth: 'testtest' };
-    it('pac proxy-obj https auth', () => {
-        effectiveExpect(pacProxy(httpsUri, '', httpsAuthObj), httpsUri, httpsAuthObj);
-    });
-
-    const ftpObj = { ...httpsObj, protocol: 'ftp' };
-    const ftpAuthUri = 'ftp://user:pass@rsshub.proxy:2333';
-    it('pac-uri ftp auth', () => {
-        effectiveExpect(pacProxy(ftpAuthUri, '', emptyProxyObj), ftpAuthUri, ftpObj);
-    });
-
-    const ftpAuthObj = { ...ftpObj, auth: 'testtest' };
-    it('pac-uri ftp auth (invalid)', () => {
-        effectiveExpect(pacProxy(ftpUri, '', ftpAuthObj), ftpUri, ftpObj);
-    });
-
-    it('pac-uri user@pass override proxy-obj auth', () => {
-        effectiveExpect(pacProxy(httpsAuthUri, '', httpsAuthObj), httpsAuthUri, httpsObj);
-    });
-});

package/lib/utils/proxy/pac-proxy.ts

@@ -1,72 +0,0 @@
-import { type Config } from '@/config';
-import logger from '@/utils/logger';
-
-const possibleProtocol = ['http', 'https', 'ftp', 'file', 'data'];
-
-const pacProxy = (pacUri: Config['pacUri'], pacScript: Config['pacScript'], proxyObj: Config['proxy']) => {
-    let pacUrlHandler: URL | null = null;
-
-    // Validate PAC_URI / PAC_SCRIPT
-    if (pacScript) {
-        if (typeof pacScript === 'string') {
-            pacUri = 'data:text/javascript;charset=utf-8,' + encodeURIComponent(pacScript);
-        } else {
-            logger.error('Invalid PAC_SCRIPT, use PAC_URI instead');
-        }
-    }
-    if (pacUri && typeof pacUri === 'string') {
-        try {
-            pacUrlHandler = new URL(pacUri);
-        } catch (error: any) {
-            pacUri = undefined;
-            pacUrlHandler = null;
-            logger.error(`Parse PAC_URI error: ${error.stack}`);
-        }
-    } else {
-        pacUri = undefined;
-    }
-
-    // Check if PAC_URI has the right protocol
-    if (pacUri && (!pacUrlHandler?.protocol || !possibleProtocol.includes(pacUrlHandler.protocol.replace(':', '')))) {
-        logger.error(`Unsupported PAC protocol: ${pacUrlHandler?.protocol?.replace(':', '')}, expect one of ${possibleProtocol.join(', ')}`);
-        pacUri = undefined;
-        pacUrlHandler = null;
-    }
-
-    // Validate proxyObj
-    if (pacUrlHandler) {
-        proxyObj.host = pacUrlHandler.hostname;
-        proxyObj.port = pacUrlHandler.port;
-        proxyObj.protocol = pacUrlHandler.protocol.replace(':', '');
-    } else {
-        proxyObj.protocol = proxyObj.host = proxyObj.port = proxyObj.auth = undefined;
-    }
-
-    // Validate PROXY_AUTH
-    if (proxyObj.auth && pacUrlHandler) {
-        let promptProxyUri = false;
-        if (pacUrlHandler.username || pacUrlHandler.password) {
-            logger.warn('PAC_URI contains username and/or password, ignoring PROXY_AUTH');
-            proxyObj.auth = undefined;
-        } else if (['http:', 'https:'].includes(pacUrlHandler.protocol)) {
-            logger.info('PROXY_AUTH is set and will be used for requests from Node.js. However, requests from puppeteer will not use it');
-            promptProxyUri = true;
-        } else {
-            logger.warn(`PROXY_AUTH is only supported by HTTP(S) proxies, but got ${pacUrlHandler.protocol}, ignoring`);
-            proxyObj.auth = undefined;
-            promptProxyUri = true;
-        }
-        if (promptProxyUri) {
-            logger.info('To get rid of this, set PAC_URI like protocol://username:password@host:port and clear PROXY_{AUTH,PROTOCOL,HOST,PORT}');
-        }
-    }
-
-    // Compatible with unify-proxy
-    return {
-        proxyUri: pacUri,
-        proxyObj,
-        proxyUrlHandler: pacUrlHandler,
-    };
-};
-
-export default pacProxy;