rucaptcha-2captcha/build/index.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.isArrayLikeString = void 0;
const fs_1 = __importDefault(require("fs"));
const axios_1 = __importDefault(require("axios"));
const cheerio_1 = __importDefault(require("cheerio"));
var types_1 = require("./types");
Object.defineProperty(exports, "isArrayLikeString", { enumerable: true, get: function () { return types_1.isArrayLikeString; } });
const wait = (s) => new Promise(res => setTimeout(res, s * 1000));
function throwErrorOfBadStatus(status, data) {
    if (!status && data.request !== 'CAPCHA_NOT_READY') {
        const e = new Error(data.error_text);
        e.name = data.request;
        throw e;
    }
}
function RuCaptcha2Captcha(key, captchaService) {
    const isRuCaptcha = captchaService !== 2 && captchaService !== '2';
    const domain = `https://${isRuCaptcha ? 'ru' : 2}captcha.com`;
    const sendUrl = `${domain}/in.php`;
    const getUrl = `${domain}/res.php`;
    const priceUrls = {
        all: isRuCaptcha ? 'https://rucaptcha.com/api-rucaptcha#rates' : 'https://2captcha.com/2captcha-api#rates',
        normal: `${domain}/public_statistics`,
    };
    const waitings = {};
    const makeReport = (type) => ((id) => axios_1.default
        .get(getUrl, {
        params: {
            key,
            action: `report${type}`,
            id,
            json: 1,
        },
    })
        .then((e) => e.data)
        .catch(e => {
        if (e.message === 'Request failed with status code 500') {
            const res = { status: 1, request: 'OK_REPORT_RECORDED' };
            return res;
        }
        throw e;
    }));
    const res = {
        async send({ url, method, file, body, ...restParams }) {
            let p = {
                method,
                file,
                body,
            };
            if (url) {
                let buffer;
                try {
                    buffer = fs_1.default.readFileSync(url);
                }
                catch {
                    const { data } = await axios_1.default.get(url, { responseType: 'arraybuffer' });
                    buffer = Buffer.from(data, 'binary');
                }
                p = {
                    method: 'base64',
                    body: buffer.toString('base64'),
                };
            }
            const params = {
                ...Object.fromEntries(Object.entries(p).filter(e => e[1] != null)),
                ...restParams,
                key,
                json: 1,
                soft_id: 2721,
            };
            const { data: { status, ...data } } = await axios_1.default.post(sendUrl, params);
            throwErrorOfBadStatus(status, data);
            const { request: id } = data;
            const m = (params.method || '').toLowerCase();
            const timeToWaitInSeconds = true
                && ['post', 'base64', ''].includes(m)
                && params.recaptcha == null
                && params.coordinatescaptcha == null
                ? 5
                : 20;
            waitings[id] = wait(timeToWaitInSeconds);
            return id;
        },
        async get(id) {
            const ids = String(id).split(/\s*,\s*/);
            // eslint-disable-next-line no-constant-condition
            while (1) {
                await Promise.all(ids.map(id => waitings[id]));
                const { data: { status, ...data } } = await axios_1.default.get(getUrl, {
                    params: {
                        key,
                        action: 'get',
                        [`id${ids.length > 1 ? 's' : ''}`]: ids.join(),
                        json: 1,
                    },
                });
                throwErrorOfBadStatus(status, data);
                const res = data.request.split('|');
                if (res.every(e => e !== 'CAPCHA_NOT_READY')) {
                    return (Array.isArray(id) || typeof id === 'string' && id.match(/,/) ? res : res[0]);
                }
                if (res.length === ids.length) {
                    const arr = ids
                        .map((id, i) => ({ id, captcha: res[i] }))
                        .filter(({ captcha }) => captcha === 'CAPCHA_NOT_READY');
                    for (const { id } of arr) {
                        waitings[id] = wait(5);
                    }
                }
                else {
                    for (const id of ids) {
                        waitings[id] = wait(5);
                    }
                }
            }
            throw new Error();
        },
        async getWithPrice(id) {
            // eslint-disable-next-line no-param-reassign
            id = String(id);
            // eslint-disable-next-line no-constant-condition
            while (1) {
                await waitings[id];
                const { data: { status, ...data } } = await axios_1.default.get(getUrl, {
                    params: {
                        key,
                        action: 'get2',
                        id,
                        json: 1,
                    },
                });
                throwErrorOfBadStatus(status, data);
                if (data.request !== 'CAPCHA_NOT_READY') {
                    const { request: token, ...rest } = data;
                    return { token, ...rest };
                }
                waitings[id] = wait(5);
            }
            throw new Error();
        },
        reportGood: makeReport('good'),
        reportBad: makeReport('bad'),
        async getBalance() {
            const { data } = await axios_1.default.get(getUrl, {
                params: {
                    key,
                    action: 'getbalance',
                },
            });
            return data;
        },
        async getPrices() {
            const normalNames = [];
            const [normalPrice, otherPrices] = await Promise.all([
                axios_1.default.get(priceUrls.normal).then(({ data }) => {
                    const $ = cheerio_1.default.load(data, { decodeEntities: false });
                    const price = $.text().match(/[i$] ?([\d.]+)/);
                    return price && +(Number(price[1]) / 1000).toFixed(7) || NaN;
                }),
                axios_1.default.get(priceUrls.all).then(({ data }) => {
                    const $ = cheerio_1.default.load(data, { decodeEntities: false });
                    const table = $($('.table').toArray().find(e => $(e).text().match(/Type of captcha|Вид капчи/i)));
                    return table.find('tr').toArray().slice(1).reduce((obj, e) => {
                        const [types, price] = $(e).find('td').toArray().map((e, i) => (i ? e : $(e).find('a').toArray()));
                        const p = +(Number($(price).text().replace(/\$/g, '')) / 1000).toFixed(7) || NaN;
                        for (const type of types) {
                            const t = $(type).text().trim();
                            if (Number.isNaN(p)) {
                                normalNames.push(t);
                            }
                            else {
                                // eslint-disable-next-line no-param-reassign
                                obj[t] = p;
                            }
                        }
                        return obj;
                    }, {});
                }),
            ]);
            const normalPrices = Object.fromEntries(normalNames.map(e => [e, normalPrice]));
            return {
                ...normalPrices,
                ...otherPrices,
            };
        },
        async solve(...params) {
            const id = await res.send(...params);
            const token = await res.get(id);
            return {
                token,
                tokenIsGood: res.reportGood.bind(null, id),
                tokenIsBad: res.reportBad.bind(null, id),
            };
        },
    };
    return res;
}
exports.default = RuCaptcha2Captcha;
if (typeof exports.default === 'function') {
    module.exports = exports.default;
    Object.assign(module.exports, exports);
}