对B站视频或评论进行屏蔽，支持关键词模糊正则等，支持时长播放弹幕过滤等，如视频、评论、动态、直播间的评论等，详情可看下面支持的屏蔽类型
// ==UserScript==
// @name 哔哩哔哩屏蔽增强器
// @namespace http://tampermonkey.net/
// @license Apache-2.0
// @version 2.2
// @author byhgz
// @description 对B站视频或评论进行屏蔽，支持关键词模糊正则等，支持时长播放弹幕过滤等，如视频、评论、动态、直播间的评论等，详情可看下面支持的屏蔽类型
// @icon https://static.hdslb.com/images/favicon.ico
// @noframes
// @grant GM_setValue
// @grant GM_getValue
// @grant GM_deleteValue
// @grant GM_addStyle
// @grant GM_unregisterMenuCommand
// @grant GM_registerMenuCommand
// @exclude *://message.bilibili.com/pages/nav/header_sync
// @exclude *://message.bilibili.com/pages/nav/index_new_pc_sync
// @exclude *://live.bilibili.com/blackboard/dropdown-menu.html
// @exclude *://live.bilibili.com/p/html/live-web-mng/*
// @exclude *://www.bilibili.com/correspond/*
// @match *://search.bilibili.com/*
// @match *://www.bilibili.com/v/food/*
// @match *://message.bilibili.com/*
// @match *://www.bilibili.com/read/*
// @match *://www.bilibili.com/v/topic/detail/?topic_id=*
// @match *://www.bilibili.com/v/kichiku/*
// @match *://t.bilibili.com/*
// @match *://space.bilibili.com/*
// @match *://www.bilibili.com/video/*
// @match *://live.bilibili.com/?spm_id_from=*
// @match *://live.bilibili.com/p/eden/area-tags?*
// @match *://live.bilibili.com/*
// @match *://www.bilibili.com/opus/*
// @match *://www.bilibili.com/*
// @require https://cdn.jsdelivr.net/npm/vue@2
// @require https://cdn.jsdelivr.net/npm/dexie@4.0.10/dist/dexie.min.js
// @require https://update.greasyfork.org/scripts/517928/gz_ui_css-v1.js
// @require https://update.greasyfork.org/scripts/521941/about_and_feedback_components.js
// @require https://greasyfork.org/scripts/462234-message/code/Message.js
// @require https://update.greasyfork.org/scripts/449512/Xtiper.js
// @require https://update.greasyfork.org/scripts/516282/Drawer_gz%E9%A1%B5%E9%9D%A2%E4%BE%A7%E8%BE%B9%E6%8A%BD%E5%B1%89%E7%BB%84%E4%BB%B6.js
// @require https://update.greasyfork.org/scripts/517538/DynamicTabs_gz.js
// ==/UserScript==
"use strict";
(function (Vue, Dexie) {
'use strict';
const start = () => {
let loop = false;
let msg;
if (!Vue) {
loop = true;
msg = 'Vue is not defined，Vue未定义，请检查是否引入了Vue';
}
if (!Dexie) {
loop = true;
msg = 'Dexie is not defined，Dexie未定义，请检查是否引入了Dexie';
}
if (loop) {
if (confirm('外部库验证失败:' + msg+`\n请联系作者核查问题\n可通过点击确定按钮跳转到脚本主页。
\n脚本主页信息中，有相关解决文档
\n或通过脚本信息底下联系方式联系作者解决`)) {
window.location.href = 'https://greasyfork.org/zh-CN/scripts/461382';
}
throw new Error(`外部库验证失败:${msg}`)
}
};
start();
var gmUtil = {
setData(key, content) {
GM_setValue(key, content);
},
getData(key, defaultValue) {
return GM_getValue(key, defaultValue);
},
delData(key) {
if (!this.isData(key)) {
return false;
}
GM_deleteValue(key);
return true;
},
isData(key) {
return this.getData(key) !== undefined;
},
addStyle(style) {
GM_addStyle(style);
},
addGMMenu(text, func, shortcutKey = null) {
return GM_registerMenuCommand(text, func, shortcutKey);
},
};
const setBorderColor = (color) => {
gmUtil.setData("borderColor", color);
};
const defBorderColor = "rgb(0, 243, 255)";
const getBorderColor = () => {
return gmUtil.getData("borderColor", defBorderColor)
};
const setOutputInformationFontColor = (color) => {
gmUtil.setData("output_information_font_color", color);
};
const defOutputInformationFontColor = "rgb(119,128,248)";
const getOutputInformationFontColor = () => {
return gmUtil.getData("output_information_font_color", defOutputInformationFontColor)
};
const setHighlightInformationColor = (color) => {
gmUtil.setData("highlight_information_color", color);
};
const defHighlightInformationColor = "rgb(234, 93, 93)";
const getHighlightInformationColor = () => {
return gmUtil.getData("highlight_information_color", defHighlightInformationColor);
};
const setDefaultColorInfo = () => {
setBorderColor(defBorderColor);
setOutputInformationFontColor(defOutputInformationFontColor);
setHighlightInformationColor(defHighlightInformationColor);
};
const setBOnlyTheHomepageIsBlocked = (bool) => {
gmUtil.setData("bOnlyTheHomepageIsBlocked", bool === true);
};
const getBOnlyTheHomepageIsBlocked = () => {
return gmUtil.getData("bOnlyTheHomepageIsBlocked", false);
};
const getAdaptationBAppCommerce = () => {
return gmUtil.getData("adaptation-b-app-recommend", false) === true;
};
const setAdaptationBAppCommerce = (bool) => {
gmUtil.setData("adaptation-b-app-recommend", bool === true);
};
const isHideMainButSwitch = () => {
return gmUtil.getData("hideMainButSwitch", false) === true;
};
const setHideMainButSwitch = (bool) => {
gmUtil.setData("hideMainButSwitch", bool === true);
};
const isHideRightTopMainButSwitch = () => {
return gmUtil.getData("hideRightTopMainButSwitch", true) === true;
};
const setHideRightTopMainButSwitch = (bool) => {
gmUtil.setData("hideRightTopMainButSwitch", bool === true);
};
const isCompatible_BEWLY_BEWLY = () => {
return gmUtil.getData("compatible_BEWLY_BEWLY", false) === true;
};
const setCompatible_BEWLY_BEWLY = (bool) => {
gmUtil.setData("compatible_BEWLY_BEWLY", bool === true);
};
const setDiscardOldCommentAreas = (bool) => {
gmUtil.setData("discardOldCommentAreas", bool === true);
};
const isDiscardOldCommentAreas = () => {
return gmUtil.getData("discardOldCommentAreas", false) === true;
};
var localMKData = {
setBorderColor,
getBorderColor,
setOutputInformationFontColor,
getOutputInformationFontColor,
setHighlightInformationColor,
getHighlightInformationColor,
setBOnlyTheHomepageIsBlocked,
getBOnlyTheHomepageIsBlocked,
getAdaptationBAppCommerce,
setAdaptationBAppCommerce,
setDefaultColorInfo,
isHideMainButSwitch,
setHideMainButSwitch,
isCompatible_BEWLY_BEWLY,
setCompatible_BEWLY_BEWLY,
setDiscardOldCommentAreas,
isDiscardOldCommentAreas,
isHideRightTopMainButSwitch,
setHideRightTopMainButSwitch
};
const mainDrawer = new Drawer_gz({
show: false,
height: "50vh",
headerShow: false,
title: "屏蔽器主面板",
direction: "top",
externalButtonText: "屏蔽器",
externalButtonWidth: "80px",
externalButtonShow: !localMKData.isHideMainButSwitch(),
zIndex: 9000,
drawerBorder: `1px solid ${localMKData.getBorderColor()}`,
bodyHtml: `<div id="shield"></div>`,
});
const options = {
styles: `
.my-custom-tab-button {
font-size: 16px;
}
.my-custom-tab-content {
background-color: #f9f9f9;
}
`,
classes: {
tabButton: 'my-custom-tab-button',
tabButtonActive: 'my-custom-tab-button-active',
tabContent: 'my-custom-tab-content',
tabContentActive: 'my-custom-tab-content-active'
},
backgroundColor: '#eee',
borderColor: '#ddd',
textColor: '#333',
fontWeight: 'bold',
activeBackgroundColor: '#0056b3',
activeTextColor: '#fff',
contentBorderColor: '#bbb',
contentBackgroundColor: '#ffffff',
onTabClick: (id, title, content) => {
const tab = tabsConfig.find(item => item.title === title);
const height = tab.height;
mainDrawer.setHeight(height ? height : '50vh');
},
};
const tabsConfig = [
{
id: 'tab01',
title: '面板设置',
content: '<div id="panel_settings_vue"></div>',
height: "25vh",
},
{
id: 'tab02',
title: '规则管理',
content: '<div id="rule_management_vue"></div>',
height: "96vh"
},
{
id: 'tab03',
title: '其他参数过滤',
content: `<div id="other_parameter_filter"></div>`,
height: '60vh'
},
{
id:'id04',
title: '兼容设置',
content: `<div id="compatible_setting"></div>`,
},
{
id: 'tab05',
title: '缓存tags管理',
content: '<div id="cache_tags_management_vue"></div>',
},
{
id: 'tab06',
title: '输出信息',
content: `<div id="output_information">
<button gz_type>清空消息</button>
<ol class="info">
</ol>
</div>`,
height: "96vh"
},
{
id: 'tab07',
title: '支持打赏',
content: '<div id="station_b_shield_donate"></div>',
height: "80vh"
},
{
id: 'tab08',
title: '关于和问题反馈',
content: `<div id="station_b_shield_problem_feedback"></div>`,
height: '53vh'
}
];
new DynamicTabs_gz('#shield', tabsConfig,
options
);
class EventEmitter {
constructor() {
this.events = {};
this.handlers = {};
}
on(eventName, callback) {
if (!this.events[eventName]) {
this.events[eventName] = [];
}
this.events[eventName].push(callback);
}
once(eventName, callback) {
const onceCallback = (...args) => {
callback(...args);
this.off(eventName, onceCallback);
};
this.on(eventName, onceCallback);
}
emit(eventName, data) {
if (!this.events[eventName]) {
throw new Error(`没有为注册的事件侦听器 "${eventName}"`);
}
this.events[eventName].forEach(callback => {
try {
callback(data);
} catch (error) {
console.error(`事件侦听器中发生错误 "${eventName}":`, error);
}
});
}
off(eventName, callback) {
if (this.events[eventName]) {
this.events[eventName] = this.events[eventName].filter(cb => cb !== callback);
}
}
removeAllListeners(eventName) {
if (eventName) {
delete this.events[eventName];
delete this.handlers[eventName];
} else {
this.events = {};
this.handlers = {};
}
}
listenerCount(eventName) {
return this.events[eventName] ? this.events[eventName].length : 0;
}
handle(eventName, handler) {
this.handlers[eventName] = handler;
}
invoke(eventName, data) {
if (this.handlers[eventName]) {
return this.handlers[eventName](data);
}
return null;
}
}
const eventEmitter = new EventEmitter();
const returnVue$5 = () => {
return new Vue({
template: `
<div>
<div>
选色器:<input type="color" v-model="input_color">
</div>
<button gz_type @click="setBorderColorBut">设置边框色</button>
<button gz_type @click="setDefFontColorForOutputInformationBut">设置输出信息默认字体色</button>
<button gz_type @click="setTheFontColorForOutputInformationBut">设置输出信息高亮字体色</button>
<button title="刷新页面生效" gz_type @click="setDefInfoBut">恢复默认</button>
<div gz_bezel>
<div>
<label>
<input type="checkbox" v-model="hideMainButSwitch">隐藏主面板开关按钮
</label>
</div>
<div>
<label>
<input type="checkbox" v-model="hideRightTopMainButSwitch">隐藏右上角圆形主面板开关按钮
</label>
</div>
</div>
<hr>
<div>
<h4>说明</h4>
<ol>
<li>按键盘tab键上的~键为展开关闭主面板</li>
</ol>
</div>
</div>`,
el: '#shield #panel_settings_vue',
data() {
return {
input_color: "",
hideMainButSwitch: localMKData.isHideMainButSwitch(),
hideRightTopMainButSwitch: localMKData.isHideRightTopMainButSwitch()
}
},
methods: {
setBorderColorBut() {
xtip.confirm("是要否设置面板边框颜色吗？", {
icon: "a",
btn1: () => {
localMKData.setBorderColor(this.input_color);
xtip.alert("已设置面板边框颜色，刷新生效");
}
});
},
setDefFontColorForOutputInformationBut() {
xtip.confirm("是要否设置输出信息默认字体颜色吗？", {
icon: "a",
btn1: () => {
localMKData.setOutputInformationFontColor(this.input_color);
xtip.alert("已设置输出信息默认字体颜色，刷新生效");
}
});
},
setTheFontColorForOutputInformationBut() {
xtip.confirm("是要否设置输出信息高亮字体颜色吗？", {
icon: "a",
btn1: () => {
localMKData.setHighlightInformationColor(this.input_color);
xtip.alert("已设置输出信息高亮字体颜色，刷新生效");
}
});
},
setDefInfoBut() {
localMKData.setDefaultColorInfo();
xtip.alert("已恢复默认颜色，刷新生效");
}
},
watch: {
hideMainButSwitch(newVal) {
localMKData.setHideMainButSwitch(newVal);
mainDrawer.externalButtonShow(!newVal);
},
hideRightTopMainButSwitch(newVal) {
localMKData.setHideRightTopMainButSwitch(newVal);
eventEmitter.emit('右上角开关按钮显隐', newVal);
}
}
});
};
const wait = (milliseconds = 1000) => {
return new Promise(resolve => setTimeout(resolve, milliseconds));
};
const fileDownload = (content, fileName) => {
const element = document.createElement('a');
element.setAttribute('href', 'data:text/plain;charset=utf-8,' + encodeURIComponent(content));
element.setAttribute('download', fileName);
element.style.display = 'none';
document.body.appendChild(element);
element.click();
document.body.removeChild(element);
};
const handleFileReader = (event) => {
return new Promise((resolve, reject) => {
const file = event.target.files[0];
if (!file) {
reject('未读取到文件');
return;
}
let reader = new FileReader();
reader.onload = (e) => {
const fileContent = e.target.result;
resolve({file, content: fileContent});
reader = null;
};
reader.readAsText(file);
});
};
const isIterable = (obj) => {
return obj != null && typeof obj[Symbol.iterator] === 'function';
};
const toTimeString = () => {
return new Date().toLocaleString();
};
function smoothScroll(toTop = false, duration = 1000) {
return new Promise((resolve) => {
const start = window.scrollY;
const end = toTop ? 0 : document.documentElement.scrollHeight - window.innerHeight;
const change = end - start;
const startTime = performance.now();
function animateScroll(currentTime) {
const elapsedTime = currentTime - startTime;
const progress = Math.min(elapsedTime / duration, 1);
const easeInOutQuad = progress < 0.5 ? 2 * progress * progress : -1 + (4 - 2 * progress) * progress;
window.scrollTo(0, start + change * easeInOutQuad);
if (progress < 1) {
requestAnimationFrame(animateScroll);
} else {
resolve();
}
}
requestAnimationFrame(animateScroll);
});
}
function debounce(func, wait = 1000) {
let timeout;
return function (...args) {
const context = this;
clearTimeout(timeout);
timeout = setTimeout(() => func.apply(context, args), wait);
};
}
function debounceAsync(asyncFunc, wait = 1000) {
let timeout;
let pendingPromise;
return async function (...args) {
const context = this;
if (pendingPromise) {
clearTimeout(timeout);
await pendingPromise;
}
pendingPromise = new Promise((resolve) => {
timeout = setTimeout(() => {
pendingPromise = null; // 清除引用
resolve(asyncFunc.apply(context, args));
}, wait);
});
return pendingPromise;
};
}
function throttle(func, limit) {
let inThrottle;
return function (...args) {
const context = this;
if (!inThrottle) {
func.apply(context, args);
inThrottle = true;
setTimeout(() => inThrottle = false, limit);
}
};
}
function throttleAsync(asyncFunc, limit) {
let isThrottled = false;
let pendingArgs = null;
let pendingContext = null;
let timeoutId;
let pendingPromiseResolve;
const throttled = async function (...args) {
const context = this;
if (isThrottled) {
return new Promise((resolve) => {
pendingArgs = args;
pendingContext = context;
pendingPromiseResolve = resolve;
});
}
isThrottled = true;
try {
return await asyncFunc.apply(context, args);
} finally {
timeoutId = setTimeout(() => {
isThrottled = false;
if (pendingArgs) {
throttled.apply(pendingContext, pendingArgs).then(pendingPromiseResolve);
pendingArgs = null;
pendingContext = null;
pendingPromiseResolve = null;
}
}, limit);
}
};
throttled.cancel = () => {
clearTimeout(timeoutId);
isThrottled = false;
pendingArgs = null;
pendingContext = null;
pendingPromiseResolve = null;
};
return throttled;
}
const parseUrl = (urlString) => {
const url = new URL(urlString);
const pathSegments = url.pathname.split('/').filter(segment => segment !== '');
const searchParams = new URLSearchParams(url.search.slice(1));
const queryParams = {};
for (const [key, value] of searchParams.entries()) {
queryParams[key] = value;
}
return {
protocol: url.protocol,
hostname: url.hostname,
port: url.port,
pathname: url.pathname,
pathSegments,
search: url.search,
queryParams,
hash: url.hash
};
};
const getLocalStorage = (key, isList = false, defaultValue = null) => {
const item = localStorage.getItem(key);
if (item === null) {
return defaultValue
}
if (isList) {
try {
return JSON.parse(item)
} catch (e) {
console.error(`读取localStorage时尝试转换${key}的值失败`, e);
return defaultValue
}
}
return item
};
var defUtil = {
wait,
fileDownload,
toTimeString,
smoothScroll,
debounce,
debounceAsync,
throttle,
throttleAsync,
parseUrl,
handleFileReader,
isIterable,
getLocalStorage
};
const ruleKeyListData = [
{
key: "name",
name: "用户名黑名单(模糊匹配)",
oldKey: "userNameKeyArr",
oldName: "用户名黑名单模式(模糊匹配)"
},
{
key: "precise_name",
name: "用户名黑名单(精确匹配)",
oldKey: "userNameArr",
oldName: "用户名黑名单模式(精确匹配)"
}, {
key: "nameCanonical",
name: "用户名黑名单(正则匹配)"
},
{
key: "precise_uid",
name: "用户uid黑名单(精确匹配)",
oldKey: "userUIDArr",
oldName: "用户uid黑名单模式(精确匹配)"
},
{
key: "precise_uid_white",
name: "用户uid白名单(精确匹配)",
oldKey: "userWhiteUIDArr",
oldName: "用户uid白名单模式(精确匹配)"
}, {
key: "title",
name: "标题黑名单(模糊匹配)",
oldKey: "titleKeyArr",
oldName: "标题黑名单模式(模糊匹配)"
}, {
key: "titleCanonical",
name: "标题黑名单(正则匹配)",
oldKey: "titleKeyCanonicalArr",
oldName: "标题黑名单模式(正则匹配)"
}, {
key: "commentOn",
name: "评论关键词黑名单(模糊匹配)",
oldKey: "commentOnKeyArr",
oldName: "评论关键词黑名单模式(模糊匹配)"
}, {
key: "commentOnCanonical",
name: "评论关键词黑名单(正则匹配)",
oldKey: "contentOnKeyCanonicalArr",
oldName: "评论关键词黑名单模式(正则匹配)"
}, {
key: "contentOn",
name: "评论内容黑名单(模糊匹配)",
oldKey: "contentOnKeyArr",
oldName: "评论内容黑名单模式(模糊匹配)"
}, {
key: "precise_fanCard",
name: "粉丝牌黑名单(精确匹配)",
oldKey: "fanCardArr",
oldName: "粉丝牌黑名单模式(精确匹配)"
}, {
key: "dynamic",
name: "动态关键词黑名单(模糊匹配)",
oldKey: "dynamicArr",
oldName: "动态关键词内容黑名单模式(模糊匹配)"
}, {
key: "precise_tag",
name: "话题tag标签黑名单(精确匹配)",
}
, {
key: "tag",
name: "话题tag标签黑名单(模糊匹配)",
}, {
key: "tagCanonical",
name: "话题tag标签黑名单(正则匹配)"
}, {
key: "precise_partition",
name: "直播分区黑名单(精确匹配)"
}, {
key: 'videoTag',
name: '视频tag黑名单(模糊匹配)',
}, {
key: 'precise_videoTag',
name: '视频tag黑名单(精确匹配)',
}, {
key: 'videoTagCanonical',
name: '视频tag黑名单(正则匹配)',
}
];
const getRuleKeyListData = () => {
return ruleKeyListData;
};
const getNameArr = () => {
return gmUtil.getData("name", []);
};
const getPreciseNameArr = () => {
return gmUtil.getData("precise_name", []);
};
const getNameCanonical = () => {
return gmUtil.getData("nameCanonical", []);
};
const getPreciseUidArr = () => {
return gmUtil.getData("precise_uid", []);
};
const getPreciseUidWhiteArr = () => {
return gmUtil.getData("precise_uid_white", []);
};
const getTitleArr = () => {
return gmUtil.getData("title", []);
};
const getTitleCanonicalArr = () => {
return gmUtil.getData("titleCanonical", []);
};
const getCommentOnArr = () => {
return gmUtil.getData("commentOn", []);
};
const getCommentOnCanonicalArr = () => {
return gmUtil.getData("commentOnCanonical", []);
};
const getPreciseTagArr = () => {
return gmUtil.getData("precise_tag", []);
};
const getTagArr = () => {
return gmUtil.getData("tag", []);
};
const getTagCanonicalArr = () => {
return gmUtil.getData("tagCanonical", []);
};
const getPreciseFanCardArr = () => {
return gmUtil.getData("precise_fanCard", []);
};
const getPrecisePartitionArr = () => {
return gmUtil.getData("precise_partition", []);
};
const getVideoTagArr = () => {
return gmUtil.getData("videoTag", []);
};
const getPreciseVideoTagArr = () => {
return gmUtil.getData("precise_videoTag", []);
};
const getVideoTagCanonicalArr = () => {
return gmUtil.getData("videoTagCanonical", []);
};
var ruleKeyListData$1 = {
getNameArr,
getPreciseNameArr,
getNameCanonical,
getPreciseUidArr,
getPreciseUidWhiteArr,
getTitleArr,
getTitleCanonicalArr,
getCommentOnArr,
getCommentOnCanonicalArr,
getRuleKeyListData,
getPreciseTagArr,
getTagArr,
getTagCanonicalArr,
getPreciseFanCardArr,
getPrecisePartitionArr,
getVideoTagArr,
getPreciseVideoTagArr,
getVideoTagCanonicalArr
};
const verificationInputValue = (ruleValue, type) => {
if (ruleValue === null) return null;
if (type === "precise_uid" || type === "precise_uid_white") {
ruleValue = parseInt(ruleValue);
if (isNaN(ruleValue)) {
Qmsg.info('请输入数字!');
return null;
}
} else {
ruleValue.trim();
}
if (ruleValue === '') {
Qmsg.info('内容为空');
return null;
}
return ruleValue;
};
const addRule = (ruleValue, type) => {
const inputValue = verificationInputValue(ruleValue, type);
return new Promise((resolve, reject) => {
if (inputValue === null) {
reject('取消添加');
return;
}
const arr = gmUtil.getData(type, []);
if (arr.includes(inputValue)) {
reject('已存在此内容');
return;
}
arr.push(inputValue);
gmUtil.setData(type, arr);
resolve('添加成功');
}
)
};
const showAddRuleInput = (type) => {
const ruleValue = window.prompt('请输入要添加的规则内容', '');
return addRule(ruleValue, type);
};
const showDelRuleInput = (type) => {
let prompt = window.prompt('请输入要移除的规则内容', '');
const inputValue = verificationInputValue(prompt, type);
return new Promise((resolve, reject) => {
if (inputValue === null) {
reject('取消添加');
return;
}
const arr = gmUtil.getData(type, []);
const indexOf = arr.indexOf(inputValue);
if (indexOf === -1) {
reject('不存在此内容');
return;
}
arr.splice(indexOf, 1);
gmUtil.setData(type, arr);
resolve('移除成功');
})
};
const showSetRuleInput = (type) => {
let prompt = window.prompt('请输入要修改的规则内容', '');
const inputValue = verificationInputValue(prompt, type);
return new Promise((resolve, reject) => {
if (inputValue === null) return;
const arr = gmUtil.getData(type, []);
const indexOf = arr.indexOf(inputValue);
if (indexOf === -1) {
reject('不存在此内容');
return;
}
prompt = window.prompt('请输入要修改的内容', '');
const newInputValue = verificationInputValue(prompt, type);
if (newInputValue === null) return;
if (arr.includes(newInputValue)) {
reject('已存在要修改过后的值内容');
return;
}
arr[indexOf] = newInputValue;
gmUtil.setData(type, arr);
resolve('修改成功');
})
};
const getRuleContent = (space = 0) => {
const ruleMap = {};
for (let ruleKeyListDatum of ruleKeyListData$1.getRuleKeyListData()) {
const key = ruleKeyListDatum.key;
ruleMap[key] = gmUtil.getData(key, []);
}
return JSON.stringify(ruleMap, null, space);
};
const verificationRuleMap = (keyArr, content) => {
let parse;
try {
parse = JSON.parse(content);
} catch (e) {
alert('规则内容有误');
return false;
}
const newRule = {};
for (let key of keyArr) {
if (!Array.isArray(parse[key])) {
continue;
}
if (parse[key].length === 0) {
continue;
}
newRule[key] = parse[key];
}
if (Object.keys(newRule).length === 0) {
alert('规则内容为空');
return false;
}
return newRule;
};
const overwriteImportRules = (keyArr, content) => {
const map = verificationRuleMap(keyArr, content);
if (map === false) return false;
for (let key of Object.keys(map)) {
gmUtil.setData(key, map[key]);
}
return true;
};
const appendImportRules = (keyArr, content) => {
const map = verificationRuleMap(keyArr, content);
if (map === false) return false;
for (let key of Object.keys(map)) {
const arr = gmUtil.getData(key, []);
for (let item of map[key]) {
if (!arr.includes(item)) {
arr.push(item);
}
}
gmUtil.setData(key, arr);
}
return true;
};
const getNewRuleKeyList = () => {
return ruleKeyListData$1.getRuleKeyListData();
};
const overwriteImportRulesV1 = (content) => {
let parse;
try {
parse = JSON.parse(content);
} catch (e) {
alert('规则内容有误');
return false;
}
for (let ruleKeyListDatum of ruleKeyListData$1.getRuleKeyListData()) {
const name = ruleKeyListDatum.oldName;
const jsonRuleList = parse[name];
if (!jsonRuleList) {
continue;
}
if (jsonRuleList.length === 0) {
continue;
}
gmUtil.setData(ruleKeyListDatum.key, jsonRuleList);
}
return true;
};
const addRulePreciseUid = (uid) => {
return addRule(uid, "precise_uid").then(msg => {
xtip.msg(msg, {icon: 's'});
}).catch(msg => {
xtip.msg(msg, {icon: 'e'});
})
};
const addRulePreciseName= (name) => {
return addRule(name, "precise_name").then(msg => {
xtip.msg(msg, {icon: 's'});
}).catch(msg => {
xtip.msg(msg, {icon: 'e'});
})
};
var ruleUtil = {
addRule,
showAddRuleInput,
showDelRuleInput,
showSetRuleInput,
getRuleContent,
overwriteImportRules,
appendImportRules,
overwriteImportRulesV1,
getNewRuleKeyList,
addRulePreciseUid,
addRulePreciseName
};
const oldToNewRule = () => {
const listData = ruleKeyListData$1.getRuleKeyListData().filter(item => item.oldKey);
for (let data of listData) {
const oldKeyDataArr = gmUtil.getData(data.oldKey, []);
if (oldKeyDataArr.length === 0) {
continue
}
const newKeyDataArr = gmUtil.getData(data.key, []);
if (newKeyDataArr.length === 0) {
gmUtil.setData(data.key, oldKeyDataArr);
gmUtil.delData(data.oldKey);
continue
}
for (let v of oldKeyDataArr) {
const isExist = newKeyDataArr.find(item => item === v);
if (!isExist) {
newKeyDataArr.push(v);
}
}
gmUtil.setData(data.key, newKeyDataArr);
}
};
var ruleConversion = {
oldToNewRule
};
const returnVue$4 = () => {
return new Vue({
template: `
<div style="display: flex">
<div style="width: 84%;" gz_bezel>
<h4>使用说明</h4>
<ol>
<li>脚本中会对要匹配的内容进行去除空格和转成小写，比如有个内容是【不 要 笑 挑 战
ChallEnGE】，会被识别称为【不要笑挑战challenge】
</li>
<li>在上述一点的情况下，模糊匹配和正则匹配的方式时不用考虑要匹配的内容中大写问题</li>
<li>大部分情况下模糊匹配比精确匹配好用</li>
<li>如果用户要添加自己的正则匹配相关的规则时，建议先去该网址进行测试再添加，避免浪费时间
<a href="https://www.jyshare.com/front-end/854/" target="_blank">>>>正则表达式在线测试<<<</a>
</li>
<li>
如果更新脚本之后规则全吗，没了请点击下面的【旧规则自动转新规则】按钮，进行转换，如不行请通过关于和问题反馈选项卡中的反馈渠道联系作者
</li>
</ol>
<div>
<!-- <h3>指定类型批量添加</h3>-->
<!-- <span>指定类型批量添加，每个规则空格分割</span>-->
<!-- <textarea-->
<!-- style="width: 100%"-->
<!-- cols="30" rows="5" placeholder="匹配添加内容时规则内容" v-model="inputVal"/>-->
</div>
<div>
<label>
<input type="checkbox" v-model="bOnlyTheHomepageIsBlocked">仅首页屏蔽生效屏蔽
</label>
</div>
<div>
<select v-model="selectVal">
<option v-for="item in ruleInfoArr" :value="item.type">{{ item.name }}</option>
</select>
《====可点击切换条件
</div>
<button gz_type @click="operationBut('add')">添加{{ selectText }}</button>
<button gz_type @click="operationBut('del')">移除{{ selectText }}</button>
<button gz_type @click="operationBut('set')">修改{{ selectText }}</button>
<button gz_type="info" @click="operationBut('del_all')">全部移除</button>
<div>
<h2>导出规则</h2>
<button gz_type @click="ruleOutToFIleBut">导出到文件</button>
<button gz_type @click="outToInputBut">导出到编辑框</button>
<button gz_type @click="ruleOutToConsoleBut">导出到控制台</button>
</div>
<hr>
<div>
<h2>导入规则</h2>
<div style="display: flex;justify-content:space-between;">
<ol>
<li>规则内容请在下面编辑框中导入</li>
<li>旧版本的需要使用下面的v1旧版本导入规则</li>
<li>旧版本的只能覆盖导入</li>
<li>v1之后的版本可以选择覆盖和追加</li>
<li>旧规则转新规则，用于2.0之前版本升上来旧规则内容丢失问题</li>
</ol>
<ol>
<li v-for="item in ruleReference">
<button gz_type='info' @click="xtipAlertBut(item.content,item.title)">
{{ item.title }}
</button>
</li>
</ol>
</div>
<input ref="file" type="file" accept="application/json" @change="handleFileUpload" style="display: none">
<button gz_type @click="inputFIleRuleBut">读取外部规则文件</button>
<button gz_type @click="overwriteImportRulesBut">覆盖导入规则</button>
<button gz_type @click="appendImportRulesBut">追加导入规则</button>
<button gz_type @click="overwriteImportRulesV1But">v1旧版本覆盖导入规则</button>
<button gz_type @click="ruleOldToNewBut">旧规则自动转新规则</button>
<div>
<textarea cols="30" rows="10" placeholder="要导入的规则内容" style="width: 100%"
v-model="ruleContentImport"></textarea>
</div>
</div>
</div>
<div style="width: 15%;" gz_bezel>
<h2>规则信息</h2>
<button gz_type @click="refreshInfoBut">刷新信息</button>
<div v-for="item in ruleInfoArr"
style="padding: 5px">
{{ item.name }}{{ item.len }}个
</div>
</div>
</div>`,
el: '#shield #rule_management_vue',
data() {
return {
selectVal: 'name',
selectText: "",
ruleContentImport: "",
ruleActions: [
{
type: "uid",
name: "uid(精确)",
}
],
ruleKeyArr: [],
ruleInfoArr: [],
ruleReference: [
{
title: "旧版本规则参考",
content: ` {"用户名黑名单模式(精确匹配)":["账号已注销"],"BV号黑名单模式(精确匹配)":[],
"用户名黑名单模式(模糊匹配)":["bili_","_bili"],"用户uid黑名单模式(精确匹配)":[442010132,76525078,225219967,3493283164588093],
"用户uid白名单模式(精确匹配)":[344490740,1861980711],"标题黑名单模式(模糊匹配)":["激励计划","蚌不住","手游激励","游戏活动打卡"],
"标题黑名单模式(正则匹配)":["感觉.*不如","不要笑.*挑战"],"评论关键词黑名单模式(模糊匹配)":["感觉不如","差不多的了"],
"评论关键词黑名单模式(正则匹配)":["这不.+吗","玩.*的","不要笑.*挑战"],"粉丝牌黑名单模式(精确匹配)":[],
"专栏关键词内容黑名单模式(模糊匹配)":[],"动态关键词内容黑名单模式(模糊匹配)":["拼多多","京东红包","京东618红包","618活动"]}`
},
{
title: "新版本规则参考",
content: "待补充"
}
],
bOnlyTheHomepageIsBlocked: localMKData.getBOnlyTheHomepageIsBlocked()
}
},
methods: {
operationBut(model) {
const type = this.selectVal;
if (model === "add") {
ruleUtil.showAddRuleInput(type).then((msg) => {
this.refreshInfoBut();
alert(msg);
}).catch(errMsg => {
Qmsg.info(errMsg);
});
}
if (model === "del") {
ruleUtil.showDelRuleInput(type).then((msg) => {
this.refreshInfoBut();
alert(msg);
}).catch(errMsg => {
Qmsg.info(errMsg);
});
}
if (model === "set") {
ruleUtil.showSetRuleInput(type).then((msg) => {
this.refreshInfoBut();
alert(msg);
}).catch(errMsg => {
Qmsg.info(errMsg);
});
}
if (model === "del_all") {
if (!window.confirm("确定要删除所有规则吗？")) {
Qmsg.info('取消删除全部操作');
return;
}
for (let x of this.ruleKeyArr) {
gmUtil.delData(x);
}
alert("删除全部规则成功");
this.refreshInfoBut();
}
},
ruleOutToFIleBut() {
const ruleContent = ruleUtil.getRuleContent(4);
let fileName = "b站屏蔽器规则-" + defUtil.toTimeString();
const s = prompt("保存为", fileName);
if (s === null) return;
if (!(s.includes(" ") || s === "" || s.length === 0)) fileName = s;
defUtil.fileDownload(ruleContent, fileName + ".json");
},
ruleOutToConsoleBut() {
xtip.msg('已导出到控制台上！', {icon: 's'});
console.log(ruleUtil.getRuleContent());
},
refreshInfoBut() {
for (let x of this.ruleInfoArr) {
x.len = gmUtil.getData(x.type, []).length;
}
Qmsg.info('已刷新规则信息');
},
overwriteImportRulesBut() {
xtip.confirm('是否要覆盖导入规则？', {
icon: 'a',
btn1: () => {
const trim = this.ruleContentImport.trim();
if (ruleUtil.overwriteImportRules(this.ruleKeyArr, trim)) {
xtip.msg('已覆盖导入成功！', {icon: 's'});
this.refreshInfoBut();
}
}
});
},
appendImportRulesBut() {
xtip.confirm('是否要追加导入规则？', {
icon: 'a',
btn1: () => {
const trim = this.ruleContentImport.trim();
if (ruleUtil.appendImportRules(this.ruleKeyArr, trim)) {
xtip.msg('已追加导入成功！', {icon: 's'});
this.refreshInfoBut();
}
}
});
},
overwriteImportRulesV1But() {
xtip.confirm('旧版本-是否导入规则？', {
icon: 'a',
btn1: () => {
const trim = this.ruleContentImport.trim();
if (ruleUtil.overwriteImportRulesV1(trim)) {
xtip.msg('已导入成功！', {icon: 's'});
this.refreshInfoBut();
}
}
});
},
xtipAlertBut(content, title) {
xtip.alert(content,
{title: title});
},
ruleOldToNewBut() {
ruleConversion.oldToNewRule();
this.refreshInfoBut();
xtip.msg('已转换成功！', {icon: 's'});
},
outToInputBut() {
this.ruleContentImport = ruleUtil.getRuleContent(2);
xtip.msg('已导出到输入框！', {icon: 's'});
},
handleFileUpload(event) {
defUtil.handleFileReader(event).then(data => {
const {content} = data;
try {
JSON.parse(content);
} catch (e) {
xtip.msg('文件内容有误', {icon: 'e'});
return;
}
this.ruleContentImport = content;
xtip.msg('读取到内容，请按需覆盖或追加', {icon: 's'});
});
},
inputFIleRuleBut() {
this.$refs.file.click();
}
},
watch: {
bOnlyTheHomepageIsBlocked(newVal) {
localMKData.setBOnlyTheHomepageIsBlocked(newVal);
},
selectVal(newVal) {
console.log(newVal);
const find = this.ruleInfoArr.find(item => item.type === newVal);
this.selectText = find.name;
}
},
created() {
for (let newRuleKeyListElement of ruleUtil.getNewRuleKeyList()) {
this.ruleKeyArr.push(newRuleKeyListElement.key);
this.ruleInfoArr.push({
type: newRuleKeyListElement.key,
name: newRuleKeyListElement.name,
len: 0
});
}
const find = this.ruleInfoArr.find(item => item.type === this.selectVal);
this.selectText = find.name;
this.refreshInfoBut();
}
});
};
const returnVue$3 = () => {
return new Vue({
el: "#station_b_shield_donate",
template: `<div>
<div style="border: 3px solid #000;">
<div style="display: flex;align-items: center;">
<h2>零钱赞助</h2>
<ul>
<li>1元不嫌少，10元不嫌多哦！感谢支持！</li>
<li>生活不易，作者叹息</li>
<li>您的支持是我最大的更新动力</li>
</ul>
</div>
<hr>
<div style="display: flex;justify-content: center;">
<div v-for="item in list" :title="item.name"><img :src="item.src" :alt="item.alt"
style="max-height: 500px;">
<span style="display: flex;justify-content: center;">{{ item.name }}</span>
</div>
</div>
<hr>
<h1 style=" display: flex; justify-content: center;">打赏点猫粮</h1>
</div>
</div>`,
data: {
list: [
{
name: "支付宝赞助",
alt: "支付宝支持",
src: "https://www.mikuchase.ltd/img/paymentCodeZFB.webp"
},
{name: "微信赞助", alt: "微信支持", src: "https://www.mikuchase.ltd/img/paymentCodeWX.webp"},
{name: "QQ赞助", alt: "QQ支持", src: "https://www.mikuchase.ltd/img/paymentCodeQQ.webp"},
]
}
});
};
const returnVue$2 = () => {
return new Vue({
el: '#other_parameter_filter',
template: `
<div style="display: flex">
<div style="width: 70vw">
<div>
<h2>使用说明</h2>
<ol>
<li>如设置时长相关单位为秒</li>
<li>如设置播放量和弹幕量相关单位为个</li>
<li>设置最小播放量则小于该值的视频会屏蔽</li>
<li>设置最大播放量则大于该值的视频会屏蔽</li>
<li>设置最小弹幕量则小于该值的视频会屏蔽</li>
<li>设置最大弹幕量则大于该值的视频会屏蔽</li>
<li>设置最小时长则小于该值的视频会屏蔽</li>
<li>设置最大时长则大于该值的视频会屏蔽</li>
<li>设置评论区最小用户等级则小于该值的会屏蔽，低于该值的会屏蔽掉</li>
<li>设置评论区最大用户等级则大于该值的会屏蔽，高于该值的会屏蔽掉</li>
<li>取消相关限制条件则不做限制处理</li>
<li>右侧信息关键条件-1则为未做任何限制处理</li>
<li>最后因为设置限制条件冲突或限制太多，视频未能限制的情况下，请按需设置限制条件</li>
</ol>
</div>
<input gz_type type="number" :min="inputMin" :max="inputMax" v-model="index">
<select v-model="selectValue">
<option :value="item.value" v-for="item in selectList">{{ item.name }}</option>
</select>
《====可点击切换限制条件
<div>
<button @click="okVideoSelectBut" gz_type>设置</button>
<button @click="cancelBut" gz_type>取消</button>
<button gz_type @click="allCancelBut">全部取消</button>
</div>
</div>
<div>
<button @click="updateInfoBut">刷新</button>
<div v-for="item in selectList" style="padding: 5px">
{{ item.name }}{{ item.defVal }}
{{ item.name.includes('时长') ? '秒' : '' }}
</div>
</div>
</div>`,
data() {
return {
index: 0,
selectList: [
{
name: '最小播放量',
value: 'nMinimumPlay',
associated: 'nMaximumPlayback',
defVal: -1
},
{
name: '最大播放量',
value: 'nMaximumPlayback',
associated: 'nMinimumPlay',
bLarge: true,
defVal: -1
},
{
name: '最小弹幕数',
value: 'nMinimumBarrage',
associated: 'nMaximumBarrage',
defVal: -1
},
{
name: '最大弹幕数',
value: 'nMaximumBarrage',
associated: 'nMinimumBarrage',
bLarge: true,
defVal: -1
},
{
name: '最小时长',
value: 'nMinimumDuration',
associated: 'nMaximumDuration',
defVal: -1
},
{
name: '最大时长',
value: 'nMaximumDuration',
associated: 'nMinimumDuration',
bLarge: true,
defVal: -1
},
{
name: '评论区最小用户等级过滤',
value: 'nMinimumLevel',
associated: 'nMaximumLevel',
defVal: -1
},
{
name: '评论区最大用户等级过滤',
value: 'nMaximumLevel',
associated: 'nMinimumLevel',
bLarge: true,
defVal: -1
}
],
selectValue: 'nMinimumPlay',
inputMax: '',
inputMin: '0'
}
},
methods: {
okVideoSelectBut() {
const find = this.selectList.find(item => item.value === this.selectValue);
const associatedVal = gmUtil.getData(find.associated, -1);
const associatedFind = this.selectList.find(item => item.value === find.associated);
if (this.index > associatedVal && associatedVal !== -1) {
if (associatedFind.bLarge) {
xtip.alert(`要设置的${find.name}值不能大于${associatedFind.name}的值`);
return
}
console.log('正常修改');
}
xtip.alert(`已设置${find.name}，值为${this.index}`);
gmUtil.setData(this.selectValue, this.index);
this.updateInfo();
},
cancelBut() {
gmUtil.setData(this.selectValue, -1);
const find = this.selectList.find(item => item.value === this.selectValue);
xtip.alert(`已取消${find.name}的限制`);
this.updateInfo();
},
allCancelBut() {
for (let item of this.selectList) {
gmUtil.setData(item.value, -1);
}
this.updateInfo();
},
updateInfo() {
for (let item of this.selectList) {
item.defVal = gmUtil.getData(item.value, -1);
}
},
updateInfoBut() {
this.updateInfo();
xtip.alert('已刷新');
},
},
watch: {
selectValue(newVal) {
const find = this.selectList.find(item => item.value === newVal);
if (find.name.includes('用户等级')) {
this.inputMin = 3;
this.inputMax = 6;
if (this.index > 6) {
this.index = 6;
}
if (this.index < 3) {
this.index = 3;
}
} else {
this.inputMin = 0;
this.inputMax = '';
}
}
},
created() {
this.updateInfo();
}
})
};
const returnVue$1 = () => {
return new Vue({
el: "#shield #compatible_setting",
template: `
<div>
<div>
<label>
<input type="checkbox" v-model="adaptationBAppRecommend">首页屏蔽适配Bilibili-Gate脚本(bilibili-app-recommend)
</label>
</div>
<div>
<label>
<input type="checkbox" v-model="compatible_BEWLY_BEWLY">兼容BewlyBewly插件
</label>
<div title="使用之后需刷新对应页面才可生效，勾选即评论区使用新版获取方式，不再使用旧版方式">
<label>
<input type="checkbox" v-model="discardOldCommentAreasV">弃用旧版评论区处理
</label>
</div>
</div>
</div>`,
data() {
return {
adaptationBAppRecommend: localMKData.getAdaptationBAppCommerce(),
compatible_BEWLY_BEWLY: localMKData.isCompatible_BEWLY_BEWLY(),
discardOldCommentAreasV:localMKData.isDiscardOldCommentAreas()
}
},
watch:{
adaptationBAppRecommend(newVal) {
localMKData.setAdaptationBAppCommerce(newVal);
},
compatible_BEWLY_BEWLY(newVal) {
localMKData.setCompatible_BEWLY_BEWLY(newVal);
},
discardOldCommentAreasV(newVal) {
localMKData.setDiscardOldCommentAreas(newVal);
}
}
})
};
const mk_db = new Dexie('mk-db');
mk_db.version(1).stores({
tags: 'bv,title,name'
});
const localData = [];
const updateLocalData = async () => {
localData.splice(0, localData.length, ...await mk_db.tags.toArray());
};
updateLocalData().then(r => {
console.log('初始化视频tags表临时缓存');
});
const findBv = async (bv) => {
const find = localData.find(item => item.bv === bv);
if (find === undefined) {
return false
}
return find
};
const addTagsData = async (data) => {
const {title, bv, name, tags} = data;
try {
await mk_db.tags.add({
bv,
title,
name,
tags
});
} catch (e) {
console.log(`添加视频tags失败`, data, e);
return false
}
return true
};
const bulkImportTags = async (friendsData) => {
try {
const lastKeyItem = await mk_db.tags.bulkPut(friendsData);
console.log('批量导入成功，最后一个插入的主键:', lastKeyItem);
return {state: true, lastKeyItem}
} catch (error) {
console.error('批量导入时出错:', error);
return {state: false, error}
}
};
const getVideoAllTags = async () => {
return await mk_db.tags.toArray()
};
const getTagsCount = async () => {
try {
const count = await mk_db.tags.count();
return {state: true, count}
} catch (e) {
return {state: false, count: -1, error: e}
}
};
const clearTagsTable = async () => {
try {
await mk_db.tags.clear();
return true
} catch (e) {
console.log('清除tags表失败', e);
return false
}
};
var bvDexie = {
addTagsData,
getVideoAllTags,
findBv,
updateLocalData,
getTagsCount,
clearTagsTable,
bulkImportTags
};
const returnVue = () => {
return new Vue({
el: "#cache_tags_management_vue",
template: `
<div>
<ol>
<li>每个域名中的tags数据不同</li>
<li>仅仅支持导入json格式</li>
<li>下面导入默认追加模式</li>
</ol>
<div>当前域名：{{ hostname }}</div>
<button gz_type @click="outTagsDataBut">导出当前域名的tags数据</button>
<input ref="inputDemo" type="file" @change="handleFileUpload" accept="application/json"
style="display: none">
<button @click="inputFIleBut" gz_type>追加导入tags数据</button>
<button gz_type @click="clearPageTagsDataBut">清空当前域名的tags数据</button>
</div>`,
data() {
return {
hostname: window.location.hostname
}
},
methods: {
outTagsDataBut() {
bvDexie.getVideoAllTags().then((data) => {
data = {
hostName: this.hostname,
size: data.length,
tags: data
};
defUtil.fileDownload(JSON.stringify(data,null,4), 'mk-db-tags.json');
xtip.msg('已导出当前域名的tags缓存数据', 'success');
console.log(data);
});
},
handleFileUpload(event) {
defUtil.handleFileReader(event).then(data => {
const {content} = data;
let parse;
try {
parse = JSON.parse(content);
} catch (e) {
xtip.msg('文件内容有误', {icon: 'e'});
return;
}
const {hostName = null, tags = []} = parse;
if (!hostName) {
xtip.msg('hostName字段不存在', {icon: 'e'});
return;
}
if (!defUtil.isIterable(tags)) {
xtip.msg('文件内容有误，非可迭代的数组！', {icon: 'e'});
return;
}
if (tags.length === 0) {
xtip.msg('tags数据为空', {icon: 'e'});
return;
}
for (let item of tags) {
if (!item['name']) {
xtip.msg('name字段不存在', {icon: 'e'});
return;
}
if (!item['title']) {
xtip.msg('title字段不存在', {icon: 'e'});
return;
}
if (!item['bv']) {
xtip.msg('bv字段不存在', {icon: 'e'});
return;
}
if (!item['tags']) {
xtip.msg('tags字段不存在', {icon: 'e'});
return;
}
}
bvDexie.bulkImportTags(tags).then((bool) => {
if (bool) {
xtip.msg('导入成功', 'success');
} else {
xtip.msg('导入失败', 'error');
}
});
});
},
inputFIleBut() {
this.$refs.inputDemo.click();
},
clearPageTagsDataBut() {
xtip.confirm('是否清空当前域名下的tags数据', {
icon: 'a',
btn1: () => {
bvDexie.clearTagsTable().then((bool) => {
if (bool) {
xtip.msg('已清空当前域名下的tags数据', 'success');
} else {
xtip.msg('清空失败', 'error');
}
});
}
});
}
},
created() {
}
})
};
document.querySelector("#output_information button")?.addEventListener("click", () => {
olEL.innerHTML = "";
alert("已清空消息");
});
const olEL = document.querySelector("#output_information>.info");
const addInfo = (content) => {
const liEL = document.createElement("li");
liEL.innerHTML = content;
olEL.appendChild(liEL);
};
const outputInformationFontColor = localMKData.getOutputInformationFontColor();
const highlightInformationColor = localMKData.getHighlightInformationColor();
eventEmitter.on('正则匹配时异常', (errorData) => {
const {msg, e} = errorData;
addInfo(msg);
console.log(msg);
throw new Error(e)
});
const getVideoInfoHtml = (type, matching, videoData) => {
const toTimeString = defUtil.toTimeString();
const {name, uid, title, videoUrl} = videoData;
return `<b style="color: ${outputInformationFontColor}; " gz_bezel>
${toTimeString}-根据${type}-${matching ? `<b style="color: ${highlightInformationColor}">【${matching}】</b>` : ""}-屏蔽用户【${name}】uid=
<a href="https://space.bilibili.com/${uid}"
style="color: ${highlightInformationColor}"
target="_blank">【${uid}】</a>
标题【<a href="${videoUrl}" target="_blank" style="color: ${highlightInformationColor}">${title}</a>】
</b>`
};
const getCommentInfoHtml = (type, matching, commentData) => {
const toTimeString = defUtil.toTimeString();
const {name, uid, content} = commentData;
return `<b style="color: ${outputInformationFontColor}; " gz_bezel>
${toTimeString}-根据${type}-${matching ? `<b style="color: ${highlightInformationColor}">【${matching}】</b>` : ""}-屏蔽用户【${name}】uid=
<a href="https://space.bilibili.com/${uid}"
style="color: ${highlightInformationColor}"
target="_blank">【${uid}】</a>
评论【${content}】
</b>`
};
const getLiveRoomCommentInfoHtml = (type, matching, commentData) => {
const toTimeString = defUtil.toTimeString();
const {name, uid, content} = commentData;
return `<b style="color: ${outputInformationFontColor}; " gz_bezel>
${toTimeString}-根据${type}-${matching ? `<b style="color: ${highlightInformationColor}">【${matching}】</b>` : ""}-屏蔽用户【${name}】uid=
<a href="https://space.bilibili.com/${uid}"
style="color: ${highlightInformationColor}"
target="_blank">【${uid}】</a>
直播评论【${content}】
</b>`
};
const getDynamicContentInfoHtml = (type, matching, dynamicData) => {
const toTimeString = defUtil.toTimeString();
const {name, uid, content} = dynamicData;
return `<b style="color: ${outputInformationFontColor}; " gz_bezel>
${toTimeString}-根据${type}-${matching ? `<b style="color: ${highlightInformationColor}">【${matching}】</b>` : ""}-屏蔽用户【${name}】uid=
<a href="https://space.bilibili.com/${uid}"
style="color: ${highlightInformationColor}"
target="_blank">【${uid}】</a>
动态【${content}】
</b>`
};
const getLiveRoomInfoHtml = (type, matching, liveRoomData) => {
const toTimeString = defUtil.toTimeString();
const {name = null, uid = -1, title, liveUrl} = liveRoomData;
return `<b style="color: ${outputInformationFontColor};" gz_bezel>
${toTimeString}-根据${type}${matching ? `<b style="color: ${highlightInformationColor}">【${matching}】</b>` : ""}-屏蔽用户【${name === null ? '' : name}】${uid === -1 ? "" : `uid=
<a href="https://space.bilibili.com/${uid}"
style="color: ${highlightInformationColor}"
target="_blank">【${uid}】</a>`}
直播间标题【<a href="${liveUrl}" target="_blank" style="color: ${highlightInformationColor}">${title}</a>】
</b>`
};
var output_informationTab = {
addInfo,
getVideoInfoHtml,
getCommentInfoHtml,
getLiveRoomCommentInfoHtml,
getDynamicContentInfoHtml,
getLiveRoomInfoHtml
};
var css$1 = `button {
position: fixed;
right: 5%;
top: 13%;
width: 60px;
height: 60px;
border-radius: 50%;
border-width: 0;
cursor: pointer;
background: #0056b3;
}
`;
const addLayout = () => {
const div = document.createElement('div');
div.style.position = 'fixed';
div.style.zIndex = '9001';
div.style.display = localMKData.isHideRightTopMainButSwitch() ? 'none' : '';
const but = document.createElement('button');
but.textContent = '屏蔽器';
const shadowRoot = div.attachShadow({mode: 'open'});
const styleElement = document.createElement('style');
styleElement.textContent = css$1;
shadowRoot.appendChild(but);
shadowRoot.appendChild(styleElement);
document.querySelector('body').appendChild(div);
but.addEventListener('click', () => mainDrawer.showDrawer());
eventEmitter.on('右上角开关按钮显隐', (loop) => {
div.style.display = !loop ? '' : 'none';
});
};
var externalHoverSwitchPanelButton = {
addLayout
};
returnVue$5();
returnVue$4();
returnVue$3();
returnVue$2();
returnVue$1();
returnVue();
installAboutAndFeedbackComponentsVue('#station_b_shield_problem_feedback',
{
title: 'B站屏蔽增强器',
gfFeedbackUrl: 'https://greasyfork.org/zh-CN/scripts/461382'
}
);
gmUtil.addStyle(`
[gz_bezel]{
border:1px solid ${localMKData.getBorderColor()}
}
`);
externalHoverSwitchPanelButton.addLayout();
const getUrlUID = (url) => {
let uid;
if (url.startsWith('http')) {
const parseUrl = defUtil.parseUrl(url);
uid = parseUrl.pathSegments[0]?.trim();
return parseInt(uid)
}
const isDoYouHaveAnyParameters = url.indexOf('?');
const lastIndexOf = url.lastIndexOf("/");
if (isDoYouHaveAnyParameters === -1) {
if (url.endsWith('/')) {
const nTheIndexOfTheLastSecondOccurrenceOfTheSlash = url.lastIndexOf('/', url.length - 2);
uid = url.substring(nTheIndexOfTheLastSecondOccurrenceOfTheSlash + 1, url.length - 1);
} else {
uid = url.substring(lastIndexOf + 1);
}
} else {
uid = url.substring(lastIndexOf + 1, isDoYouHaveAnyParameters);
}
return parseInt(uid);
};
const getUrlBV = (url) => {
let match = url.match(/video\/(.+)\//);
if (match === null) {
match = url.match(/video\/(.+)\?/);
}
if (match === null) {
match=url.match(/video\/(.+)/);
}
return match?.[1]?.trim() || null;
};
const eventRegistry = new Map();
function addEventListenerWithTracking(element, eventName, handler) {
if (!element) {
console.error(element);
throw new Error('错误的元素！')
}
if (!eventRegistry.has(element)) {
eventRegistry.set(element, {events: [], attrs: []});
}
const {events, attrs} = eventRegistry.get(element);
if (attrs.includes(eventName)) {
return
}
attrs.push(eventName);
events.push({eventName, handler});
element.setAttribute(`event-${eventName}`, eventName);
element.addEventListener(eventName, handler);
}
function hasEventListener(element, eventName) {
const elementEvents = eventRegistry.get(element);
if (!elementEvents) {
return false
}
const attr = element.getAttribute(`event-${eventName}`);
if (attr) {
return true
}
const {events} = elementEvents;
return events.some(item => item === eventName);
}
function findElementUntilFound(selector, config = {}) {
const defConfig = {
doc: document,
interval: 1000,
timeout: -1,
};
config = {...defConfig, ...config};
return new Promise((resolve, reject) => {
const i1 = setInterval(() => {
const element = config.doc.querySelector(selector);
if (element) {
resolve(element);
clearInterval(i1);
}
}, config.interval);
if (config.timeout > 0) {
setTimeout(() => {
clearInterval(i1);
reject(null); // 超时则返回 null
}, config.timeout);
}
});
}
function findElementsUntilFound(selector, config = {}) {
const defConfig = {doc: document, interval: 1000, timeout: -1};
config = {...defConfig, ...config};
return new Promise((resolve, reject) => {
const i1 = setInterval(() => {
const elements = config.doc.querySelectorAll(selector);
if (elements.length > 0) {
resolve(elements);
clearInterval(i1);
}
}, config.interval);
if (config.timeout > 0) {
setTimeout(() => {
clearInterval(i1);
reject(null); // 超时则返回 null
}, config.timeout);
}
});
}
function findElementWithTimeout(selector, config = {}) {
const defConfig = {
doc: document,
interval: 1000,
timeout: 60000
};
config = {...defConfig, ...config};
return new Promise((resolve) => {
let intervalId;
function attemptToFind() {
const element = config.doc.querySelector(selector);
if (element) {
clearInterval(intervalId);
resolve({
state: true,
msg: "已找到元素",
el: element
});
}
}
intervalId = setInterval(attemptToFind, config.interval);
const timeout = setTimeout(() => {
clearInterval(intervalId);
resolve({
state: false,
msg: "已超时:" + config.timeout
}); // 超时后提示信息
clearTimeout(timeout);
}, config.timeout);
attemptToFind(); // 立即尝试一次
});
}
const findElementsAndBindEvents = (css, callback, config = {}) => {
config = {
...{
interval: 2000,
timeOut: 3000
}, config
};
setTimeout(() => {
findElementUntilFound(css, {interval: config.interval}).then((el) => {
el.addEventListener("click", () => {
callback();
});
});
}, config.timeOut);
};
var elUtil = {
getUrlUID,
getUrlBV,
addEventListenerWithTracking,
findElementUntilFound,
findElementWithTimeout,
findElementsUntilFound,
findElementsAndBindEvents,
hasEventListener
};
const exactMatch = (ruleList, value) => {
if (ruleList === null || ruleList === undefined) return false;
if (!Array.isArray(ruleList)) return false
return ruleList.some(item => item === value);
};
const regexMatch = (ruleList, value) => {
if (ruleList === null || ruleList === undefined) return null;
if (!Array.isArray(ruleList)) return null
value = value.toLowerCase();
value = value.split(/[\t\r\f\n\s]*/g).join("");
const find = ruleList.find(item => {
try {
return value.search(item) !== -1;
} catch (e) {
const msg = `正则匹配失败，请检查规则列表中的正则表达式是否正确，错误信息：${e.message}`;
eventEmitter.emit('正则匹配时异常', {e, msg});
return false;
}
});
return find === undefined ? null : find;
};
const fuzzyMatch = (ruleList, value) => {
if (ruleList === null || ruleList === undefined||value===null) return null;
if (!Array.isArray(ruleList)) return null
const find = ruleList.find(item => value.toLowerCase().includes(item));
return find === undefined ? null : find;
};
var ruleMatchingUtil = {
exactMatch,
regexMatch,
fuzzyMatch
};
const Tip = {
success(text, config) {
Qmsg.success(text, config);
},
successBottomRight(text) {
this.success(text, {position: "bottomright"});
},
videoBlock(text) {//屏蔽了视频的提示
this.success(text, {position: "bottomright"});
},
info(text, config) {
Qmsg.info(text, config);
},
infoBottomRight(text) {
this.info(text, {position: "bottomright"});
},
error(text, config) {
Qmsg.error(text, config);
},
errorBottomRight(text) {
this.error(text, {position: "bottomright"});
},
warning(text, config) {
Qmsg.warning(text, config);
},
config(cfg) {//设置全局Tip配置
Qmsg.config(cfg);
},
loading(text, config) {
return Qmsg.loading(text, config);
},
close(loading) {
try {
loading.close();
} catch (e) {
console.error(e);
this.error("loading关闭失败！");
}
},
printLn(content) {
Util.printElement("#outputInfo", `<dd>${content}</dd>`);
},
printVideo(color, content, name, uid, title, videoHref) {
Util.printElement("#outputInfo", `
<dd><b
style="color: ${color}; ">${Util.toTimeString()}${content}屏蔽用户【${name}】uid=<a href="https://space.bilibili.com/${uid}" target="_blank">【${uid}】</a>标题【<a href="${videoHref}" target="_blank">${title}</a>】</b>
</dd>`);
},
printCommentOn(color, content, name, uid, primaryContent) {
Util.printElement("#outputInfo", `
<dd>
<b style="color: ${color}; ">${Util.toTimeString()}${content} 屏蔽用户【${name}】uid=<a href="https://space.bilibili.com/${uid}" target="_blank">【${uid}】</a>
原言论=【${primaryContent}】</b>
</dd>`);
}
};
const isTopicDetailPage = (url) => {
return url.includes("//www.bilibili.com/v/topic/detail/")
};
const getDataList$1 = async () => {
const elList = await elUtil.findElementsUntilFound(".list__topic-card");
const list = [];
for (let el of elList) {
const name = el.querySelector(".bili-dyn-title").textContent.trim();
const uidEl = el.querySelector(".bili-dyn-item__following");
const uid = parseInt(uidEl.getAttribute("data-mid"));
const judgmentEl = el.querySelector(".bili-dyn-card-video__title");
const data = {name, uid, el, judgmentVideo: judgmentEl !== null};
if (judgmentEl !== null) {
data.title = judgmentEl.textContent.trim();
const videoUrl = el.querySelector(".bili-dyn-card-video").href;
data.videoUrl = videoUrl;
data.bv = elUtil.getUrlBV(videoUrl);
data.insertionPositionEl = el.querySelector(".bili-dyn-content__orig");
data.explicitSubjectEl = data.insertionPositionEl;
} else {
const dynTitle = el.querySelector(".dyn-card-opus__title");
const contentTitle = dynTitle === null ? "" : dynTitle.textContent.trim();
const contentBody = el.querySelector(".bili-rich-text>div").textContent.trim();
data.insertionPositionEl = el.querySelector(".dyn-card-opus");
data.explicitSubjectEl = data.insertionPositionEl;
data.content = contentTitle + contentBody;
}
list.push(data);
}
return list;
};
const __shieldingVideo = (videoData) => {
if (shielding.shieldingVideoDecorated(videoData)) {
return;
}
shielding.addTopicDetailVideoBlockButton({data: videoData, maskingFunc: startShielding});
};
const __shieldingDynamic = (dynamicData) => {
if (shielding.shieldingCommentDecorated(dynamicData)) {
return;
}
shielding.addTopicDetailContentsBlockButton({data: dynamicData, maskingFunc: startShielding});
};
const startShielding = async () => {
const list = await getDataList$1();
const css = {width: "100%"};
for (let data of list) {
data.css = css;
if (data.judgmentVideo) {
__shieldingVideo(data);
} else {
__shieldingDynamic(data);
}
}
};
var topicDetail = {
isTopicDetailPage,
startShielding
};
const getUrlUserLevel = (src) => {
const levelMath = src?.match(/level_(.+)\.svg/) || null;
let level = -1;
if (levelMath !== null) {
const levelRow = levelMath[1];
if (levelRow === 'h') {
level = 7;
} else {
level = parseInt(levelRow);
}
}
return level;
};
const getOldUserLevel = (iEl) => {
let level = -1;
const levelCLassName = iEl.classList[1];
if (levelCLassName === 'level-hardcore') {
level = 7;
} else {
const levelMatch = levelCLassName.match(/level-(.+)/)?.[1] || '';
level = parseInt(levelMatch);
}
return level
};
const getCommentSectionList = async () => {
const commentApp = await elUtil.findElementUntilFound("bili-comments",
{interval: 500});
const comments = await elUtil.findElementsUntilFound("#feed>bili-comment-thread-renderer",
{doc: commentApp.shadowRoot, interval: 500});
const commentsData = [];
let isLoaded = false;
for (let el of comments) {
const theOPEl = el.shadowRoot.getElementById("comment").shadowRoot;
const theOPUserInfo = theOPEl.querySelector("bili-comment-user-info")
.shadowRoot.getElementById("info");
const userNameEl = theOPUserInfo.querySelector("#user-name>a");
const userLevelSrc = theOPUserInfo.querySelector('#user-level>img')?.src || null;
const level = getUrlUserLevel(userLevelSrc);
isLoaded = theOPEl.querySelector("#content>bili-rich-text")
.shadowRoot.querySelector("#contents>*") !== null;
if (!isLoaded) {
break;
}
const theOPContentEl = theOPEl.querySelector("#content>bili-rich-text")
.shadowRoot.querySelector("#contents");
const theOPContent = theOPContentEl.textContent.trim();
const userName = userNameEl.textContent.trim();
const userUrl = userNameEl.href;
const uid = elUtil.getUrlUID(userUrl);
const replies = [];
commentsData.push({
name: userName,
userUrl,
uid,
level,
content: theOPContent,
replies,
el,
insertionPositionEl: theOPUserInfo,
explicitSubjectEl: theOPEl.querySelector("#body")
});
const inTheBuildingEls = el.shadowRoot.querySelector("bili-comment-replies-renderer")
.shadowRoot.querySelectorAll("bili-comment-reply-renderer");
for (let inTheBuildingEl of inTheBuildingEls) {
const inTheContentEl = inTheBuildingEl.shadowRoot;
const biliCommentUserInfo = inTheContentEl.querySelector("bili-comment-user-info");
biliCommentUserInfo.style.display = 'block';
const inTheBuildingUserInfo = biliCommentUserInfo.shadowRoot.getElementById("info");
const inTheBuildingUserNameEl = inTheBuildingUserInfo.querySelector("#user-name>a");
const inTheBuildingUserName = inTheBuildingUserNameEl.textContent.trim();
const inTheBuildingUserUrl = inTheBuildingUserNameEl.href;
const inTheBuildingUid = elUtil.getUrlUID(inTheBuildingUserUrl);
const biliRichTextEL = inTheContentEl.querySelector("bili-rich-text");
const inTheBuildingContent = biliRichTextEL.shadowRoot.getElementById("contents").textContent.trim();
const userLevelSrc = inTheBuildingUserInfo.querySelector('#user-level>img')?.src || null;
const level = getUrlUserLevel(userLevelSrc);
replies.push({
name: inTheBuildingUserName,
userUrl: inTheBuildingUserUrl,
uid: inTheBuildingUid,
level,
content: inTheBuildingContent,
el: inTheBuildingEl,
insertionPositionEl: inTheBuildingUserInfo,
explicitSubjectEl: inTheBuildingEl
});
}
}
if (!isLoaded) {
await defUtil.wait(500);
return getCommentSectionList()
}
return commentsData;
};
const getOldCommentSectionList = async () => {
let results;
try {
results = await elUtil.findElementsUntilFound(".reply-list>.reply-item", {timeout: 5000});
} catch (e) {
return []
}
const commentsData = [];
for (let el of results) {
const theOPEl = el.querySelector(".root-reply-container");
const theOPUserInfoEl = theOPEl.querySelector(".user-name");
const userName = theOPUserInfoEl.textContent.trim();
const uid = parseInt(theOPUserInfoEl.getAttribute("data-user-id"));
const userUrl = `https://space.bilibili.com/${uid}`;
const theOPContent = theOPEl.querySelector(".reply-content").textContent.trim();
const userInfoEl = el.querySelector(".user-info");
const iEl = userInfoEl.querySelector('i');
const level = getOldUserLevel(iEl);
const replies = [];
commentsData.push({
name: userName,
userUrl,
uid,
content: theOPContent,
level,
replies,
el,
insertionPositionEl: userInfoEl,
explicitSubjectEl: el.querySelector(".content-warp")
});
const inTheBuildingEls = el.querySelectorAll(".sub-reply-container>.sub-reply-list>.sub-reply-item");
for (let inTheBuildingEl of inTheBuildingEls) {
const subUserNameEl = inTheBuildingEl.querySelector(".sub-user-name");
const uid = parseInt(subUserNameEl.getAttribute("data-user-id"));
const userName = subUserNameEl.textContent.trim();
const userUrl = `https://space.bilibili.com/${uid}`;
const subContent = inTheBuildingEl.querySelector(".reply-content").textContent.trim();
const subUserInfoEl = inTheBuildingEl.querySelector(".sub-user-info");
const iEl = subUserInfoEl.querySelector('i');
const level = getOldUserLevel(iEl);
const replyContentContainerEl = inTheBuildingEl.querySelector('span.reply-content-container');
replyContentContainerEl.style.display = 'block';
replies.push({
name: userName,
userUrl,
uid,
level,
content: subContent,
el: inTheBuildingEl,
insertionPositionEl: subUserInfoEl,
explicitSubjectEl: inTheBuildingEl
});
}
}
return commentsData;
};
const startShieldingComments = async () => {
let list;
const href = window.location.href;
if (localMKData.isDiscardOldCommentAreas()) {
list = await getCommentSectionList();
} else if (href.includes("https://space.bilibili.com/") || topicDetail.isTopicDetailPage(href)) {
list = await getOldCommentSectionList();
} else {
list = await getCommentSectionList();
}
shielding.shieldingComments(list);
};
var commentSectionModel = {
startShieldingComments
};
const getVideoTags = async (bv) => {
const response = await fetch(`https://api.bilibili.com/x/web-interface/view/detail/tag?bvid=${bv}`);
const videoTagData = {bv, state: false, tags: []};
if (!response.ok) {
videoTagData.msgData = {msg: 'fetch网络请求失败:获取视频tag失败', response};
return videoTagData
}
let responseJson;
try {
responseJson = await response.json();
} catch (e) {
videoTagData.msgData = {msg: '获取视频tag异常:转换json内容失败', e};
return videoTagData
}
const {code, data} = responseJson;
if (code !== 0) {
videoTagData.msgData = {msg: '获取视频tag失败', responseJson};
return videoTagData
}
try {
for (let datum of data) {
videoTagData.tags.push(datum['tag_name']);
}
} catch (e) {
videoTagData.msgData = {msg: '获取视频tag异常:遍历读取data数据时失败', e};
return videoTagData
}
videoTagData.state = true;
videoTagData.msgData = {msg: '获取视频tag成功'};
return videoTagData
};
const getVideoTagsPackaging = async (videoData) => {
const {bv, title, name} = videoData;
const find = await bvDexie.findBv(bv);
if (find) {
return {state: true, data: {bv, name, title, tags: find.tags}}
}
const videoTagData = await getVideoTags(bv);
if (!videoTagData.state) {
console.error(videoTagData.msgData.msg, videoTagData.msgData);
return {state: false, data: videoTagData}
}
const {tags} = videoTagData;
const bool = await bvDexie.addTagsData({bv, title, name, tags});
if (bool) {
await bvDexie.updateLocalData();
console.log('mk-db-tags-添加数据成功', videoTagData, videoData);
} else {
console.error('mk-db-tags-添加数据失败', videoTagData, videoData);
}
return {state: true, data: {bv, name, title, tags}}
};
var bFetch = {
getVideoTagsPackaging
};
const addBlockButton$1 = (data, tagCss = '', position = []) => {
const {insertionPositionEl, explicitSubjectEl, css} = data.data;
if (tagCss !== '') {
if (insertionPositionEl.querySelector("." + tagCss)) return;
}
const buttonEL = document.createElement("button");
buttonEL.setAttribute("gz_type", "");
if (tagCss !== '') {
buttonEL.className = tagCss;
}
buttonEL.textContent = "屏蔽";
if (position.length !== 0) {
buttonEL.style.position = "absolute";
}
if (position.includes("right")) {
buttonEL.style.right = "0";
}
if (position.includes("bottom")) {
buttonEL.style.bottom = "0";
}
if (css !== undefined) {
for (let key of Object.keys(css)) {
buttonEL.style[key] = css[key];
}
}
if (explicitSubjectEl) {
buttonEL.style.display = "none";
elUtil.addEventListenerWithTracking(explicitSubjectEl, "mouseout", () => buttonEL.style.display = "none");
elUtil.addEventListenerWithTracking(explicitSubjectEl, "mouseover", () => buttonEL.style.display = "");
}
insertionPositionEl.appendChild(buttonEL);
buttonEL.addEventListener("click", (event) => {
event.stopImmediatePropagation(); // 阻止事件冒泡和同一元素上的其他事件处理器
event.preventDefault(); // 阻止默认行为
const {uid, name} = data.data;
console.log("该选项数据:", data);
xtip.sheet({
btn: [`uid精确屏蔽-用户uid=${uid}-name=${name}`, `用户名精确屏蔽(不推荐)-用户name=${name}`],
btn1: () => {
if (uid === -1) {
Tip.error("该页面数据不存在uid字段");
return;
}
ruleUtil.addRule(uid, "precise_uid").then(msg => {
xtip.msg(msg);
data.maskingFunc();
}).catch(msg => {
xtip.alert(msg, {icon: 'e'});
});
},
btn2: () => {
if (!name) {
alert("该页面数据不存在name字段" + name);
return;
}
if (!window.confirm('不推荐用户使用精确用户名来屏蔽，确定继续吗？')) return
ruleUtil.addRulePreciseName(name);
},
});
});
};
const addVideoBlockButton$1 = (data) => {
addBlockButton$1(data, "gz_shielding_button", ["right"]);
};
const addPopularVideoBlockButton = (data) => {
addBlockButton$1(data, "gz_shielding_button", ["right", "bottom"]);
};
const addTopicDetailVideoBlockButton = (data) => {
addBlockButton$1(data, "gz_shielding_button");
};
const addTopicDetailContentsBlockButton = (data) => {
const position = data.data.position;
const loop = position !== undefined;
addBlockButton$1(data, "gz_shielding_topic_detail_button", loop ? position : []);
};
const addCommentBlockButton = (commentsData) => {
const data = {
data: commentsData,
maskingFunc: commentSectionModel.startShieldingComments
};
addBlockButton$1(data, "gz_shielding_comment_button");
};
const addLiveContentBlockButton = (commentsData) => {
addBlockButton$1(commentsData, "gz_shielding_live_danmaku_button");
};
const shieldingVideo = (videoData) => {
const {
title, uid = -1,
name, nDuration = -1,
nBulletChat = -1, nPlayCount = -1
} = videoData;
if (ruleMatchingUtil.exactMatch(ruleKeyListData$1.getPreciseUidWhiteArr(), uid)) {
return {state: false};
}
if (ruleMatchingUtil.exactMatch(ruleKeyListData$1.getPreciseUidArr(), uid)) {
return {state: true, type: "精确匹配uid"};
}
let matching = ruleMatchingUtil.fuzzyMatch(ruleKeyListData$1.getTitleArr(), title);
if (matching !== null) {
return {state: true, type: "模糊匹配标题", matching};
}
matching = ruleMatchingUtil.regexMatch(ruleKeyListData$1.getTitleCanonicalArr(), title);
if (matching !== null) {
return {state: true, type: "正则匹配标题", matching};
}
if (ruleMatchingUtil.exactMatch(ruleKeyListData$1.getPreciseNameArr(), name)) {
return {state: true, type: "精确匹配用户名"};
}
matching = ruleMatchingUtil.fuzzyMatch(ruleKeyListData$1.getNameArr(), name);
if (matching !== null) {
return {state: true, type: "模糊匹配用户名", matching};
}
matching = ruleMatchingUtil.regexMatch(ruleKeyListData$1.getNameCanonical(), name);
if (matching !== null) {
return {state: true, type: "正则用户名", matching};
}
if (nDuration !== -1) {
const min = gmUtil.getData('nMinimumDuration', -1);
if (min > nDuration && min !== -1) {
return {state: true, type: '最小时长', matching: min}
}
const max = gmUtil.getData('nMaximumDuration', -1);
if (max < nDuration && max !== -1) {
return {state: true, type: '最大时长', matching: max}
}
}
if (nBulletChat !== -1) {
const min = gmUtil.getData('nMinimumBarrage', -1);
if (min > nBulletChat && min !== -1) {
return {state: true, type: '最小弹幕数', matching: min}
}
const max = gmUtil.getData('nMaximumBarrage', -1);
if (max < nBulletChat && max !== -1) {
return {state: true, type: '最大弹幕数', matching: max}
}
}
if (nPlayCount !== -1) {
const min = gmUtil.getData('nMinimumPlay', -1);
if (min > nPlayCount && min !== -1) {
return {state: true, type: '最小播放量', matching: min}
}
const max = gmUtil.getData('nMaximumPlayback', -1);
if (max < nPlayCount && max !== -1) {
return {state: true, type: '最大播放量', matching: max}
}
}
return {state: false};
};
const blockBasedVideoTag = async (videoData) => {
const {el, bv = '-1'} = videoData;
if (bv === '-1') {
return
}
const preciseVideoTagArr = ruleKeyListData$1.getPreciseVideoTagArr();
const videoTagArr = ruleKeyListData$1.getVideoTagArr();
if (preciseVideoTagArr.length <= 0 && videoTagArr.length <= 0) {
return
}
const tagsData = await bFetch.getVideoTagsPackaging(videoData);
const {state, data} = tagsData;
if (!state) {
console.log('错误:', data);
return
}
const {tags = []} = data;
for (let tag of tags) {
if (ruleMatchingUtil.exactMatch(preciseVideoTagArr, tag)) {
el?.remove();
Tip.successBottomRight("屏蔽了视频");
output_informationTab.addInfo(output_informationTab.getVideoInfoHtml("精确tag", tag, videoData));
return
}
let fuzzyMatch = ruleMatchingUtil.fuzzyMatch(videoTagArr, tag);
if (fuzzyMatch) {
el?.remove();
Tip.successBottomRight("屏蔽了视频");
output_informationTab.addInfo(output_informationTab.getVideoInfoHtml("模糊tag", fuzzyMatch, videoData));
return
}
fuzzyMatch = ruleMatchingUtil.regexMatch(ruleKeyListData$1.getVideoTagCanonicalArr(), tag);
if (fuzzyMatch) {
el?.remove();
Tip.successBottomRight("屏蔽了视频");
output_informationTab.addInfo(output_informationTab.getVideoInfoHtml("正则tag", fuzzyMatch, videoData));
return
}
}
};
const shieldingVideoDecorated = (videoData, method = "remove") => {
const {el} = videoData;
if (el.style.display === "none") {
return true
}
const {state, type, matching = null} = shieldingVideo(videoData);
if (state) {
if (method === "remove") {
el?.remove();
} else {
el.style.display = "none";
}
Tip.successBottomRight("屏蔽了视频");
const videoInfoHtml = output_informationTab.getVideoInfoHtml(type, matching, videoData);
output_informationTab.addInfo(videoInfoHtml);
return true;
}
blockBasedVideoTag(videoData);
return state;
};
const shieldingDynamic = (dynamicData) => {
const {
content = null,
el,
title = null,
tag = null
} = dynamicData;
let matching = null;
if (content !== null) {
matching = ruleMatchingUtil.fuzzyMatch(ruleKeyListData$1.getCommentOnArr(), content);
if (matching !== null) {
el?.remove();
return {state: true, type: "评论模糊内容", matching};
}
matching = ruleMatchingUtil.regexMatch(ruleKeyListData$1.getCommentOnCanonicalArr(), content);
if (matching !== null) {
el?.remove();
return {state: true, type: "评论正则内容", matching};
}
}
if (title !== null) {
matching = ruleMatchingUtil.fuzzyMatch(ruleKeyListData$1.getTitleArr(), title);
if (matching !== null) {
el?.remove();
return {state: true, type: "模糊标题", matching};
}
matching = ruleMatchingUtil.regexMatch(ruleKeyListData$1.getTitleCanonicalArr(), title);
if (matching !== null) {
el?.remove();
return {state: true, type: "正则标题", matching};
}
}
if (tag !== null) {
if (ruleMatchingUtil.exactMatch(ruleKeyListData$1.getPreciseTagArr(), tag)) {
el?.remove();
return {state: true, type: "精确tag"};
}
matching = ruleMatchingUtil.fuzzyMatch(ruleKeyListData$1.getTagArr(), tag);
if (matching !== null) {
el?.remove();
return {state: true, type: "模糊tag", matching};
}
matching = ruleMatchingUtil.regexMatch(ruleKeyListData$1.getTagCanonicalArr(), tag);
if (matching !== null) {
el?.remove();
return {state: true, type: "正则tag", matching};
}
}
return {state: false}
};
const shieldingDynamicDecorated = (dynamicData) => {
const {state, type, matching} = shieldingDynamic(dynamicData);
if (state) {
Tip.successBottomRight("屏蔽了视频");
output_informationTab.addInfo(output_informationTab.getDynamicContentInfoHtml(type, matching, dynamicData));
}
return state;
};
const shieldingComment = (commentsData) => {
const {content, uid, name, level = -1} = commentsData;
if (ruleMatchingUtil.exactMatch(ruleKeyListData$1.getPreciseUidWhiteArr(), uid)) {
return {state: false};
}
if (ruleMatchingUtil.exactMatch(ruleKeyListData$1.getPreciseUidArr(), uid)) {
return {state: true, type: "精确匹配uid"};
}
if (ruleMatchingUtil.exactMatch(ruleKeyListData$1.getPreciseNameArr(), name)) {
return {state: true, type: "精确用户名"};
}
let matching = ruleMatchingUtil.fuzzyMatch(ruleKeyListData$1.getNameArr(), name);
if (matching !== null) {
return {state: true, type: "模糊匹配用户名", matching};
}
matching = ruleMatchingUtil.regexMatch(ruleKeyListData$1.getNameCanonical(), name);
if (matching !== null) {
return {state: true, type: "正则用户名", matching};
}
matching = ruleMatchingUtil.fuzzyMatch(ruleKeyListData$1.getCommentOnArr(), content);
if (matching !== null) {
return {state: true, type: "模糊评论内容", matching};
}
matching = ruleMatchingUtil.regexMatch(ruleKeyListData$1.getCommentOnCanonicalArr(), content);
if (matching !== null) {
return {state: true, type: "正则评论内容", matching};
}
if (level !== -1) {
const min = gmUtil.getData('nMinimumLevel', -1);
if (min > level) {
return {state: true, type: "评论区最小用户等级过滤", matching: min};
}
const max = gmUtil.getData('nMaximumLevel', -1);
if (max > level) {
return {state: true, type: "评论区最大用户等级过滤", matching: max};
}
}
return {state: false};
};
const shieldingCommentDecorated = (commentsData) => {
const {state, type, matching} = shieldingComment(commentsData);
if (state) {
commentsData.el?.remove();
Tip.successBottomRight("屏蔽了评论");
output_informationTab.addInfo(output_informationTab.getCommentInfoHtml(type, matching, commentsData));
}
return state;
};
const shieldingLiveRoomContentDecorated = (liveRoomContent) => {
let {state, type, matching} = shieldingComment(liveRoomContent);
const {el, fansMedal} = liveRoomContent;
if (fansMedal !== null) {
if (ruleMatchingUtil.exactMatch(ruleKeyListData$1.getPreciseFanCardArr(), fansMedal)) {
el?.remove();
state = true;
type = "精确粉丝牌";
}
}
if (state) {
el?.remove();
Tip.successBottomRight("屏蔽了直播间评论");
}
if (type) {
output_informationTab.addInfo(output_informationTab.getLiveRoomCommentInfoHtml(type, matching, liveRoomContent));
}
return state;
};
const shieldingComments = (commentsDataList) => {
for (let commentsData of commentsDataList) {
if (shieldingCommentDecorated(commentsData)) continue;
addCommentBlockButton(commentsData);
const {replies = []} = commentsData;
if (replies.length === 0) continue;
for (let reply of replies) {
if (shieldingCommentDecorated(reply)) continue;
addCommentBlockButton(reply);
}
}
};
const shieldingLiveRoom = (liveRoomData) => {
const {name, title, partition, uid = -1} = liveRoomData;
if (uid !== -1) {
if (ruleMatchingUtil.exactMatch(ruleKeyListData$1.getPreciseUidWhiteArr(), uid)) {
return {state: false};
}
if (ruleMatchingUtil.exactMatch(ruleKeyListData$1.getPreciseUidArr(), uid)) {
return {state: true, type: "精确用户uid"};
}
}
let matching;
if (name) {
if (ruleMatchingUtil.exactMatch(ruleKeyListData$1.getPreciseNameArr(), name)) {
return {state: true, type: "精确用户名"};
}
matching = ruleMatchingUtil.fuzzyMatch(ruleKeyListData$1.getNameArr(), name);
if (matching) {
return {state: true, type: "模糊用户名", matching};
}
}
matching = ruleMatchingUtil.exactMatch(ruleKeyListData$1.getTitleArr(), title);
if (matching) {
return {state: true, type: "模糊标题", matching};
}
matching = ruleMatchingUtil.fuzzyMatch(ruleKeyListData$1.getTitleCanonicalArr(), title);
if (matching) {
return {state: true, type: "正则标题", matching};
}
if (partition) {
if (ruleMatchingUtil.exactMatch(ruleKeyListData$1.getPrecisePartitionArr(), partition)) {
return {state: true, type: "精确直播分区"};
}
}
return {state: false};
};
const shieldingLiveRoomDecorated = (liveRoomData) => {
const {state, type, matching = null} = shieldingLiveRoom(liveRoomData);
if (state) {
liveRoomData.el?.remove();
Tip.successBottomRight("屏蔽了直播间");
output_informationTab.addInfo(output_informationTab.getLiveRoomInfoHtml(type, matching, liveRoomData));
}
return state;
};
const intervalExecutionStartShieldingVideoInert = (func, name = '') => {
let i1 = -1;
const start = () => {
if (i1 !== -1) {
return
}
console.log('开始执行屏蔽' + name);
i1 = setInterval(() => {
func();
console.log(`执行屏蔽${name}列表-定时器正在执行`);
}, 1500);
};
const stop = () => {
if (i1 === -1) {
return
}
clearInterval(i1);
console.log(`已停止执行屏蔽${name}列表`);
i1 = -1;
};
return {start, stop}
};
var shielding = {
shieldingVideoDecorated,
shieldingDynamicDecorated,
shieldingCommentDecorated,
shieldingLiveRoomDecorated,
shieldingComments,
addVideoBlockButton: addVideoBlockButton$1,
addCommentBlockButton,
shieldingLiveRoomContentDecorated,
addLiveContentBlockButton,
addPopularVideoBlockButton,
addTopicDetailVideoBlockButton,
addTopicDetailContentsBlockButton,
intervalExecutionStartShieldingVideoInert,
addBlockButton: addBlockButton$1
};
const toPlayCountOrBulletChat = (str) => {
if (!str) {
return -1
}
str = str.split(/[\t\r\f\n\s]*/g).join("");
const replace = str.replace(/[^\d.]/g, '');
if (str.endsWith('万') || str.endsWith('万次') || str.endsWith('万弹幕')) {
return parseFloat(replace) * 10000;
}
if (str.endsWith('次') || str.endsWith('弹幕')) {
return parseInt(replace);
}
return parseInt(str)
};
const timeStringToSeconds = (timeStr) => {
if (!timeStr) {
return -1
}
const parts = timeStr.split(':');
switch (parts.length) {
case 1: // 只有秒
return Number(parts[0]);
case 2: // 分钟和秒
return Number(parts[0]) * 60 + Number(parts[1]);
case 3: // 小时、分钟和秒
return Number(parts[0]) * 3600 + Number(parts[1]) * 60 + Number(parts[2]);
default:
throw new Error('Invalid time format');
}
};
var sFormatUtil = {
toPlayCountOrBulletChat,
timeStringToSeconds
};
const isHome = (url, title) => {
if (title !== "哔哩哔哩 (゜-゜)つロ 干杯~-bilibili") {
return false
}
if (url === 'https://www.bilibili.com/') {
return true
}
return url.includes('https://www.bilibili.com/?spm_id_from=')
};
const adaptationBAppCommerce$1 = localMKData.getAdaptationBAppCommerce();
const deDesktopDownloadTipEl = async () => {
const el = await elUtil.findElementUntilFound(".desktop-download-tip");
el?.remove();
const log = "已删除下载提示";
Tip.infoBottomRight(log);
console.log(log, el);
};
const getChangeTheVideoElList = async () => {
const elList = await elUtil.findElementsUntilFound(".container.is-version8>.feed-card");
const list = [];
for (let el of elList) {
try {
const tempData = getVideoData(el);
const {userUrl} = tempData;
const videoUrl = el.querySelector(".bili-video-card__info--tit>a")?.href || null;
if (!userUrl.includes("//space.bilibili.com/")) {
el?.remove();
const log = "遍历换一换视频列表中检测到异常内容，已将该元素移除";
Tip.infoBottomRight(log);
console.log(log, el);
continue;
}
const items = {
...tempData, ...{
videoUrl,
el,
insertionPositionEl: el.querySelector(".bili-video-card__info--bottom"),
explicitSubjectEl: el.querySelector(".bili-video-card__info")
}
};
if (videoUrl?.includes('www.bilibili.com/video')) {
items.bv = elUtil.getUrlBV(videoUrl);
}
list.push(items);
} catch (e) {
el.remove();
Qmsg.error("获取视频信息失败");
}
}
return list
};
const getVideoData = (el) => {
const title = el.querySelector(".bili-video-card__info--tit").title;
const name = el.querySelector(".bili-video-card__info--author").textContent.trim();
let nPlayCount = el.querySelector('.bili-video-card__stats--text')?.textContent.trim();
nPlayCount = sFormatUtil.toPlayCountOrBulletChat(nPlayCount);
let nBulletChat = el.querySelector('.bili-video-card__stats--text')?.textContent.trim();
nBulletChat = sFormatUtil.toPlayCountOrBulletChat(nBulletChat);
let nDuration = el.querySelector('.bili-video-card__stats__duration')?.textContent.trim();
nDuration = sFormatUtil.timeStringToSeconds(nDuration);
const userUrl = el.querySelector(".bili-video-card__info--owner").getAttribute("href");
const uid = elUtil.getUrlUID(userUrl);
return {
title,
name,
uid,
nPlayCount,
nBulletChat,
nDuration,
userUrl
}
};
const getHomeVideoELList = async () => {
const elList = await elUtil.findElementsUntilFound(".container.is-version8>.bili-video-card");
let list = [];
for (let el of elList) {
try {
const tempData = getVideoData(el);
const {userUrl} = tempData;
if (!userUrl.includes("//space.bilibili.com/")) {
el?.remove();
const log = "遍历换一换视频列表下面列表时检测到异常内容，已将该元素移除";
Tip.infoBottomRight(log);
console.log(log, el);
continue;
}
const videoUrl = el.querySelector(".bili-video-card__info--tit>a")?.href;
const items = {
...tempData, ...{
videoUrl,
el,
insertionPositionEl: el.querySelector(".bili-video-card__info--bottom"),
explicitSubjectEl: el.querySelector(".bili-video-card__info")
}
};
if (videoUrl?.includes('www.bilibili.com/video')) {
items.bv = elUtil.getUrlBV(videoUrl);
}
list.push(items);
} catch (e) {
el?.remove();
Tip.infoBottomRight("遍历视频列表中检测到异常内容，已将该元素移除;");
}
}
return list;
};
const getGateActivatedTab = async () => {
const el = await elUtil.findElementUntilFound(".ant-radio-group>.ant-radio-button-wrapper-checked .css-1k4kcw8");
return el?.textContent.trim();
};
const getGateDataList = async () => {
const elList = await elUtil.findElementsUntilFound(".bilibili-gate-video-grid>[data-bvid].bili-video-card");
const list = [];
for (let el of elList) {
const tempData = getVideoData(el);
const videoUrl = el.querySelector("a.css-feo88y")?.href;
const bv = elUtil.getUrlBV(videoUrl);
const insertionPositionEl = el.querySelector(".bili-video-card__info--owner");
list.push({
...tempData, ...{
videoUrl,
el,
bv,
insertionPositionEl,
explicitSubjectEl: el
}
});
}
return list;
};
const startShieldingGateVideoList = async () => {
const list = await getGateDataList();
for (let videoData of list) {
if (shielding.shieldingVideoDecorated(videoData, "hide")) {
continue;
}
shielding.addVideoBlockButton({data: videoData, maskingFunc: startShieldingGateVideoList});
}
};
const startIntervalShieldingGateVideoList = () => {
const throttle = defUtil.throttle(startShieldingGateVideoList, 2000);
setInterval(async () => {
await getGateActivatedTab();
throttle();
}, 1500);
};
const startClearExcessContentList = () => {
if (adaptationBAppCommerce$1) return;
setInterval(() => {
const otherElList = document.querySelectorAll(".floor-single-card");
const liveList = document.querySelectorAll(".bili-live-card");
const elList = [...otherElList, ...liveList];
for (let el of elList) {
el?.remove();
}
}, 1000);
console.log("已启动每秒清理首页视频列表中多余的内容");
};
const startShieldingChangeVideoList = async () => {
const list = await getChangeTheVideoElList();
for (let videoData of list) {
if (shielding.shieldingVideoDecorated(videoData)) {
continue;
}
shielding.addVideoBlockButton({data: videoData, maskingFunc: startShieldingChangeVideoList});
}
};
const startDebounceShieldingChangeVideoList = defUtil.debounce(startShieldingChangeVideoList, 200);
const startShieldingHomeVideoList = async () => {
const homeVideoELList = await getHomeVideoELList();
for (const videoData of homeVideoELList) {
if (shielding.shieldingVideoDecorated(videoData)) {
continue;
}
shielding.addVideoBlockButton({data: videoData, maskingFunc: startShieldingHomeVideoList});
}
};
const startDebounceShieldingHomeVideoList = defUtil.debounce(startShieldingHomeVideoList, 500);
const scrollMouseUpAndDown = async () => {
if (adaptationBAppCommerce$1) return;
await defUtil.smoothScroll(false, 100);
return defUtil.smoothScroll(true, 600);
};
var bilibiliHome = {
isHome,
startClearExcessContentList,
startDebounceShieldingChangeVideoList,
startDebounceShieldingHomeVideoList,
scrollMouseUpAndDown,
deDesktopDownloadTipEl,
startIntervalShieldingGateVideoList
};
var css = `.to_hide_xl {
display: block !important;
}
`;
const installStyle = () => {
const styleElement = document.createElement('style');
styleElement.textContent = css;
document.head.appendChild(styleElement);
};
const getLiveRoomList = async () => {
const elList = await elUtil.findElementsUntilFound('.live-room-cards>.video-list-item');
const list = [];
for (let el of elList) {
const titleAEl = el.querySelector('.bili-live-card__info--tit>a');
const titleEl = el.querySelector('.bili-live-card__info--tit>a>span');
const userEl = el.querySelector('.bili-live-card__info--uname');
const liveUrl = titleAEl.href;
const title = titleEl.textContent.trim();
const userUrl = userEl.href;
const uid = elUtil.getUrlUID(userUrl);
const name = userEl.textContent.trim();
list.push({
title,
liveUrl,
name,
userUrl,
uid,
el,
explicitSubjectEl: el.querySelector('.bili-live-card__info'),
insertionPositionEl: userEl
});
}
return list
};
const addBlockButton = (data) => {
shielding.addBlockButton(data, '', ['right']);
};
const startShieldingLiveRoomList = async () => {
const list = await getLiveRoomList();
for (let liveData of list) {
if (shielding.shieldingLiveRoomDecorated(liveData)) {
continue
}
addBlockButton({data: liveData, maskingFunc: startShieldingLiveRoomList});
}
};
const InstallLiveTopTabsListener = async () => {
const el = await elUtil.findElementUntilFound('.live-condition');
if (elUtil.hasEventListener(el, 'click')) return
elUtil.addEventListenerWithTracking(el, 'click', async (event) => {
const target = event.target;
const label = target.textContent.trim();
if (label === '主播') {
return
}
await startShieldingLiveRoomList();
InstallBottomPagingListener();
installTopRoomOrderListener();
});
console.log("直播顶部选项卡安装监听器已安装");
};
const InstallBottomPagingListener = async () => {
const el = await elUtil.findElementUntilFound('.vui_pagenation--btns');
if (elUtil.hasEventListener(el, 'click')) return
elUtil.addEventListenerWithTracking(el, 'click', async (event) => {
const target = event.target;
if (target.tagName !== 'BUTTON') {
return
}
await startShieldingLiveRoomList();
installTopRoomOrderListener();
});
console.log("底部分页安装监听器已安装");
};
const installTopRoomOrderListener = async () => {
const el = await elUtil.findElementUntilFound('.room-order');
if (elUtil.hasEventListener(el, 'click')) return
elUtil.addEventListenerWithTracking(el, 'click', async (event) => {
const target = event.target;
console.log('顶部房间排序监听器触发了', target.textContent.trim(), target);
await startShieldingLiveRoomList();
InstallBottomPagingListener();
installTopRoomOrderListener();
});
console.log('顶部房间排序监听器已安装');
};
var searchLive = {
InstallLiveTopTabsListener,
installStyle,
startShieldingLiveRoomList,
InstallBottomPagingListener,
installTopRoomOrderListener
};
const isSearch = (url) => {
return url.includes("search.bilibili.com")
};
const currentlyActivatedOptions = async () => {
const el = await elUtil.findElementUntilFound('.vui_tabs--nav-item-active .vui_tabs--nav-text');
const label = el.textContent.trim();
if (label === '直播') {
await searchLive.startShieldingLiveRoomList();
searchLive.InstallLiveTopTabsListener();
searchLive.InstallBottomPagingListener();
elUtil.findElementUntilFound('.live-condition>.vui_button--active').then(activeEl => {
if (activeEl.textContent.trim() !== '主播') {
searchLive.installTopRoomOrderListener();
}
});
}
};
const searchTopTabsIWrapperInstallListener = async () => {
const tempTabs = ['番剧', '影视', '用户'];
const el = await elUtil.findElementUntilFound('.vui_tabs--navbar>ul');
el.addEventListener("click", async (event) => {
const eventTarget = event.target;
if (eventTarget.className !== 'vui_tabs--nav-text') {
return
}
const tabName = eventTarget.textContent.trim();
if (tempTabs.includes(tabName)) {
return
}
if (tabName === '直播') {
searchLive.installTopRoomOrderListener();
return
}
console.log("搜索页顶部选项卡监听器触发了", tabName);
});
console.log("搜索页顶部选项卡安装监听器已安装");
};
const getVideoList$1 = async (css) => {
const elList = await elUtil.findElementsUntilFound(css, {interval: 200});
const list = [];
for (let el of elList) {
const title = el.querySelector(".bili-video-card__info--tit").title;
const userEl = el.querySelector(".bili-video-card__info--owner");
if (userEl === null) {
console.log("获取不到该视频卡片的用户地址，", el);
el?.remove();
continue
}
const userUrl = userEl.getAttribute("href");
if (!userUrl.includes("//space.bilibili.com/")) {
el?.remove();
Tip.infoBottomRight("移除了非视频内容");
console.log("移除了非视频内容", userUrl, el);
continue;
}
const videoUrl = el.querySelector(".bili-video-card__info--right>a")?.href;
if (videoUrl?.includes('live.bilibili.com/')) {
continue
}
const bv = elUtil.getUrlBV(videoUrl);
const uid = elUtil.getUrlUID(userUrl);
const name = userEl.querySelector(".bili-video-card__info--author").textContent.trim();
const bili_video_card__stats_item = el.querySelectorAll('.bili-video-card__stats--item');
let nPlayCount = bili_video_card__stats_item[0]?.textContent.trim();
nPlayCount = sFormatUtil.toPlayCountOrBulletChat(nPlayCount);
let nBulletChat = bili_video_card__stats_item[1]?.textContent.trim();
nBulletChat = sFormatUtil.toPlayCountOrBulletChat(nBulletChat);
let nDuration = el.querySelector('.bili-video-card__stats__duration')?.textContent.trim();
nDuration = sFormatUtil.timeStringToSeconds(nDuration);
list.push({
title,
userUrl,
name,
uid,
bv,
nPlayCount,
nBulletChat,
nDuration,
el,
videoUrl,
insertionPositionEl: el.querySelector(".bili-video-card__info--bottom"),
explicitSubjectEl: el.querySelector(".bili-video-card__info")
});
}
return list;
};
const getTabComprehensiveSortedVideoList = () => {
return getVideoList$1(".video.i_wrapper.search-all-list>.video-list>div");
};
const getOtherVideoList = () => {
return getVideoList$1(".search-page.search-page-video>.video-list.row>div");
};
const startShieldingCSVideoList = async () => {
const list = await getTabComprehensiveSortedVideoList();
for (let videoData of list) {
if (shielding.shieldingVideoDecorated(videoData)) {
continue;
}
shielding.addVideoBlockButton({data: videoData, maskingFunc: startShieldingCSVideoList});
}
};
const startShieldingOtherVideoList = async () => {
const list = await getOtherVideoList();
for (let videoData of list) {
if (shielding.shieldingVideoDecorated(videoData)) {
continue;
}
shielding.addVideoBlockButton({data: videoData, maskingFunc: startShieldingOtherVideoList});
}
};
const getTwTabActiveItem = async () => {
const twoTabActiveItem = await elUtil.findElementUntilFound('.vui_button.vui_button--tab.vui_button--active.mr_sm', {interval: 200});
const twoTabActiveItemLabel = twoTabActiveItem.textContent.trim();
return {el: twoTabActiveItemLabel, label: twoTabActiveItemLabel}
};
const startShieldingVideoList$6 = async () => {
const topTabActiveItem = await elUtil.findElementUntilFound('.vui_tabs--nav-item.vui_tabs--nav-item-active', {interval: 200});
const topTabActiveItemLabel = topTabActiveItem.textContent.trim();
if (topTabActiveItemLabel !== '综合') {
await startShieldingOtherVideoList();
return
}
const {label} = await getTwTabActiveItem();
if (label !== '综合排序') {
await startShieldingOtherVideoList();
return
}
const parseUrl = defUtil.parseUrl(window.location.href);
if (parseUrl.queryParams['page']) {
await startShieldingOtherVideoList();
} else {
await startShieldingCSVideoList();
processingExactSearchVideoCardContent();
}
};
const processingExactSearchVideoCardContent = async () => {
let el;
try {
el = await elUtil.findElementUntilFound('.user-list.search-all-list', {interval: 50, timeout: 4000});
} catch (e) {
return
}
const infoCardEl = el.querySelector('.info-card');
const userNameEl = infoCardEl.querySelector('.user-name');
const name = userNameEl.textContent.trim();
const userUrl = userNameEl.href;
const uid = elUtil.getUrlUID(userUrl);
if (ruleMatchingUtil.exactMatch(ruleKeyListData$1.getPreciseUidArr(), uid)) {
el.remove();
Tip.successBottomRight('屏蔽到用户');
output_informationTab.addInfo(`根据精确uid匹配到用户${name}-【${uid}】`);
return
}
let fuzzyMatch = ruleMatchingUtil.fuzzyMatch(ruleKeyListData$1.getNameArr(), name);
if (fuzzyMatch) {
el.remove();
Tip.infoBottomRight('屏蔽到用户');
output_informationTab.addInfo(`根据模糊用户名【${fuzzyMatch}】匹配到用户${name}-【${uid}】`);
return
}
fuzzyMatch = ruleMatchingUtil.regexMatch(ruleKeyListData$1.getNameCanonical(), name);
if (fuzzyMatch) {
el.remove();
Tip.infoBottomRight('屏蔽到用户');
output_informationTab.addInfo(`根据正则用户名【${fuzzyMatch}】匹配到用户${name}-【${uid}】`);
return
}
const insertionPositionEl = el.querySelector('.info-card.flex_start');
shielding.addBlockButton({
data: {
name,
uid,
insertionPositionEl,
}
});
const videoElList = el.querySelectorAll('.video-list>.video-list-item');
const list = [];
for (let videoEl of videoElList) {
const titleEl = videoEl.querySelector('.bili-video-card__info--right>a');
const videoUrl = titleEl.href;
const bv = elUtil.getUrlBV(videoUrl);
const title = titleEl.textContent.trim();
let nDuration = videoEl.querySelector('.bili-video-card__stats__duration')?.textContent.trim();
nDuration = sFormatUtil.timeStringToSeconds(nDuration);
let nPlayCount = videoEl.querySelector('.bili-video-card__stats--item>span')?.textContent.trim();
nPlayCount = sFormatUtil.toPlayCountOrBulletChat(nPlayCount);
list.push({
title,
userUrl,
name,
uid,
bv,
nPlayCount,
nDuration,
el: videoEl,
videoUrl
});
}
for (let videoData of list) {
shielding.shieldingVideoDecorated(videoData);
}
};
var searchModel = {
isSearch,
searchTopTabsIWrapperInstallListener,
startShieldingVideoList: startShieldingVideoList$6,
currentlyActivatedOptions
};
const getData = (key,defValue=null) => {
const el = document.querySelector('#mk_data');
if (el === null) {
return defValue
}
const text = el.textContent.trim();
const parse = JSON.parse(text);
if (parse[key]) {
return parse[key]
}
return defValue
};
const addData = (key, value) => {
const el = document.querySelector('#mk_data');
if (el === null) {
const mk_data = document.createElement('div');
mk_data.id = 'mk_data';
mk_data.style.display = 'none';
document.head.appendChild(mk_data);
mk_data.textContent = JSON.stringify({[key]: value});
return
}
const txt = el.textContent.trim();
const parse = JSON.parse(txt);
parse[key] = value;
el.textContent = JSON.stringify(parse);
};
const setData = (key, value) => {
addData(key, value);
};
var elData = {
addData,
getData,
setData
};
const isVideoPlayPage = (url) => {
return url.includes("www.bilibili.com/video");
};
const installSingleUserCreatorButton = async () => {
const el = await elUtil.findElementUntilFound('.up-info-container');
const installPositionEl = el.querySelector('.up-info--right');
const butEl = document.createElement("button");
butEl.setAttribute("gz_type", "");
butEl.textContent = "屏蔽";
butEl.style.width = "100%";
butEl.style.display = 'none';
const nameEl = installPositionEl.querySelector('a.up-name');
butEl.addEventListener('click', () => {
const name = nameEl.textContent.trim();
const userUrl = nameEl.href;
const uid = elUtil.getUrlUID(userUrl);
console.log('点击了屏蔽按钮', name, userUrl, uid);
xtip.confirm(`用户uid=${uid}-name=${name}`, {
title: "uid精确屏蔽方式", icon: "a",
btn1: () => {
if (uid === -1) {
Tip.error("该页面数据不存在uid字段");
return;
}
ruleUtil.addRulePreciseUid(uid);
}
});
});
elUtil.addEventListenerWithTracking(installPositionEl, 'mouseover', () => butEl.style.display = '');
elUtil.addEventListenerWithTracking(installPositionEl, 'mouseout', () => butEl.style.display = 'none');
installPositionEl.appendChild(butEl);
Tip.infoBottomRight(`单作者添加屏蔽按钮成功`);
};
const creationTeamInsertsShieldButton = async () => {
const elList = await elUtil.findElementsUntilFound('.container>.membersinfo-upcard-wrap>.membersinfo-upcard');
for (let item of elList) {
const butEL = document.createElement('button');
butEL.className = "gz_button gz_demo";
butEL.textContent = "屏蔽";
butEL.style.display = 'none';
const userUrl = item.querySelector('.avatar').href;
const uid = elUtil.getUrlUID(userUrl);
const name = item.querySelector('.staff-name').textContent.trim();
butEL.addEventListener('click', () => {
xtip.confirm(`uid=${uid}-name=${name}`, {
title: "uid精确屏蔽方式", icon: "a",
btn1: () => {
if (uid === -1) {
Tip.error("该页面数据不存在uid字段");
return;
}
ruleUtil.addRulePreciseUid(uid);
}
});
});
item.appendChild(butEL);
elUtil.addEventListenerWithTracking(item, 'mouseover', () => butEL.style.display = '');
elUtil.addEventListenerWithTracking(item, 'mouseout', () => butEL.style.display = 'none');
}
Tip.infoBottomRight(`创作团队添加屏蔽按钮成功`);
};
const execAuthorAddBlockButton = () => {
elUtil.findElementWithTimeout('.header.can-pointer', {timeout: 4000}).then(res => {
if (res.state) {
creationTeamInsertsShieldButton();
elData.setData('isSingleAuthor', false);
return
}
if (elData.getData('isSingleAuthor', false)) {
return;
}
elData.setData('isSingleAuthor', true);
installSingleUserCreatorButton();
});
};
const getGetTheVideoListOnTheRight$1 = async () => {
await elUtil.findElementUntilFound(".video-page-card-small .b-img img");
const elList = await elUtil.findElementsUntilFound(".video-page-card-small", {interval: 50});
const list = [];
for (let el of elList) {
try {
const elInfo = el.querySelector(".info");
const title = elInfo.querySelector(".title").title;
const name = elInfo.querySelector(".upname .name").textContent.trim();
const userUrl = elInfo.querySelector(".upname>a").href;
const uid = elUtil.getUrlUID(userUrl);
const playInfo = el.querySelector('.playinfo').innerHTML.trim();
const videoUrl = el.querySelector(".info>a").href;
const bv = elUtil.getUrlBV(videoUrl);
let nPlayCount = playInfo.match(/<\/svg>(.*)<svg/s)?.[1].trim();
nPlayCount = sFormatUtil.toPlayCountOrBulletChat(nPlayCount);
let nBulletChat = playInfo.match(/class="dm".+<\/svg>(.+)$/s)?.[1].trim();
nBulletChat = sFormatUtil.toPlayCountOrBulletChat(nBulletChat);
let nDuration = el.querySelector('.duration')?.textContent.trim();
nDuration = sFormatUtil.timeStringToSeconds(nDuration);
list.push({
title,
userUrl,
name,
uid,
bv,
nPlayCount,
nBulletChat,
nDuration,
el,
videoUrl,
insertionPositionEl: el.querySelector(".playinfo"),
explicitSubjectEl: elInfo
});
} catch (e) {
console.error("获取右侧视频列表失败:", e);
}
}
return list;
};
const startShieldingVideoList$5 = () => {
console.time("屏蔽右侧视频列表");
getGetTheVideoListOnTheRight$1().then((videoList) => {
console.timeEnd("屏蔽右侧视频列表");
for (let videoData of videoList) {
if (shielding.shieldingVideoDecorated(videoData)) {
continue;
}
shielding.addVideoBlockButton({data: videoData, maskingFunc: startShieldingVideoList$5});
}
});
};
const findTheExpandButtonForTheListOnTheRightAndBindTheEvent$2 = () => {
setTimeout(() => {
elUtil.findElementUntilFound(".rec-footer", {interval: 2000}).then((el) => {
console.log("找到右侧视频列表的展开按钮", el);
el.addEventListener("click", () => {
startShieldingVideoList$5();
});
});
}, 3000);
};
var videoPlayModel = {
isVideoPlayPage,
startShieldingVideoList: startShieldingVideoList$5,
findTheExpandButtonForTheListOnTheRightAndBindTheEvent: findTheExpandButtonForTheListOnTheRightAndBindTheEvent$2,
execAuthorAddBlockButton
};
const getPlayCountAndBulletChatAndDuration = (el) => {
const playInfo = el.querySelector('.playinfo').innerHTML.trim();
let nPlayCount = playInfo.match(/<\/svg>(.*)<svg/s)?.[1].trim();
nPlayCount = sFormatUtil.toPlayCountOrBulletChat(nPlayCount);
let nBulletChat = playInfo.match(/class="dm-icon".+<\/svg>(.+)$/s)?.[1].trim();
nBulletChat = sFormatUtil.toPlayCountOrBulletChat(nBulletChat);
let nDuration = el.querySelector('.duration')?.textContent.trim();
nDuration = sFormatUtil.timeStringToSeconds(nDuration);
return {
nPlayCount, nBulletChat, nDuration
}
};
const getRightVideoDataList$1=(elList)=>{
const list = [];
for (let el of elList) {
const title = el.querySelector(".title").textContent.trim();
const userInfoEl = el.querySelector(".upname");
const name = userInfoEl.querySelector(".name").textContent.trim();
const userUrl = userInfoEl.href;
const uid = elUtil.getUrlUID(userUrl);
const videoUrl = el.querySelector(".info>a").href;
const bv = elUtil.getUrlBV(videoUrl);
list.push({
...getPlayCountAndBulletChatAndDuration(el), ...{
title,
name,
userUrl,
videoUrl,
uid,
bv,
el,
insertionPositionEl: el.querySelector(".playinfo"),
explicitSubjectEl: el.querySelector(".info")
}
});
}
return list;
};
var generalFuc = {getRightVideoDataList: getRightVideoDataList$1};
const iscCollectionVideoPlayPage = (url) => {
return url.includes("www.bilibili.com/list/ml")
};
const getGetTheVideoListOnTheRight = async () => {
const elList = await elUtil.findElementsUntilFound(".recommend-list-container>.video-card");
return generalFuc.getRightVideoDataList(elList);
};
const startShieldingVideoList$4 = () => {
getGetTheVideoListOnTheRight().then((videoList) => {
const css = {right: "123px"};
for (let videoData of videoList) {
if (shielding.shieldingVideoDecorated(videoData)) continue;
videoData.css = css;
shielding.addVideoBlockButton({data: videoData, maskingFunc: startShieldingVideoList$4});
}
});
};
const findTheExpandButtonForTheListOnTheRightAndBindTheEvent$1 = () => {
setTimeout(() => {
elUtil.findElementUntilFound(".rec-footer", {interval: 2000}).then((el) => {
el.addEventListener("click", () => {
startShieldingVideoList$4();
});
});
}, 3000);
};
var collectionVideoPlayPageModel = {
iscCollectionVideoPlayPage,
startShieldingVideoList: startShieldingVideoList$4,
findTheExpandButtonForTheListOnTheRightAndBindTheEvent: findTheExpandButtonForTheListOnTheRightAndBindTheEvent$1
};
const addEventListenerUrlChange = (callback) => {
let oldUrl = window.location.href;
setInterval(() => {
const newUrl = window.location.href;
if (oldUrl === newUrl) return;
oldUrl = newUrl;
const title = document.title;
callback(newUrl, oldUrl, title);
}, 1000);
};
const addEventListenerNetwork = (callback) => {
new PerformanceObserver(() => {
const entries = performance.getEntriesByType('resource');
const windowUrl = window.location.href;
const winTitle = document.title;
for (let entry of entries) {
const url = entry.name;
const initiatorType = entry.initiatorType;
if (initiatorType === "img" || initiatorType === "css" || initiatorType === "link" || initiatorType === "beacon") {
continue;
}
callback(url, windowUrl,winTitle, initiatorType);
}
performance.clearResourceTimings();//清除资源时间
}).observe({entryTypes: ['resource']});
};
function watchElementListLengthWithInterval(selector, callback, config={}) {
const defConfig = {};
config = {...defConfig, ...config};
let previousLength = -1;
const timer = setInterval(() => {
if (previousLength === -1) {
previousLength = document.querySelectorAll(selector).length;
return
}
const currentElements = document.querySelectorAll(selector);
const currentLength = currentElements.length;
if (currentLength !== previousLength) {
previousLength = currentLength;
callback({
action: currentLength > previousLength ? 'add' : 'del',
elements: currentElements,
length: currentLength
}
);
}
},
config.interval
);
return stop = () => {
clearInterval(timer);
};
}
var watch = {
addEventListenerUrlChange,
addEventListenerNetwork,
watchElementListLengthWithInterval
};
const isLiveRoom = (url) => {
return url.search('/live.bilibili.com/\\d+') !== -1;
};
const getChatItems = async () => {
const elList = await elUtil.findElementsUntilFound("#chat-items>div");
if (elList.length >= 200) {
for (let i = 0; i < 100; i++) {
elList[i]?.remove();
}
console.log("弹幕列表超过200，已删除前100条");
}
const list = [];
for (let el of elList) {
if (el.className === "chat-item convention-msg border-box") {
continue;
}
if (el.className === "chat-item misc-msg guard-buy") {
continue;
}
const name = el.getAttribute("data-uname");
if (name === null) {
continue;
}
const uid = el.getAttribute("data-uid");
const content = el.getAttribute("data-danmaku");
const timeStamp = el.getAttribute("data-timestamp");
const fansMedalEl = el.querySelector(".fans-medal-content");
const fansMedal = fansMedalEl === null ? null : fansMedalEl.textContent.trim();
list.push({
name,
uid,
content,
timeStamp,
fansMedal,
el,
insertionPositionEl: el,
explicitSubjectEl: el
});
}
return list;
};
const startShieldingLiveChatContents = async () => {
const commentsDataList = await getChatItems();
for (let commentsData of commentsDataList) {
if (shielding.shieldingLiveRoomContentDecorated(commentsData)) {
continue;
}
shielding.addLiveContentBlockButton({data: commentsData, maskingFunc: startShieldingLiveChatContents});
}
};
const addWatchLiveRoomChatItemsListener = () => {
const throttle = defUtil.throttle(startShieldingLiveChatContents, 1000);
watch.watchElementListLengthWithInterval("#chat-items>div", throttle);
};
var liveRoomModel = {
isLiveRoom,
addWatchLiveRoomChatItemsListener
};
const getVideDataList = async (isWeekly = false) => {
const css = isWeekly ? ".video-list>.video-card" : ".card-list>.video-card";
const elList = await elUtil.findElementsUntilFound(css);
const list = [];
for (let el of elList) {
const videoCardInfoEl = el.querySelector(".video-card__info");
const title = videoCardInfoEl.querySelector(".video-name").title.trim();
const name = videoCardInfoEl.querySelector(".up-name__text").title;
const videoUrl = el.querySelector('.video-card__content>a')?.href || null;
const bv = elUtil.getUrlBV(videoUrl);
let nPlayCount = el.querySelector('.play-text').textContent.trim();
nPlayCount = sFormatUtil.toPlayCountOrBulletChat(nPlayCount);
let nBulletChat = el.querySelector('.like-text').textContent.trim();
nBulletChat = sFormatUtil.toPlayCountOrBulletChat(nBulletChat);
list.push({
el,
title,
name,
uid: -1,
videoUrl,
bv,
nPlayCount,
nBulletChat,
nDuration: -1,
insertionPositionEl: videoCardInfoEl.querySelector("div"),
explicitSubjectEl: videoCardInfoEl
});
}
return list;
};
const startShieldingVideoList$3 = async (isWeekly = false) => {
const list = await getVideDataList(isWeekly);
for (let videoData of list) {
if (shielding.shieldingVideoDecorated(videoData)) {
continue;
}
shielding.addPopularVideoBlockButton({data: videoData, maskingFunc: startShieldingVideoList$3});
}
};
var popularAll = {
startShieldingVideoList: startShieldingVideoList$3
};
const generalUrl=[
"popular/rank/all",
"popular/rank/douga",
"popular/rank/music",
"popular/rank/dance",
"popular/rank/game",
"popular/rank/knowledge",
"popular/rank/tech",
"popular/rank/sports",
"popular/rank/car",
"popular/rank/life",
"popular/rank/food",
"popular/rank/animal",
"popular/rank/kichiku",
"popular/rank/fashion",
"popular/rank/ent",
"popular/rank/cinephile",
"popular/rank/origin",
"popular/rank/rookie"
];
const isPopularHistory = (url) => {
return url.includes("popular/history")
};
const isPopularAllPage = (url) => {
return url.includes("www.bilibili.com/v/popular/all");
};
const isPopularWeeklyPage = (url) => {
return url.includes("www.bilibili.com/v/popular/weekly");
};
const isGeneralPopularRank=(url)=>{
return generalUrl.some(itemUrl => url.includes(itemUrl));
};
const getVideoDataList$2 = async () => {
const elList = await elUtil.findElementsUntilFound(".rank-list>li");
const list = [];
for (let el of elList) {
const title = el.querySelector(".title").textContent.trim();
const userUrl = el.querySelector(".detail>a").href;
const uid = elUtil.getUrlUID(userUrl);
const name = el.querySelector(".up-name").textContent.trim();
const detailStateEls = el.querySelectorAll('.detail-state>.data-box');
let nPlayCount = detailStateEls[0].textContent.trim();
nPlayCount = sFormatUtil.toPlayCountOrBulletChat(nPlayCount);
let nBulletChat = detailStateEls[1].textContent.trim();
nBulletChat = sFormatUtil.toPlayCountOrBulletChat(nBulletChat);
const videoUrl = el.querySelector('.img>a')?.href || null;
const bv = elUtil.getUrlBV(videoUrl);
list.push({
title,
userUrl,
uid,
name,
videoUrl,
bv,
nPlayCount,
nBulletChat,
nDuration: -1,
el,
insertionPositionEl: el.querySelector(".detail-state"),
explicitSubjectEl: el.querySelector(".info")
});
}
return list;
};
const startShieldingRankVideoList = async () => {
const list = await getVideoDataList$2();
for (let videoData of list) {
if (shielding.shieldingVideoDecorated(videoData)) {
continue;
}
shielding.addPopularVideoBlockButton({data: videoData, maskingFunc: startShieldingRankVideoList});
}
};
var popular = {
isPopularHistory,
isPopularAllPage,
isGeneralPopularRank,
isPopularWeeklyPage,
startShieldingRankVideoList,
};
const isSpacePage = (url) => {
return url.startsWith('https://space.bilibili.com/')
};
const isPersonalHomepage = () => {
const data = defUtil.getLocalStorage('time_tracker', true, {});
const dataKeys = Object.keys(data);
if (dataKeys.length === 0) {
return false
}
const tempUid=dataKeys[0];
const urlUID = elUtil.getUrlUID(window.location.href);
try {
return parseInt(tempUid) === urlUID;
} catch (e) {
console.log('isPersonalHomepage出现错误',e);
return false
}
};
const __insertButton = (el, label, callback = null) => {
debugger
const liEl = document.createElement("li");
liEl.textContent = label;
liEl.className = 'be-dropdown-item';
el.insertAdjacentElement('afterbegin', liEl);
liEl.addEventListener('click', callback);
};
const initializePageBlockingButton = async () => {
const is = isPersonalHomepage();
if (is) return
const el = await elUtil.findElementUntilFound('.be-dropdown.h-add-to-black .be-dropdown-menu.menu-align-');
const urlUID = elUtil.getUrlUID(window.location.href);
const nameEl = await elUtil.findElementUntilFound('#h-name');
if (ruleKeyListData$1.getPreciseUidArr().includes(urlUID)) {
xtip.msg('当前用户为已标记uid黑名单');
return
}
const name = nameEl.textContent;
const name_label = '用户名精确屏蔽';
__insertButton(el, name_label, () => {
xtip.confirm(`屏蔽的对象为${urlUID}【${name}】`, {
title: name_label, icon: "a",
btn1: () => {
ruleUtil.addRulePreciseName(name);
}
});
});
const uid_label = 'uid精确屏蔽';
__insertButton(el, uid_label, () => {
xtip.confirm(`屏蔽的对象为${urlUID}【${name}】`, {
title: uid_label, icon: "a",
btn1: () => {
ruleUtil.addRulePreciseUid(urlUID);
}
});
});
Tip.infoBottomRight('用户空间页面屏蔽按钮插入成功');
};
var space = {
isPersonalHomepage,
initializePageBlockingButton,
isSpacePage
};
const isDynamicPage = (url) => {
return url.search("space.bilibili.com/\\d+/dynamic") !== -1;
};
const getDataList = async () => {
const elList = await elUtil.findElementsUntilFound(".bili-dyn-list__items>.bili-dyn-list__item");
const list = [];
for (let el of elList) {
const videoCardEl = el.querySelector(".bili-dyn-card-video__title");
const name = el.querySelector(".bili-dyn-title").textContent.trim();
const tagEl = el.querySelector(".bili-dyn-topic__text");
const data = {el, name};
if (tagEl !== null) {
data.tag = tagEl.textContent.trim();
}
data.judgmentVideo = videoCardEl !== null;
if (data.judgmentVideo) {
data.title = videoCardEl.textContent.trim();
} else {
const contentTitleEL = el.querySelector(".dyn-card-opus>.dyn-card-opus__title");
const contentTitle = contentTitleEL === null ? "" : contentTitleEL.textContent.trim();
const contentElBody = el.querySelector(".bili-rich-text").textContent.trim();
data.content = contentTitle + contentElBody;
}
list.push(data);
}
return list;
};
const startShieldingDynamicContent = async () => {
const personalHomepage = space.isPersonalHomepage();
if (personalHomepage) return;
const list = await getDataList();
for (let dynamicContent of list) {
shielding.shieldingDynamicDecorated(dynamicContent);
}
};
const startThrottleShieldingDynamicContent = defUtil.throttle(startShieldingDynamicContent, 2000);
var dynamic = {
isDynamicPage,
startThrottleShieldingDynamicContent
};
const isVideoPlayWatchLaterPage = (url) => {
return url.startsWith("https://www.bilibili.com/list/watchlater")
};
const getRightVideoDataList = async () => {
const elList = await elUtil.findElementsUntilFound(".recommend-video-card.video-card");
return generalFuc.getRightVideoDataList(elList);
};
const startShieldingVideoList$2 = async () => {
const videoList = await getRightVideoDataList();
const css = {right: "123px"};
for (let videoData of videoList) {
videoData.css = css;
if (shielding.shieldingVideoDecorated(videoData)) continue;
shielding.addVideoBlockButton({data: videoData, maskingFunc: startShieldingVideoList$2});
}
};
const startDebounceShieldingVideoList = defUtil.debounce(startShieldingVideoList$2, 1000);
const findTheExpandButtonForTheListOnTheRightAndBindTheEvent = () => {
elUtil.findElementsAndBindEvents(".rec-footer", startDebounceShieldingVideoList);
};
var videoPlayWatchLater = {
isVideoPlayWatchLaterPage,
startDebounceShieldingVideoList,
findTheExpandButtonForTheListOnTheRightAndBindTheEvent
};
const isLiveSection = (url) => {
return url.includes("live.bilibili.com/p/eden/area-tags")
};
const getRoomCardDataList = async () => {
const elList = await elUtil.findElementsUntilFound("#room-card-list>div");
const list = [];
for (let el of elList) {
const liveUrl = el.querySelector("#card").href;
const name = el.querySelector(".Item_nickName_KO2QE").textContent.trim();
const title = el.querySelector(".Item_roomTitle_ax3eD").textContent.trim();
const partition = el.querySelector(".Item_area-name_PXDG4")?.textContent.trim() || null;
const popularity = el.querySelector(".Item_onlineCount_FmOW6").textContent.trim();
list.push({liveUrl, name, title, partition, popularity, el});
}
return list;
};
const startShieldingLiveRoom$1 = async () => {
const liveList = await getRoomCardDataList();
for (let liveData of liveList) {
shielding.shieldingLiveRoomDecorated(liveData);
}
};
var liveSectionModel = {
isLiveSection,
startShieldingLiveRoom: startShieldingLiveRoom$1
};
const isLiveHomePage = (url) => {
return url.includes("https://live.bilibili.com/?spm_id_from=333.1007.0.0") ||
url === "https://live.bilibili.com/"
};
const getTopLiveRoomDataList = async () => {
const verification = await elUtil.findElementUntilFound(".v-top>.aside-item .t-left.aside-item-tips.p-absolute.w-100.border-box");
if (verification.textContent.trim() === "--") {
return await getTopLiveRoomDataList();
}
const elList = await elUtil.findElementsUntilFound(".v-top>.aside-item", {interval: 2000});
const list = [];
for (let el of elList) {
const classList = el.classList;
const active = classList.contains("active");
const title = el.getAttribute("title");
const {up_id: uid, room_id} = JSON.parse(el.getAttribute("data-report"));
const liveUrl = `https://live.bilibili.com/${room_id}`;
list.push({title, uid, active, liveUrl, el});
}
return list;
};
const getLiveRoomDataList = async () => {
const elList = await elUtil.findElementsUntilFound(".room-card-wrapper.p-relative.dp-i-block");
const list = [];
for (let el of elList) {
const cardEl = el.querySelector(".room-card-ctnr.p-relative.w-100");
const cardData = JSON.parse(cardEl.getAttribute("data-bl-report-click") || "");
const {up_id: uid, room_id} = cardData.msg;
const liveUrl = `https://live.bilibili.com/${room_id}`;
const name = el.querySelector(".room-anchor>span").textContent.trim();
const title = el.querySelector(".room-title.card-text").textContent.trim();
const partition = el.querySelector(".area-name").textContent.trim();
const popularity = el.querySelector(".room-anchor .v-middle").textContent.trim();
list.push({name, title, partition, popularity, liveUrl, uid, el});
}
return list;
};
const startShieldingLiveRoom = async () => {
const list = await getLiveRoomDataList();
for (let liveData of list) {
shielding.shieldingLiveRoomDecorated(liveData);
}
};
const startShieldingTopLiveRoom = async () => {
const list = await getTopLiveRoomDataList();
for (let liveData of list) {
shielding.shieldingLiveRoomDecorated(liveData);
}
};
var liveHome = {
isLiveHomePage,
startShieldingLiveRoom,
startShieldingTopLiveRoom
};
const getBewlyEl = async () => {
let el = await elUtil.findElementUntilFound('#bewly', {interval: 500});
return el.shadowRoot;
};
const isBEWLYPage = (url) => {
return url.includes('www.bilibili.com/?page=') ||
url === 'https://www.bilibili.com/'
|| url.startsWith('https://www.bilibili.com/?spm_id_from=')
};
const getVideoList = async () => {
const beEl = await getBewlyEl();
const elList = await elUtil.findElementsUntilFound('.video-card.group', {doc: beEl});
const list = [];
for (let el of elList) {
const parentElement = el.parentElement.parentElement;
const title = el.querySelector('.keep-two-lines>a[title]').textContent.trim();
const userUrlEl = el.querySelector('.channel-name');
const userUrl = userUrlEl.href;
const uid = elUtil.getUrlUID(userUrl);
const name = userUrlEl.textContent.trim();
const playInfoEl = el.querySelector('[flex="~ items-center gap-1 wrap"]>div');
let playCount = playInfoEl.querySelector('span:first-child')?.textContent.trim() || null;
playCount = sFormatUtil.toPlayCountOrBulletChat(playCount);
let bulletChat = playInfoEl.querySelector('span:last-of-type')?.textContent.trim() || null;
if (playInfoEl.querySelectorAll('span').length < 2) {
bulletChat = -1;
} else {
bulletChat = sFormatUtil.toPlayCountOrBulletChat(bulletChat);
}
let nDuration = el.querySelector('[class*="group-hover:opacity-0"]')?.textContent.trim() || null;
nDuration = sFormatUtil.timeStringToSeconds(nDuration);
const videoUrl = el.querySelector('[href*="https://www.bilibili.com/video"]')?.href;
const bv=elUtil.getUrlBV(videoUrl);
const insertionPositionEl = el.querySelector('[class="group/desc"]');
list.push({
title,
name,
uid,
bv,
userUrl,
videoUrl,
playCount,
bulletChat,
nDuration,
el: parentElement,
insertionPositionEl,
explicitSubjectEl: parentElement
});
}
return list
};
const getRightTabs = async () => {
const beEl = await getBewlyEl();
const els = await elUtil.findElementsUntilFound(".dock-content-inner>.b-tooltip-wrapper", {doc: beEl});
const list = [];
for (let el of els) {
const label = el.querySelector('.b-tooltip').textContent.trim();
const active = !!el.querySelector('.dock-item.group.active');
list.push({label, active, el});
}
return list;
};
const getHistoryVideoDataList = async () => {
const beEL = await getBewlyEl();
const elList = await elUtil.findElementsUntilFound("a.group[flex][cursor-pointer]", {doc: beEL});
const list = [];
for (let el of elList) {
const titleEl = el.querySelector('h3.keep-two-lines');
const videoUrlEl = titleEl.parentElement;
const userEl = videoUrlEl.nextElementSibling;
const videoUrl = videoUrlEl.href;
const bv=elUtil.getUrlBV(videoUrl);
const userUrl = userEl.href;
const uid = elUtil.getUrlUID(userUrl);
const name = userEl.textContent.trim();
const title = titleEl?.textContent.trim();
const tempTime = el.querySelector('div[pos][rounded-8]')?.textContent.trim().split(/[\t\r\f\n\s]*/g).join("");
const match = tempTime?.match(/\/(.*)/);
let nDuration = match?.[1];
nDuration = sFormatUtil.timeStringToSeconds(nDuration);
list.push({
title,
userUrl,
name,
uid,
videoUrl,
nDuration,
bv,
el,
insertionPositionEl: videoUrlEl.parentElement,
explicitSubjectEl: el
});
}
return list
};
const startShieldingHistoryVideoList = async () => {
const list = await getHistoryVideoDataList();
for (let videoData of list) {
if (shielding.shieldingVideoDecorated(videoData)) {
continue
}
shielding.addVideoBlockButton({data: videoData, maskingFunc: startShieldingHistoryVideoList});
}
};
const startShieldingVideoList$1 = async () => {
const list = await getVideoList();
for (let videoData of list) {
if (shielding.shieldingVideoDecorated(videoData)) {
continue
}
addVideoBlockButton({data: videoData, maskingFunc: startShieldingVideoList$1});
}
};
const intervalExecutionStartShieldingVideo$2 = () => {
const res = shielding.intervalExecutionStartShieldingVideoInert(startShieldingVideoList$1, '视频');
return () => {
return res
}
};
const intervalExecutionStartShieldingHistoryVideo = () => {
const res = shielding.intervalExecutionStartShieldingVideoInert(startShieldingHistoryVideoList, '历史记录');
return () => {
return res
}
};
const startShieldingVideo$1 = intervalExecutionStartShieldingVideo$2();
const startShieldingHistoryVideo = intervalExecutionStartShieldingHistoryVideo();
const rightTabsInsertListener = () => {
getRightTabs().then(list => {
for (let {el, label, active} of list) {
el.addEventListener('click', () => {
console.log('右侧选项卡栏点击了' + label, active);
if (label === '首页') {
homeTopTabsInsertListener();
startShieldingVideo$1().start();
} else {
startShieldingVideo$1().stop();
}
if (label === '观看历史') {
startShieldingHistoryVideo().start();
} else {
startShieldingHistoryVideo().stop();
}
}
);
}
}
);
};
const getHomeTopTabs = async () => {
const beEl = await getBewlyEl();
const els = beEl.querySelectorAll('.home-tabs-inside>[data-overlayscrollbars-contents]>button');
const list = [];
for (let el of els) {
const label = el.textContent.trim();
const active = el.classList.contains('tab-activated');
list.push({label, active, el});
}
if (list.some(tab => tab.active === true)) {
return list
}
return await getHomeTopTabs()
};
const excludeTabNames = ['正在关注', '订阅剧集', '直播'];
const excludeRankingLeftTabNames = ['番剧', '综艺', '电视剧', '纪录片', '中国动画'];
const homeTopTabsInsertListener = () => {
getHomeTopTabs().then(list => {
for (let {el, label} of list) {
el.addEventListener('click', () => {
console.log('点击了' + label);
if (excludeTabNames.includes(label)) {
startShieldingVideo$1().stop();
return
}
if (label === '排行') {
rankingLeftTabsInsertListener();
}
startShieldingVideo$1().start();
});
}
});
};
const getRankingLeftTabs = async () => {
const beEl = await getBewlyEl();
const elList = await elUtil.findElementsUntilFound('ul[flex="~ col gap-2"]>li', {doc: beEl});
const list = [];
for (let el of elList) {
const label = el.textContent.trim();
list.push({label, el});
}
return list
};
const rankingLeftTabsInsertListener = () => {
getRankingLeftTabs().then(list => {
for (let {el, label} of list) {
el.addEventListener('click', () => {
console.log('点击了' + label);
if (excludeRankingLeftTabNames.includes(label)) {
startShieldingVideo$1().stop();
return
}
startShieldingVideo$1().start();
});
}
});
};
const addVideoBlockButton = (data) => {
shielding.addBlockButton(data, "gz_shielding_button", ["right", 'bottom']);
};
const installBEWLStyle = () => {
getBewlyEl().then(el => {
gz_ui_css.addStyle(el, el);
});
};
const searchBoxInsertListener = async () => {
const beEl = await getBewlyEl();
const input = await elUtil.findElementUntilFound('[placeholder="搜索观看历史"]', {doc: beEl});
input.addEventListener('keydown', (event) => {
if (event.key === 'Enter' || event.keyCode === 13) {
console.log('回车键被按下');
if (input['value'].length === 0) return
setTimeout(startShieldingHistoryVideoList, 1500);
}
});
};
const startRun$1 = async (url) => {
const parseUrl = defUtil.parseUrl(url);
const {page} = parseUrl.queryParams;
installBEWLStyle();
if (page === 'Home' || url === 'https://www.bilibili.com/') {
startShieldingVideo$1().start();
homeTopTabsInsertListener();
}
if (page === 'History') {
startShieldingHistoryVideo().start();
searchBoxInsertListener();
}
rightTabsInsertListener();
};
var compatibleBewlyBewly = {
startRun: startRun$1,
isBEWLYPage,
};
const isNewHistoryPage = (url) => {
return url.includes('://www.bilibili.com/history')
};
const getDuration = (str) => {
if (str === null) {
return -1
}
if (str.includes('已看完') || str === '') {
return -1
} else {
const match = str?.match(/\/(.*)/);
if (match) {
return sFormatUtil.timeStringToSeconds(match[1]);
}
}
return -1
};
const getVideoDataList$1 = async () => {
const elList = await elUtil.findElementsUntilFound('.section-cards.grid-mode>div');
const list = [];
for (let el of elList) {
const titleEl = el.querySelector('.bili-video-card__title');
const title = titleEl.textContent.trim();
const videoUrl = titleEl.firstElementChild.href||null;
if (videoUrl?.includes('live.bilibili.com')) {
continue
}
const bv=elUtil.getUrlBV(videoUrl);
const userEl = el.querySelector('.bili-video-card__author');
const cardTag = el.querySelector('.bili-cover-card__tag')?.textContent.trim() || null;
const name = userEl.textContent.trim();
const userUrl = userEl.href;
const uid = elUtil.getUrlUID(userUrl);
let nDuration = -1;
if (cardTag !== '专栏') {
nDuration = el.querySelector('.bili-cover-card__stat')?.textContent.trim() || null;
nDuration = getDuration(nDuration);
}
const tempEL = el.querySelector('.bili-video-card__details');
list.push({
title,
videoUrl,
name,
userUrl,
nDuration,
uid,
el,
bv,
insertionPositionEl: tempEL,
explicitSubjectEl: tempEL
});
}
return list
};
const startShieldingVideoList = async () => {
const list = await getVideoDataList$1();
for (let videoData of list) {
if (shielding.shieldingVideoDecorated(videoData)) {
continue;
}
shielding.addBlockButton({data: videoData, maskingFunc: startShieldingVideoList}, "gz_shielding_button");
}
};
const intervalExecutionStartShieldingVideo$1 = () => {
const res = shielding.intervalExecutionStartShieldingVideoInert(startShieldingVideoList, '历史记录项');
return () => {
return res
}
};
const executionStartShieldingVideo = intervalExecutionStartShieldingVideo$1();
const getTopFilterLabel = async () => {
const el = await elUtil.findElementUntilFound('.radio-filter>.radio-filter__item--active');
return el.textContent?.trim()
};
const topFilterInsertListener = () => {
elUtil.findElementUntilFound('.radio-filter').then((el => {
el.addEventListener('click', (e) => {
const target = e.target;
const label = target.textContent?.trim();
console.log(`点击了${label}`);
if (label === '直播') {
executionStartShieldingVideo().stop();
return
}
executionStartShieldingVideo().start();
});
}));
};
const startRun = () => {
getTopFilterLabel().then(label => {
if (label === '直播') {
return
}
executionStartShieldingVideo().start();
});
topFilterInsertListener();
};
var newHistory = {
isNewHistoryPage,
intervalExecutionStartShieldingVideo: intervalExecutionStartShieldingVideo$1,
startRun
};
const isOldHistory = (url) => {
return url.includes('https://www.bilibili.com/account/history')
};
const getVideoDataList = async () => {
const elList = await elUtil.findElementsUntilFound('#history_list>.history-record');
const list = [];
for (let el of elList) {
const labelEL = el.querySelector('.cover-contain>.label');
if (labelEL !== null) {
const label = labelEL.textContent.trim();
console.log(`排除${label}`);
continue
}
const titleEl = el.querySelector('.title');
const userEl = el.querySelector('.w-info>span>a');
const title = titleEl.textContent.trim();
const videoUrl = titleEl.href;
const bv = elUtil.getUrlBV(videoUrl);
const name = userEl.textContent.trim();
const userUrl = userEl.href;
const uid = elUtil.getUrlUID(userUrl);
list.push({
title,
videoUrl,
name,
userUrl,
uid,
el,
bv,
explicitSubjectEl: el.querySelector('.r-txt'),
insertionPositionEl: el.querySelector('.subtitle')
});
}
return list
};
const startShieldingVideo = async () => {
console.log('开始屏蔽旧版历史记录视频列表');
const list = await getVideoDataList();
const css = {right: "45px"};
for (let videoData of list) {
if (shielding.shieldingVideoDecorated(videoData)) {
continue;
}
videoData.css = css;
shielding.addVideoBlockButton({data: videoData, maskingFunc: startShieldingVideo});
}
console.log('屏蔽旧版历史记录视频列表完成');
};
const intervalExecutionStartShieldingVideo = () => {
setInterval(startShieldingVideo, 2000);
};
var oldHistory = {
isOldHistory,
intervalExecutionStartShieldingVideo
};
const bOnlyTheHomepageIsBlocked$1 = localMKData.getBOnlyTheHomepageIsBlocked();
const adaptationBAppCommerce = localMKData.getAdaptationBAppCommerce();
const compatible_BEWLY_BEWLY$1 = localMKData.isCompatible_BEWLY_BEWLY();
const staticRoute = (title, url) => {
console.log("静态路由", title, url);
if (compatible_BEWLY_BEWLY$1 && compatibleBewlyBewly.isBEWLYPage(url)) {
compatibleBewlyBewly.startRun(url);
return;
}
if (bilibiliHome.isHome(url, title)) {
if (compatible_BEWLY_BEWLY$1) {
return;
}
if (adaptationBAppCommerce) {
bilibiliHome.startIntervalShieldingGateVideoList();
}
bilibiliHome.scrollMouseUpAndDown().then(() => bilibiliHome.startDebounceShieldingChangeVideoList());
bilibiliHome.startClearExcessContentList();
bilibiliHome.deDesktopDownloadTipEl();
bilibiliHome.startDebounceShieldingHomeVideoList();
}
if (bOnlyTheHomepageIsBlocked$1) return;
if (searchModel.isSearch(url)) {
searchModel.searchTopTabsIWrapperInstallListener();
searchModel.startShieldingVideoList();
searchModel.currentlyActivatedOptions();
searchLive.installStyle();
}
if (videoPlayModel.isVideoPlayPage(url)) {
videoPlayModel.startShieldingVideoList();
videoPlayModel.findTheExpandButtonForTheListOnTheRightAndBindTheEvent();
videoPlayModel.execAuthorAddBlockButton();
}
if (collectionVideoPlayPageModel.iscCollectionVideoPlayPage(url)) {
collectionVideoPlayPageModel.startShieldingVideoList();
collectionVideoPlayPageModel.findTheExpandButtonForTheListOnTheRightAndBindTheEvent();
}
if (liveRoomModel.isLiveRoom(url)) {
liveRoomModel.addWatchLiveRoomChatItemsListener();
}
if (popular.isPopularAllPage(url) || popular.isPopularHistory(url)) {
popularAll.startShieldingVideoList();
}
if (popular.isPopularWeeklyPage(url)) {
popularAll.startShieldingVideoList(true);
}
if (popular.isGeneralPopularRank(url)) {
popular.startShieldingRankVideoList();
}
if (topicDetail.isTopicDetailPage(url)) {
topicDetail.startShielding();
}
if (dynamic.isDynamicPage(url)) {
dynamic.startThrottleShieldingDynamicContent();
}
if (videoPlayWatchLater.isVideoPlayWatchLaterPage(url)) {
videoPlayWatchLater.startDebounceShieldingVideoList();
videoPlayWatchLater.findTheExpandButtonForTheListOnTheRightAndBindTheEvent();
}
if (liveSectionModel.isLiveSection(url)) {
liveSectionModel.startShieldingLiveRoom();
}
if (liveHome.isLiveHomePage(url)) {
liveHome.startShieldingLiveRoom();
liveHome.startShieldingTopLiveRoom();
}
if (newHistory.isNewHistoryPage(url)) {
newHistory.startRun();
}
if (oldHistory.isOldHistory(url)) {
oldHistory.intervalExecutionStartShieldingVideo();
}
if (space.isSpacePage(url)) {
space.initializePageBlockingButton();
}
};
const dynamicRouting = (title, url) => {
console.log("动态路由", title, url);
if (bOnlyTheHomepageIsBlocked$1) return;
if (searchModel.isSearch(url)) {
searchModel.startShieldingVideoList();
}
if (videoPlayModel.isVideoPlayPage(url)) {
videoPlayModel.startShieldingVideoList();
videoPlayModel.execAuthorAddBlockButton();
}
if (popular.isPopularAllPage(url) || popular.isPopularHistory(url)) {
popularAll.startShieldingVideoList();
}
if (popular.isPopularWeeklyPage(url)) {
popularAll.startShieldingVideoList(true);
}
if (popular.isGeneralPopularRank(url)) {
popular.startShieldingRankVideoList();
}
if (dynamic.isDynamicPage(url)) {
dynamic.startThrottleShieldingDynamicContent();
}
};
var router = {
staticRoute,
dynamicRouting
};
const bOnlyTheHomepageIsBlocked = localMKData.getBOnlyTheHomepageIsBlocked();
const compatible_BEWLY_BEWLY = localMKData.isCompatible_BEWLY_BEWLY();
const observeNetwork = (url, windowUrl,winTitle, initiatorType) => {
if (bOnlyTheHomepageIsBlocked) {
if (!bilibiliHome.isHome(windowUrl, winTitle)) {
return;
}
}
if (url.startsWith("https://api.bilibili.com/x/web-interface/wbi/index/top/feed/rcmd?web_location=")) {
if (compatible_BEWLY_BEWLY) {
return;
}
bilibiliHome.startDebounceShieldingChangeVideoList();
bilibiliHome.startDebounceShieldingHomeVideoList();
console.log("检测到首页加载了换一换视频列表和其下面的视频列表");
return;
}
if (url.startsWith("https://api.bilibili.com/x/v2/reply/wbi/main?oid=")) {
console.log("检测到评论区楼主评论加载了");
commentSectionModel.startShieldingComments();
return;
}
if (url.startsWith("https://api.bilibili.com/x/v2/reply/reply?oid=")) {
console.log("检测到评论区楼主层中的子层评论列表加载了");
commentSectionModel.startShieldingComments();
}
if (url.startsWith("https://api.bilibili.com/x/web-interface/popular?ps=")) {
popularAll.startShieldingVideoList();
}
if (url.startsWith("https://api.bilibili.com/x/web-interface/popular/series/one?number=")) {
popularAll.startShieldingVideoList(true);
}
if (url.startsWith("https://api.bilibili.com/x/polymer/web-dynamic/v1/feed/space?offset=")) {
console.log("检测到用户动态加载了");
dynamic.startThrottleShieldingDynamicContent();
}
if (url.startsWith("https://api.live.bilibili.com/xlive/web-interface/v1/second/getList?platform=web&parent_area_id=")) {
console.log("检测到直播间加载了分区下的房间列表");
liveSectionModel.startShieldingLiveRoom();
}
if (url.startsWith("https://api.live.bilibili.com/xlive/web-interface/v1/index/getList?platform=web")) {
console.log("检测到直播间加载了推荐房间列表");
liveHome.startShieldingLiveRoom();
}
};
var observeNetwork$1 = {
observeNetwork
};
gmUtil.addGMMenu('主面板', () => {
mainDrawer.showDrawer();
},'Q');
gmUtil.addGMMenu('脚本主页', () => {
const aEl = document.createElement('a');
aEl.target = '_blank';
aEl.href = 'https://greasyfork.org/zh-CN/scripts/461382';
aEl.click();
},'W');
router.staticRoute(document.title, window.location.href);
watch.addEventListenerUrlChange((newUrl, oldUrl, title) => {
router.dynamicRouting(title, newUrl);
});
watch.addEventListenerNetwork((url, windowUrl, winTitle, initiatorType) => {
observeNetwork$1.observeNetwork(url, windowUrl, winTitle, initiatorType);
});
document.addEventListener('keydown', function (event) {
if (event.key === "`") {
mainDrawer.showDrawer();
}
});
})(Vue, Dexie);