@jshookmcp/jshook 0.2.6 → 0.2.8

package/dist/src/modules/emulator/BrowserAPIDatabase.js

@@ -1,325 +0,0 @@
-export class BrowserAPIDatabase {
-    apis = new Map();
-    constructor() {
-        this.initializeAPIs();
-    }
-    initializeAPIs() {
-        this.addAPI({
-            name: 'window',
-            path: 'window',
-            type: 'property',
-            returnType: 'Window',
-            description: 'Global window object',
-            antiCrawlImportance: 10,
-        });
-        this.addAPI({
-            name: 'self',
-            path: 'window.self',
-            type: 'property',
-            returnType: 'Window',
-            description: 'Reference to window itself',
-            antiCrawlImportance: 8,
-        });
-        this.addAPI({
-            name: 'top',
-            path: 'window.top',
-            type: 'property',
-            returnType: 'Window',
-            description: 'Topmost window',
-            antiCrawlImportance: 7,
-        });
-        this.addAPI({
-            name: 'parent',
-            path: 'window.parent',
-            type: 'property',
-            returnType: 'Window',
-            description: 'Parent window',
-            antiCrawlImportance: 7,
-        });
-        this.addAPI({
-            name: 'setTimeout',
-            path: 'window.setTimeout',
-            type: 'method',
-            returnType: 'number',
-            parameters: [
-                { name: 'callback', type: 'Function' },
-                { name: 'delay', type: 'number', optional: true, defaultValue: 0 },
-            ],
-            implementation: 'function(callback, delay) { return setTimeout(callback, delay); }',
-            antiCrawlImportance: 9,
-        });
-        this.addAPI({
-            name: 'setInterval',
-            path: 'window.setInterval',
-            type: 'method',
-            returnType: 'number',
-            parameters: [
-                { name: 'callback', type: 'Function' },
-                { name: 'delay', type: 'number', optional: true, defaultValue: 0 },
-            ],
-            implementation: 'function(callback, delay) { return setInterval(callback, delay); }',
-            antiCrawlImportance: 8,
-        });
-        this.addAPI({
-            name: 'clearTimeout',
-            path: 'window.clearTimeout',
-            type: 'method',
-            returnType: 'void',
-            parameters: [{ name: 'id', type: 'number' }],
-            implementation: 'function(id) { clearTimeout(id); }',
-            antiCrawlImportance: 7,
-        });
-        this.addAPI({
-            name: 'clearInterval',
-            path: 'window.clearInterval',
-            type: 'method',
-            returnType: 'void',
-            parameters: [{ name: 'id', type: 'number' }],
-            implementation: 'function(id) { clearInterval(id); }',
-            antiCrawlImportance: 7,
-        });
-        this.addAPI({
-            name: 'requestAnimationFrame',
-            path: 'window.requestAnimationFrame',
-            type: 'method',
-            returnType: 'number',
-            parameters: [{ name: 'callback', type: 'FrameRequestCallback' }],
-            implementation: 'function(callback) { return setTimeout(callback, 16); }',
-            antiCrawlImportance: 8,
-        });
-        this.addAPI({
-            name: 'cancelAnimationFrame',
-            path: 'window.cancelAnimationFrame',
-            type: 'method',
-            returnType: 'void',
-            parameters: [{ name: 'id', type: 'number' }],
-            implementation: 'function(id) { clearTimeout(id); }',
-            antiCrawlImportance: 7,
-        });
-        this.addAPI({
-            name: 'btoa',
-            path: 'window.btoa',
-            type: 'method',
-            returnType: 'string',
-            parameters: [{ name: 'data', type: 'string' }],
-            implementation: 'function(data) { return Buffer.from(data).toString("base64"); }',
-            antiCrawlImportance: 6,
-        });
-        this.addAPI({
-            name: 'atob',
-            path: 'window.atob',
-            type: 'method',
-            returnType: 'string',
-            parameters: [{ name: 'data', type: 'string' }],
-            implementation: 'function(data) { return Buffer.from(data, "base64").toString(); }',
-            antiCrawlImportance: 6,
-        });
-        this.addAPI({
-            name: 'plugins',
-            path: 'navigator.plugins',
-            type: 'property',
-            returnType: 'PluginArray',
-            description: 'Browser plugins',
-            antiCrawlImportance: 9,
-        });
-        this.addAPI({
-            name: 'mimeTypes',
-            path: 'navigator.mimeTypes',
-            type: 'property',
-            returnType: 'MimeTypeArray',
-            description: 'Supported MIME types',
-            antiCrawlImportance: 8,
-        });
-        this.addAPI({
-            name: 'permissions',
-            path: 'navigator.permissions',
-            type: 'property',
-            returnType: 'Permissions',
-            description: 'Permissions API',
-            antiCrawlImportance: 7,
-            browsers: ['chrome', 'firefox', 'edge'],
-        });
-        this.addAPI({
-            name: 'getBattery',
-            path: 'navigator.getBattery',
-            type: 'method',
-            returnType: 'Promise<BatteryManager>',
-            parameters: [],
-            implementation: 'function() { return Promise.resolve({}); }',
-            antiCrawlImportance: 5,
-            browsers: ['chrome', 'firefox', 'edge', 'opera'],
-        });
-        this.addAPI({
-            name: 'getGamepads',
-            path: 'navigator.getGamepads',
-            type: 'method',
-            returnType: 'Gamepad[]',
-            parameters: [],
-            implementation: 'function() { return []; }',
-            antiCrawlImportance: 3,
-        });
-        this.addAPI({
-            name: 'sendBeacon',
-            path: 'navigator.sendBeacon',
-            type: 'method',
-            returnType: 'boolean',
-            parameters: [
-                { name: 'url', type: 'string' },
-                { name: 'data', type: 'any', optional: true },
-            ],
-            implementation: 'function() { return true; }',
-            antiCrawlImportance: 6,
-        });
-        this.addAPI({
-            name: 'getElementById',
-            path: 'document.getElementById',
-            type: 'method',
-            returnType: 'HTMLElement | null',
-            parameters: [{ name: 'id', type: 'string' }],
-            implementation: 'function() { return null; }',
-            antiCrawlImportance: 7,
-        });
-        this.addAPI({
-            name: 'querySelector',
-            path: 'document.querySelector',
-            type: 'method',
-            returnType: 'Element | null',
-            parameters: [{ name: 'selector', type: 'string' }],
-            implementation: 'function() { return null; }',
-            antiCrawlImportance: 7,
-        });
-        this.addAPI({
-            name: 'querySelectorAll',
-            path: 'document.querySelectorAll',
-            type: 'method',
-            returnType: 'NodeList',
-            parameters: [{ name: 'selector', type: 'string' }],
-            implementation: 'function() { return []; }',
-            antiCrawlImportance: 7,
-        });
-        this.addAPI({
-            name: 'createElement',
-            path: 'document.createElement',
-            type: 'method',
-            returnType: 'HTMLElement',
-            parameters: [{ name: 'tagName', type: 'string' }],
-            implementation: 'function() { return {}; }',
-            antiCrawlImportance: 8,
-        });
-        this.addAPI({
-            name: 'createTextNode',
-            path: 'document.createTextNode',
-            type: 'method',
-            returnType: 'Text',
-            parameters: [{ name: 'data', type: 'string' }],
-            implementation: 'function() { return {}; }',
-            antiCrawlImportance: 6,
-        });
-        this.addAPI({
-            name: 'addEventListener',
-            path: 'document.addEventListener',
-            type: 'method',
-            returnType: 'void',
-            parameters: [
-                { name: 'type', type: 'string' },
-                { name: 'listener', type: 'EventListener' },
-                { name: 'options', type: 'boolean | AddEventListenerOptions', optional: true },
-            ],
-            implementation: 'function() {}',
-            antiCrawlImportance: 7,
-        });
-        this.addAPI({
-            name: 'log',
-            path: 'console.log',
-            type: 'method',
-            returnType: 'void',
-            parameters: [{ name: 'message', type: 'any' }],
-            implementation: 'function(...args) { console.log(...args); }',
-            antiCrawlImportance: 5,
-        });
-        this.addAPI({
-            name: 'warn',
-            path: 'console.warn',
-            type: 'method',
-            returnType: 'void',
-            parameters: [{ name: 'message', type: 'any' }],
-            implementation: 'function(...args) { console.warn(...args); }',
-            antiCrawlImportance: 4,
-        });
-        this.addAPI({
-            name: 'error',
-            path: 'console.error',
-            type: 'method',
-            returnType: 'void',
-            parameters: [{ name: 'message', type: 'any' }],
-            implementation: 'function(...args) { console.error(...args); }',
-            antiCrawlImportance: 4,
-        });
-        this.addAPI({
-            name: 'XMLHttpRequest',
-            path: 'XMLHttpRequest',
-            type: 'constructor',
-            returnType: 'XMLHttpRequest',
-            description: 'XMLHttpRequest constructor',
-            antiCrawlImportance: 9,
-        });
-        this.addAPI({
-            name: 'fetch',
-            path: 'window.fetch',
-            type: 'method',
-            returnType: 'Promise<Response>',
-            parameters: [
-                { name: 'input', type: 'RequestInfo' },
-                { name: 'init', type: 'RequestInit', optional: true },
-            ],
-            implementation: 'function() { return Promise.reject(new Error("Not implemented")); }',
-            antiCrawlImportance: 8,
-        });
-        this.addAPI({
-            name: 'getItem',
-            path: 'localStorage.getItem',
-            type: 'method',
-            returnType: 'string | null',
-            parameters: [{ name: 'key', type: 'string' }],
-            implementation: 'function() { return null; }',
-            antiCrawlImportance: 7,
-        });
-        this.addAPI({
-            name: 'setItem',
-            path: 'localStorage.setItem',
-            type: 'method',
-            returnType: 'void',
-            parameters: [
-                { name: 'key', type: 'string' },
-                { name: 'value', type: 'string' },
-            ],
-            implementation: 'function() {}',
-            antiCrawlImportance: 7,
-        });
-    }
-    addAPI(api) {
-        this.apis.set(api.path, api);
-    }
-    getAPI(path) {
-        return this.apis.get(path);
-    }
-    getAllAPIs() {
-        return Array.from(this.apis.values());
-    }
-    getAPIsByType(type) {
-        return this.getAllAPIs().filter((api) => api.type === type);
-    }
-    searchAPIs(query) {
-        const lowerQuery = query.toLowerCase();
-        return this.getAllAPIs().filter((api) => api.name.toLowerCase().includes(lowerQuery) ||
-            api.path.toLowerCase().includes(lowerQuery) ||
-            api.description?.toLowerCase().includes(lowerQuery));
-    }
-    exportToJSON() {
-        return JSON.stringify(Array.from(this.apis.entries()), null, 2);
-    }
-    loadFromJSON(json) {
-        const data = JSON.parse(json);
-        this.apis = new Map(data);
-    }
-}

package/dist/src/modules/emulator/BrowserEnvironmentConfigHelpers.d.ts

@@ -1,5 +0,0 @@
-import type { BrowserType, BrowserConfig } from '../emulator/BrowserEnvironmentRules.js';
-export declare function createDefaultBrowserConfigs(): Map<BrowserType, BrowserConfig>;
-export declare function generateUserAgentFromConfig(browser: BrowserType, version: string, browserConfigs: Map<BrowserType, BrowserConfig>): string;
-export declare function getPlatformFromConfig(browser: BrowserType, browserConfigs: Map<BrowserType, BrowserConfig>): string;
-export declare function getVendorFromConfig(browser: BrowserType, browserConfigs: Map<BrowserType, BrowserConfig>): string;

package/dist/src/modules/emulator/BrowserEnvironmentConfigHelpers.js

@@ -1,51 +0,0 @@
-export function createDefaultBrowserConfigs() {
-    const configs = new Map();
-    configs.set('chrome', {
-        type: 'chrome',
-        version: '120.0.0.0',
-        userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-        platform: 'Win32',
-        vendor: 'Google Inc.',
-        language: 'zh-CN',
-        languages: ['zh-CN', 'zh', 'en-US', 'en'],
-        hardwareConcurrency: 8,
-        deviceMemory: 8,
-        maxTouchPoints: 0,
-        screenWidth: 1920,
-        screenHeight: 1080,
-        colorDepth: 24,
-        pixelRatio: 1,
-    });
-    configs.set('firefox', {
-        type: 'firefox',
-        version: '121.0',
-        userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0',
-        platform: 'Win32',
-        vendor: '',
-        language: 'zh-CN',
-        languages: ['zh-CN', 'zh', 'en-US', 'en'],
-        hardwareConcurrency: 8,
-        deviceMemory: 8,
-        maxTouchPoints: 0,
-        screenWidth: 1920,
-        screenHeight: 1080,
-        colorDepth: 24,
-        pixelRatio: 1,
-    });
-    return configs;
-}
-export function generateUserAgentFromConfig(browser, version, browserConfigs) {
-    const config = browserConfigs.get(browser);
-    if (config) {
-        return config.userAgent.replace(/\d+\.\d+\.\d+\.\d+/, version);
-    }
-    return '';
-}
-export function getPlatformFromConfig(browser, browserConfigs) {
-    const config = browserConfigs.get(browser);
-    return config?.platform || 'Win32';
-}
-export function getVendorFromConfig(browser, browserConfigs) {
-    const config = browserConfigs.get(browser);
-    return config?.vendor || '';
-}

package/dist/src/modules/emulator/BrowserEnvironmentRules.d.ts

@@ -1,44 +0,0 @@
-export type BrowserType = 'chrome' | 'firefox' | 'safari' | 'edge' | 'opera';
-export type EnvironmentCategory = 'window' | 'document' | 'navigator' | 'location' | 'screen' | 'performance' | 'console' | 'storage' | 'crypto' | 'other';
-type EnvironmentDefaultValueResolver = (browser: BrowserType, version: string) => unknown;
-export interface EnvironmentRule {
-    path: string;
-    category: EnvironmentCategory;
-    type: 'string' | 'number' | 'boolean' | 'object' | 'array' | 'function' | 'undefined' | 'null';
-    defaultValue?: unknown | EnvironmentDefaultValueResolver;
-    readonly?: boolean;
-    required?: boolean;
-    description?: string;
-    browsers?: BrowserType[];
-    minVersion?: Record<BrowserType, string>;
-    antiCrawlImportance?: number;
-}
-export interface BrowserConfig {
-    type: BrowserType;
-    version: string;
-    userAgent: string;
-    platform: string;
-    vendor: string;
-    language: string;
-    languages: string[];
-    hardwareConcurrency: number;
-    deviceMemory: number;
-    maxTouchPoints: number;
-    screenWidth: number;
-    screenHeight: number;
-    colorDepth: number;
-    pixelRatio: number;
-}
-export declare class BrowserEnvironmentRulesManager {
-    private rules;
-    private browserConfigs;
-    constructor();
-    private initializeDefaultRules;
-    addRule(rule: EnvironmentRule): void;
-    getRule(path: string): EnvironmentRule | undefined;
-    getAllRules(): EnvironmentRule[];
-    getRulesByCategory(category: EnvironmentCategory): EnvironmentRule[];
-    exportToJSON(): string;
-    loadFromJSON(json: string): void;
-}
-export {};