which-bot/dist/util.js

detect which bot is from user-agent and is trustable

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.isValidIp = exports.match = exports.serializeRules = void 0;
const mergeRegexp = (rules) => {
    const sources = rules.map(item => item.source);
    const flags = Array.from(new Set(Array.prototype.concat([], ...rules.map(item => item.flags ? item.flags.split('') : []))));
    return new RegExp(sources.join('|'), flags.join('') || 'i');
};
const serializeRules = (rules) => {
    return rules.map((item) => {
        const bots = item.bots.map(item => {
            return Object.assign(Object.assign({}, item), { pattern: new RegExp(item.pattern, item.pattern instanceof RegExp && item.pattern.flags || 'i') });
        });
        return Object.assign(Object.assign({}, item), { bots, pattern: mergeRegexp(bots.map((item) => item.pattern)) });
    });
};
exports.serializeRules = serializeRules;
const match = (ua, rules) => {
    for (const group of rules) {
        if (!ua.match(group.pattern)) {
            continue;
        }
        for (const bot of group.bots) {
            if (!ua.match(bot.pattern)) {
                continue;
            }
            return {
                company: group.company,
                name: bot.name,
                hosts: group.hosts,
            };
        }
        return false;
    }
    return false;
};
exports.match = match;
const isValidIp = (hosts, ip) => __awaiter(void 0, void 0, void 0, function* () {
    const { reverse } = require('dns').promises;
    if (typeof reverse !== 'function') {
        return false;
    }
    try {
        const resolved = yield reverse(ip);
        for (const item of resolved) {
            for (const host of hosts) {
                if (item.endsWith(host)) {
                    return true;
                }
            }
        }
        return false;
    }
    catch (e) {
        return false;
    }
});
exports.isValidIp = isValidIp;
//# sourceMappingURL=util.js.map