// ==UserScript== // @name ElementRaid Test // @namespace https://bbs.tampermonkey.net.cn/ // @version 0.0.5 // @description ElementRaid Test // @author EmpyrealTear // @match .*://.* // @require https://cdn.bootcdn.net/ajax/libs/jquery/3.7.1/jquery.min.js // @require https://scriptcat.org/lib/513/2.0.0/ElementGetter.js // require https://scriptcat.org/lib/2628/6.2.0.1/moduleRaid.js // @grant unsafeWindow // @grant GM_setValue // @grant GM_getValue // @grant GM_registerMenuCommand // @grant GM_unregisterMenuCommand // @run-at document-start // ==/UserScript== // const xhrOpen = XMLHttpRequest.prototype.open; // XMLHttpRequest.prototype.open = function () { // const xhr = this // // 是否显示默认被隐藏的卖价 // if (/logan[^\/]+\.js/.test(arguments[1])) { // console.log('-------------------------SUCCESS') // const getter = Object.getOwnPropertyDescriptor(XMLHttpRequest.prototype, "responseText").get // Object.defineProperty(xhr, "responseText", { // get: () => { // let result = getter.call(xhr) // console.log(result) // result = result.replace('window.webpackJpLogan20=window.webpackJpLogan20||[]', 'window.webpackJpLogan20=window.webpackJpLogan20||[], debugger') // debugger // return result // }, // }) // } // return xhrOpen.apply(xhr, arguments) // } // 监听所有网络请求 // const observer = new PerformanceObserver((list) => { // list.getEntries().forEach((entry) => { // if (entry.initiatorType === 'script' && /logan_[^\/]+\.js/.test(entry.name)) { // console.log('Script loaded:', entry.name); // // 检查加载状态 // if (entry.duration > 0) { // console.log('Script loaded successfully:', entry.name); // } else { // console.error('Script failed to load:', entry.name); // } // } // }); // }); // observer.observe({ entryTypes: ['resource'] }); // if ('serviceWorker' in navigator) { // navigator.serviceWorker.register('/logan_2.1.5.js') // .then((registration) => { // console.log('Service Worker 注册成功，作用范围:', registration.scope); // }) // .catch((error) => { // console.error('Service Worker 注册失败:', error); // }); // } // 开始观察网络请求 // const observer = new MutationObserver((mutationsList) => { // for (const mutation of mutationsList) { // if (mutation.type === 'childList') { // mutation.addedNodes.forEach((node) => { // if (node.tagName === 'SCRIPT' && /logan_[^\/]+\.js/.test(node.src)) { // console.log('Detected script tag with src:', node.src); // // 阻止原始脚本加载 // node.remove(); // // 使用 Fetch API 加载脚本 // fetch(node.src) // .then((response) => response.text()) // .then((scriptContent) => { // // console.log('Script loaded:', scriptContent); // // 动态执行脚本 // const newScript = document.createElement('script'); // newScript.textContent = scriptContent // .replace('window.webpackJpLogan20=window.webpackJpLogan20||[]', 'window.webpackJpLogan20=window.webpackJpLogan20||[],window.webpackJpLogan20.require=o'); // document.head.appendChild(newScript); // }) // .catch((error) => { // console.error('Failed to load script:', error); // }); // } // }); // } // } // }); // observer.observe(document.documentElement, { // childList: true, // subtree: true // }); // 劫持 document.createElement // const originalCreateElement = document.createElement; // document.createElement = function (tagName) { // if (tagName.toLowerCase() === 'script') { // const script = originalCreateElement.call(document, tagName); // // 劫持 src 属性 // let src = ''; // Object.defineProperty(script, 'src', { // get() { // return src; // }, // set(value) { // // 检查 src 是否以目标后缀结尾 // if (/logan_[^\/]+\.js/.test(value)) { // console.log('Detected script tag with src:', value); // // 使用 Fetch API 加载脚本 // fetch(value) // .then((response) => response.text()) // .then((scriptContent) => { // // console.log('Script loaded:', scriptContent); // // 动态执行脚本 // const newScript = document.createElement('script'); // newScript.textContent = scriptContent // .replace('window.webpackJpLogan20=window.webpackJpLogan20||[]', 'window.webpackJpLogan20=window.webpackJpLogan20||[],window.webpackJpLogan20.require=o'); // document.head.appendChild(newScript); // }) // .catch((error) => { // console.error('Failed to load script:', error); // }); // this.remove() // } else { // src = value // } // return true; // } // }); // return script; // } // return originalCreateElement.call(document, tagName); // }; /** * Main moduleRaid class */ class ModuleRaid { /** * moduleRaid constructor * * @example * Constructing an instance without any arguments: * ```ts * const mR = new ModuleRaid() * ``` * * Constructing an instance with the optional `opts` object: * ```ts * const mR = new ModuleRaid({ entrypoint: 'webpackChunk_custom_name' }) * ``` * * @param opts a object containing options to initialize moduleRaid with * - **opts:** * - _target_: the window object being searched for * - _entrypoint_: the Webpack entrypoint present on the global window object * - _debug_: whether debug mode is enabled or not * - _strict_: whether strict mode is enabled or not */ constructor(opts) { /** * A random generated module ID we use for injecting into Webpack */ this.moduleID = Math.random().toString(36).substring(7); /** * An array containing different argument injection methods for * Webpack (before version 4), and subsequently pulling out methods and modules * @internal */ this.functionArguments = [ [ [0], [ (_e, _t, i) => { this.modules = i.c; this.constructors = i.m; this.get = i; }, ], ], [ [1e3], { [this.moduleID]: (_e, _t, i) => { this.modules = i.c; this.constructors = i.m; this.get = i; }, }, [[this.moduleID]], ], ]; /** * An array containing different argument injection methods for * Webpack (after version 4), and subsequently pulling out methods and modules * @internal */ this.arrayArguments = [ // webpackJsonpCallback(chunkIds, executeModules, moreModules) this.functionArguments[1], // webpackJsonpCallback(chunkIds, moreModules, executeModules) [ [this.moduleID], {}, (e) => { const mCac = e.m; Object.keys(mCac).forEach((mod) => { try { this.modules[mod] = e(mod); } catch (err) { this.log(`[arrayArguments/1] Failed to require(${mod}) with error:\n${err}\n${err.stack}`); } }); this.get = e; }, ], ]; /** * Storage for the modules we extracted from Webpack */ this.modules = {}; /** * Storage for the constructors we extracted from Webpack */ this.constructors = []; let options = { target: window, entrypoint: 'webpackJsonp', debug: false, strict: false, }; if (typeof opts === 'object') { options = Object.assign(Object.assign({}, options), opts); } this.target = options.target this.entrypoint = options.entrypoint; this.debug = options.debug; this.strict = options.strict; this.detectEntrypoint(); this.fillModules(); this.replaceGet(); this.setupPushEvent(); } /** * Debug logging method, outputs to the console when {@link ModuleRaid.debug} is true * * @param {*} message The message to be logged * @internal */ log(message) { if (this.debug) { console.warn(`[moduleRaid] ${message}`); } } /** * Method to set an alternative getter if we weren't able to extract __webpack_require__ * from Webpack * @internal */ replaceGet() { if (this.get === null) { this.get = (key) => this.modules[key]; } } /** * Method that will try to inject a module into Webpack or get modules * depending on it's success it might be more or less brute about it * @internal */ fillModules() { if (typeof this.target[this.entrypoint] === 'function') { this.functionArguments.forEach((argument, index) => { try { if (this.modules && Object.keys(this.modules).length > 0) return; this.target[this.entrypoint](...argument); } catch (err) { this.log(`moduleRaid.functionArguments[${index}] failed:\n${err}\n${err.stack}`); } }); } else { this.arrayArguments.forEach((argument, index) => { try { if (this.modules && Object.keys(this.modules).length > 0) return; this.target[this.entrypoint].push(argument); } catch (err) { this.log(`Pushing moduleRaid.arrayArguments[${index}] into ${this.entrypoint} failed:\n${err}\n${err.stack}`); } }); } if (this.modules && Object.keys(this.modules).length == 0) { let moduleEnd = false; let moduleIterator = 0; if (typeof this.target[this.entrypoint] != 'function' || !this.target[this.entrypoint]([], [], [moduleIterator])) { throw Error('Unknown Webpack structure'); } while (!moduleEnd) { try { this.modules[moduleIterator] = this.target[this.entrypoint]([], [], [moduleIterator]); moduleIterator++; } catch (err) { moduleEnd = true; } } } } /** * Method to hook into `this.target[this.entrypoint].push` adding a listener for new * chunks being pushed into Webpack * * @example * You can listen for newly pushed packages using the `moduleraid:webpack-push` event * on `document` * * ```ts * document.addEventListener('moduleraid:webpack-push', (e) => { * // e.detail contains the arguments push() was called with * console.log(e.detail) * }) * ``` * @internal */ setupPushEvent() { const originalPush = this.target[this.entrypoint].push; this.target[this.entrypoint].push = (...args) => { const result = Reflect.apply(originalPush, this.target[this.entrypoint], args); document.dispatchEvent(new CustomEvent('moduleraid:webpack-push', { detail: args })); return result; }; } /** * Method to try autodetecting a Webpack JSONP entrypoint based on common naming * * If the default entrypoint, or the entrypoint that's passed to the moduleRaid constructor * already matches, the method exits early * * If `options.strict` has been set in the constructor and the initial entrypoint cannot * be found, this method will error, demanding a strictly set entrypoint * @internal */ detectEntrypoint() { if (this.target[this.entrypoint] != undefined) { return; } if (this.strict) { throw Error(`Strict mode is enabled and entrypoint at window.${this.entrypoint} couldn't be found. Please specify the correct one!`); } let windowObjects = Object.keys(this.target); windowObjects = windowObjects .filter((object) => object.toLowerCase().includes('chunk') || object.toLowerCase().includes('webpack')) .filter((object) => typeof this.target[object] === 'function' || Array.isArray(this.target[object])); if (windowObjects.length > 1) { throw Error(`Multiple possible endpoints have been detected, please create a new moduleRaid instance with a specific one:\n${windowObjects.join(', ')}`); } if (windowObjects.length === 0) { throw Error('No Webpack JSONP entrypoints could be detected'); } this.log(`Entrypoint has been detected at window.${windowObjects[0]} and set for injection`); this.entrypoint = windowObjects[0]; } /** * Recursive object-search function for modules * * @param object the object to search through * @param query the query the object keys/values are searched for * @returns boolean state of `object` containing `query` somewhere in it * @internal */ searchObject(object, query) { for (const key in object) { const value = object[key]; const lowerCaseQuery = query.toLowerCase(); if (typeof value != 'object') { const lowerCaseKey = key.toString().toLowerCase(); if (lowerCaseKey.includes(lowerCaseQuery)) return true; if (typeof value != 'object') { const lowerCaseValue = value.toString().toLowerCase(); if (lowerCaseValue.includes(lowerCaseQuery)) return true; } else { if (this.searchObject(value, query)) return true; } } } return false; } /** * Method to search through the module object, searching for the fitting content * if a string is supplied * * If query is supplied as a function, everything that returns true when passed * to the query function will be returned * * @example * With a string as query argument: * ```ts * const results = mR.findModule('feature') * // => Array of module results * ``` * * With a function as query argument: * ```ts * const results = mR.findModule((module) => { typeof module === 'function' }) * // => Array of module results * ``` * * @param query query to search the module list for * @return a list of modules fitting the query */ findModule(query) { const results = []; const modules = Object.keys(this.modules); if (modules.length === 0) { throw new Error('There are no modules to search through!'); } modules.forEach((key) => { const module = this.modules[key.toString()]; if (module === undefined) return; try { if (typeof query === 'string') { query = query.toLowerCase(); switch (typeof module) { case 'string': if (module.toLowerCase().includes(query)) results.push(module); break; case 'function': if (module.toString().toLowerCase().includes(query)) results.push(module); break; case 'object': if (this.searchObject(module, query)) results.push(module); break; } } else if (typeof query === 'function') { if (query(module)) results.push(module); } else { throw new TypeError(`findModule can only find via string and function, ${typeof query} was passed`); } } catch (err) { this.log(`There was an error while searching through module '${key}':\n${err}\n${err.stack}`); } }); return results; } /** * Method to search through the constructor array, searching for the fitting content * if a string is supplied * * If query is supplied as a function, everything that returns true when passed * to the query function will be returned * * @example * With a string as query argument: * ```ts * const results = mR.findConstructor('feature') * // => Array of constructor/module tuples * ``` * * With a function as query argument: * ```ts * const results = mR.findConstructor((constructor) => { constructor.prototype.value !== undefined }) * // => Array of constructor/module tuples * ``` * * Accessing the resulting data: * ```ts * // With array destructuring (ES6) * const [constructor, module] = results[0] * * // ...or... * * // regular access * const constructor = results[0][0] * const module = results[0][1] * ``` * * @param query query to search the constructor list for * @returns a list of constructor/module tuples fitting the query */ findConstructor(query) { const results = []; const constructors = Object.keys(this.constructors); if (constructors.length === 0) { throw new Error('There are no constructors to search through!'); } constructors.forEach((key) => { const constructor = this.constructors[key]; try { if (typeof query === 'string') { query = query.toLowerCase(); if (constructor.toString().toLowerCase().includes(query)) results.push([this.constructors[key], this.modules[key]]); } else if (typeof query === 'function') { if (query(constructor)) results.push([this.constructors[key], this.modules[key]]); } } catch (err) { this.log(`There was an error while searching through constructor '${key}':\n${err}\n${err.stack}`); } }); return results; } } class ElementRaid { constructor(opts) { let options = { target: document.body, // 目标 DOM 节点 entrypoint: '_', // DOM 节点内部实例的关键字 children: [], // 子节点 }; // 合并用户配置 if (typeof opts === 'object') { options = { ...options, ...opts }; } // 初始化属性 this.target = options.target; this.entrypoint = options.entrypoint; this.children = [...options.children]; } /** * 查找目标节点及其子节点中的 React 实例 * @param {HTMLElement} target - 目标 DOM 节点 * @returns {Array<HTMLElement>} - 包含 DOM 节点的列表 */ closest(target) { let queue = [target]; let children = []; while (queue.length > 0) { let cur = queue.pop(); let elmObjects = Object.keys(cur); elmObjects = elmObjects.filter((v) => v.includes(this.entrypoint)); if (elmObjects.length > 0) { children.push(cur); } else { queue.push(...cur.children); } } return children; } /** * 遍历 children 并返回符合筛选条件的子节点 * @param {Object|Function} filter - 筛选条件，可以是对象或函数 * @returns {Array<ElementRaid>} - 符合筛选条件的子节点列表 */ filterChildren(obj, filter) { // 如果 filter 是函数，则直接使用该函数进行筛选 if (typeof filter === 'function') { return obj.children.filter(filter); } // 如果 filter 是对象，则将其作为属性匹配条件 if (typeof filter === 'object' && filter !== null) { return obj.children.filter((child) => { // 检查 child 的属性是否与 filter 对象中的属性匹配 return Object.keys(filter).every((key) => { // 如果 filter 中的属性值是函数，则调用该函数进行匹配 if (typeof filter[key] === 'function') { return filter[key](child[key]); } // 否则直接比较属性值 return child[key] === filter[key]; }); }); } // 如果 filter 不是函数也不是对象，则返回空数组 return []; } /** * 遍历所有子节点并返回符合筛选条件的节点 * @param {Object|Function} filter - 筛选条件，可以是对象或函数 * @param {boolean} deep - 是否深度遍历所有子节点，默认为 false * @returns {Array<ElementRaid>} - 符合筛选条件的节点列表 */ filterAllChildren(filter, deep = false) { let queue = [...this.children] let matched = [] while (queue.length > 0) { if (matched.length > 0 && !deep) break let obj = queue.pop() let res = this.filterChildren(obj, filter) if (res.length > 0) { matched.push(...res) } if (obj.children.length > 0) { queue.push(...obj.children) } } return matched; } } class ReactRaid extends ElementRaid { constructor(opts) { let options = { target: document.body, // 目标 DOM 节点 entrypoint: 'react', // React 内部实例的关键字 children: [], // 子节点 }; // 合并用户配置 if (typeof opts === 'object') { options = { ...options, ...opts }; } super(options) // 如果未提供子节点，则从目标节点的子节点中查找 if (this.target.children.length > 0 && this.children.length == 0) { Array.from(this.target.children).forEach((v) => { this.children.push(...this.closest(v).map(v => new ReactRaid({ target: v }))); }); } // 获取 React 实例和父组件 this.instance = this.getInstance(this.target); this.parentComponent = this.findParent(this.instance); this.props = this.getProperties(this.target); this.events = this.getEvents(this.instance); } /** * 获取目标节点的 React 属性 * @param {HTMLElement} elm - 目标 DOM 节点 * @returns {Object} - React 属性 */ getProperties(elm) { let props = {}; // 遍历节点的属性，提取 React 相关属性 Object.keys(elm).forEach((key) => { if (key.includes(this.entrypoint)) { const propName = key .replace(/\$.+$/, '') // 去除后缀 .replace(/Listening.*$/, 'Listening'); // 处理事件监听器 props[propName] = elm[key]; } }); // 提取嵌套属性（如 props.children） if (elm._reactProps) { Object.assign(props, elm._reactProps); } return props; } /** * 获取目标节点的 React 实例 * @param {HTMLElement} elm - 目标 DOM 节点 * @returns {Object|null} - React 实例 */ getInstance(elm) { // 查找 React 15 或 React 16+ 的内部实例 const key = Object.keys(elm).find( (key) => key.startsWith('__reactInternalInstance$') || // React 15 key.startsWith('__reactFiber$') // React 16+ ); return key ? elm[key] : null; } /** * 获取 React 实例的父组件 * @param {Object} internalInstance - React 实例 * @returns {Object|null} - 父组件 */ findParent(internalInstance) { if (internalInstance == null) return null; // 兼容不同版本的 React return ( internalInstance._debugOwner ?? // React 16+ 开发模式 internalInstance.return ?? // React 16+ internalInstance._currentElement?._owner // React 15 ); } /** * 获取 React 实例的事件监听器 * @param {Object} internalInstance - React 实例 * @returns {Object|null} - 事件监听器 */ getEvents(internalInstance) { if (internalInstance == null) return null; // 提取事件监听器 const events = {}; Object.keys(internalInstance).forEach((key) => { if (key.includes('Listener') || key.includes('Handler')) { events[key] = internalInstance[key]; } }); // 提取嵌套事件（如 props.onClick） if (internalInstance.memoizedProps) { Object.keys(internalInstance.memoizedProps).forEach((key) => { if (key.startsWith('on') && typeof internalInstance.memoizedProps[key] === 'function') { events[key] = internalInstance.memoizedProps[key]; } }); } return events; } /** * 获取 React 组件的类型 * @param {Object} internalInstance - React 实例 * @returns {string|null} - 组件类型 */ getComponentType(internalInstance) { if (internalInstance == null) return null; // 从 Fiber 节点中提取组件类型 const type = internalInstance.type ?? internalInstance.elementType; if (typeof type === 'string') { // 宿主组件（如 div、span） return type; } else if (typeof type === 'function') { // 函数组件或类组件 return type.name || 'AnonymousComponent'; } else if (type?.$$typeof === Symbol.for('react.memo')) { // React.memo 组件 return type.type.name || 'MemoComponent'; } else if (type?.$$typeof === Symbol.for('react.forward_ref')) { // React.forwardRef 组件 return type.render.name || 'ForwardRefComponent'; } else { // 其他类型 return 'UnknownComponent'; } } } (function () { 'use strict'; unsafeWindow.jQuery = $; unsafeWindow.ModuleRaid = ModuleRaid; unsafeWindow.ReactRaid = ReactRaid; document.addEventListener("DOMContentLoaded", DOM_ContentReady); window.addEventListener("load", pageFullyLoaded); function DOM_ContentReady() { // 2ND PART OF SCRIPT RUN GOES HERE. // This is the equivalent of @run-at document-end console.log("==> 2nd part of script run.", new Date()); } function pageFullyLoaded() { console.log("==> Page is fully loaded, including images.", new Date()); } })();