`;
},
renderConfigTextForm() {
const configToExport = structuredClone(State.config);
delete configToExport.general;
if (Array.isArray(configToExport.rules)) {
configToExport.rules.forEach(rule => {
if (rule.params && rule.params.length === 0) { delete rule.params; }
if (rule.transform && rule.transform.length === 0) { delete rule.transform; }
if (rule.enabled === true) { delete rule.enabled; }
if (rule.applyGeneral === true) { delete rule.applyGeneral; }
});
}
const configString = JSON.stringify(configToExport, null, 2);
return `
`;
},
};
// --- Events (事件处理与数据逻辑) ---
const Events = {
_getCurrentContext() {
const isGeneral = State.ui.activeTab === GENERAL_TAB_ID;
if (isGeneral) {
return {
isGeneral: true,
params: State.config.general.params || [],
rule: null
};
}
const rule = State.config.rules[State.ui.activeRuleIndex];
return {
isGeneral: false,
params: rule ? (rule.params || []) : [],
rule: rule
};
},
_confirmingAction: {
el: null,
onConfirm: null,
originalText: '',
isActivating: false,
timer: null,
},
_resetConfirmation() {
if (this._confirmingAction.el) {
clearTimeout(this._confirmingAction.timer);
this._confirmingAction.el.classList.remove('ulc-confirming-action', 'ulc-confirmation-activating');
this._confirmingAction.el.textContent = this._confirmingAction.originalText;
this._confirmingAction = { el: null, onConfirm: null, originalText: '' };
}
},
requestConfirmation(buttonElement, onConfirmCallback, confirmText = Utils.t('ui.buttons.confirm')) {
this._resetConfirmation();
this._confirmingAction = {
el: buttonElement,
onConfirm: onConfirmCallback,
originalText: buttonElement.textContent,
isActivating: true,
timer: setTimeout(() => {
this._confirmingAction.isActivating = false;
if (this._confirmingAction.el) {
this._confirmingAction.el.classList.remove('ulc-confirmation-activating');
}
}, State.ui.ACTIVATION_DELAY)
};
buttonElement.classList.add('ulc-confirming-action', 'ulc-confirmation-activating');
buttonElement.textContent = confirmText;
},
addParamsFromInput() {
const input = document.getElementById('ulc-new-param');
if (!input || !input.value) return false;
const inputValue = input.value.trim().replace(/['"]/g, '');
let newParams = [];
const parsedUrl = Utils.tryParseURL(inputValue);
if (parsedUrl) {
if (parsedUrl.searchParams.size === 0) {
input.value = '';
return false;
}
newParams = [...parsedUrl.searchParams.keys()];
} else {
newParams = inputValue.split(',').map(p => p.trim()).filter(p => p);
}
if (newParams.length === 0) {
input.value = '';
return false;
}
const context = this._getCurrentContext();
if (!context.isGeneral && !context.rule) {
return false;
}
const paramsList = context.params;
const paramsSet = new Set(paramsList);
const addedParams = new Set();
newParams.forEach(p => {
if (!paramsSet.has(p)) {
paramsSet.add(p);
addedParams.add(p);
}
});
if (addedParams.size > 0) {
const sortedParams = Array.from(paramsSet).sort();
if (context.isGeneral) {
State.config.general.params = sortedParams;
} else {
context.rule.params = sortedParams;
}
Logger.log(`Added ${addedParams.size} parameter(s)...`);
}
input.value = '';
return addedParams;
},
deleteParam(paramToDelete) {
const context = this._getCurrentContext();
const params = context.params;
if ((!context.isGeneral && !context.rule) || !params) {
return false;
}
const index = params.indexOf(paramToDelete);
if (index > -1) {
params.splice(index, 1);
const contextName = context.isGeneral ? 'General Rules' : context.rule.name;
Logger.log(`Parameter "${paramToDelete}" deleted from "${contextName}".`);
return true;
}
return false;
},
saveRule() {
const nameInput = document.getElementById('ulc-rule-name');
const matchInput = document.getElementById('ulc-rule-match');
const transformInput = document.getElementById('ulc-transform-keys');
const newName = nameInput.value.trim();
const newMatches = [...new Set(matchInput.value.split('\n').map(m => m.trim()).filter(m => m))];
const newTransformKeys = [...new Set(transformInput.value.split('\n').map(k => k.trim()).filter(k => k))];
if (!newName || newMatches.length === 0) {
UI.showToast(Utils.t('toasts.allEmpty'));
return false;
}
if (newName.toLowerCase() === GENERAL_TAB_ID) {
UI.showToast(Utils.t('toasts.nameReserved'));
return false;
}
const isEdit = State.ui.view === 'edit';
const ruleIndex = isEdit ? State.ui.activeRuleIndex : -1;
if (State.config.rules.some((r, i) => r.name.toLowerCase() === newName.toLowerCase() && i !== ruleIndex)) {
Logger.warn('Save failed: Duplicate rule name detected.', newName);
UI.showToast(Utils.t('toasts.nameExists'));
return false;
}
const ruleData = { name: newName, match: newMatches };
if (isEdit) {
const rule = State.config.rules[ruleIndex];
Object.assign(rule, ruleData);
rule.transform = newTransformKeys;
} else {
const newRule = {
...ruleData,
params: [],
transform: newTransformKeys,
enabled: true,
applyGeneral: true
};
State.config.rules.push(newRule);
State.ui.activeRuleIndex = State.config.rules.length - 1;
State.ui.activeTab = Utils.getRuleTabId(newRule);
}
Logger.log(`Rule "${newName}" has been saved (${isEdit ? 'edited' : 'newly created'}).`);
UI.showToast(Utils.t('toasts.ruleSaved', { ruleName: newName }));
return true;
},
deleteCurrentRule() {
const rule = State.config.rules[State.ui.activeRuleIndex];
if (State.ui.activeTab === GENERAL_TAB_ID || !rule) return false;
State.config.rules.splice(State.ui.activeRuleIndex, 1);
Logger.log(`Rule "${rule.name}" has been deleted.`);
UI.showToast(Utils.t('toasts.ruleDeleted'));
return true;
},
saveConfigFromText() {
const textarea = document.getElementById('ulc-config-textarea');
if (!textarea) return false;
let parsedJson;
try {
parsedJson = JSON.parse(textarea.value);
} catch (e) {
UI.showToast(Utils.t('toasts.jsonInvalid', { error: e.message }));
return false;
}
if (typeof parsedJson !== 'object' || parsedJson === null || Array.isArray(parsedJson)) {
UI.showToast(Utils.t('toasts.configNotAnObject'));
return false;
}
let newConfig;
try {
newConfig = structuredClone(parsedJson);
} catch (e) {
UI.showToast(Utils.t('toasts.configInvalidContent', { error: e.message }));
return false;
}
newConfig.general = structuredClone(State.config.general);
if (!Array.isArray(newConfig.rules)) {
UI.showToast(Utils.t('toasts.configMissingRules'));
return false;
}
const validationResult = Utils.validateAndNormalizeConfig(newConfig);
if (validationResult.error) {
UI.showToast(Utils.t('toasts.configInvalid', { error: validationResult.error }));
return false;
}
State.config = validationResult.config;
Core.saveConfig();
UI.showToast(Utils.t('toasts.configSaved'));
return true;
},
resetConfig() {
State.config.general.params = structuredClone(State.DEFAULT_CONFIG.general.params);
Logger.warn('General rules have been reset to default.');
UI.showToast(Utils.t('toasts.configReset'));
return true;
},
onSearchInputDebounced: null, // 防抖处理的 input 事件处理器
_performSearch(query) {
if (query !== State.ui.searchQuery) {
State.ui.searchQuery = query;
UI.updateRuleList();
}
},
// 动作字典
actions: {
closePanel() {
if (State.dom.settingsPanel) {
State.dom.settingsPanel.remove();
State.dom.settingsPanel = null;
}
},
openTab(target) {
const tabId = target.dataset.tabId;
if (State.ui.activeTab === tabId) return;
State.ui.highlightedParams.clear();
State.ui.activeTab = tabId;
State.ui.activeRuleIndex = parseInt(target.dataset.ruleIndex, 10);
State.ui.view = 'list';
UI.renderPanel();
},
addParam() {
const newlyAddedParams = Events.addParamsFromInput();
if (newlyAddedParams === false) {
return;
}
if (newlyAddedParams.size > 0) {
UI.showToast(Utils.t('toasts.paramsAdded', { count: newlyAddedParams.size }));
State.ui.highlightedParams = newlyAddedParams;
Core.saveConfig();
UI.renderMainContent();
}
else {
UI.showToast(Utils.t('toasts.paramsExist'));
}
},
deleteParam(target) {
if (Events.deleteParam(target.dataset.param)) {
Core.saveConfig();
UI.renderMainContent();
}
},
openAddRuleForm() {
State.ui.view = 'add';
UI.renderMainContent();
},
openEditRuleForm() {
State.ui.view = 'edit';
UI.renderMainContent();
},
deleteRule(target) {
Events.requestConfirmation(target, () => {
const originalIndex = State.ui.activeRuleIndex;
if (Events.deleteCurrentRule()) {
const newIndex = originalIndex - 1;
if (State.config.rules.length === 0) {
State.ui.activeRuleIndex = -1;
State.ui.activeTab = GENERAL_TAB_ID;
} else {
const newSafeIndex = Math.max(-1, Math.min(newIndex, State.config.rules.length - 1));
State.ui.activeRuleIndex = newSafeIndex;
if (newSafeIndex === -1) {
State.ui.activeTab = GENERAL_TAB_ID;
} else {
const newActiveRule = State.config.rules[newSafeIndex];
State.ui.activeTab = Utils.getRuleTabId(newActiveRule);
}
}
Core.saveConfig();
UI.renderPanel();
}
}, Utils.t('ui.buttons.confirmDelete'));
},
resetGeneral(target) {
Events.requestConfirmation(target, () => {
if (Events.resetConfig()) {
Core.saveConfig();
UI.renderMainContent();
}
}, Utils.t('ui.buttons.confirmReset'));
},
toggleRuleEnabled(target) {
const rule = State.config.rules[State.ui.activeRuleIndex];
if (rule) rule.enabled = target.checked;
Core.saveConfig();
},
toggleApplyGeneral(target) {
const rule = State.config.rules[State.ui.activeRuleIndex];
if (rule) rule.applyGeneral = target.checked;
Core.saveConfig();
},
saveRule() {
if (Events.saveRule()) {
State.ui.view = 'list';
Core.saveConfig();
UI.renderPanel();
}
},
cancelRuleForm() {
State.ui.view = 'list';
UI.renderMainContent();
},
openConfigText() {
State.ui.view = 'config-text';
UI.renderMainContent();
},
saveConfigText() {
if (Events.saveConfigFromText()) {
State.ui.view = 'list';
State.ui.activeTab = GENERAL_TAB_ID;
State.ui.activeRuleIndex = -1;
Core.saveConfig();
UI.renderPanel();
}
},
cancelConfigText() {
State.ui.view = 'list';
UI.renderMainContent();
}
},
// 核心事件处理器
handlePanelClick(e) {
const target = e.target;
const actionTarget = target.closest('[data-action]');
if (!actionTarget) {
if (this._confirmingAction.el) {
this._resetConfirmation();
}
return;
}
if (this._confirmingAction.el === actionTarget) {
if (this._confirmingAction.isActivating) {
return;
} else {
this._confirmingAction.onConfirm();
this._resetConfirmation();
return;
}
}
if (this._confirmingAction.el) {
this._resetConfirmation();
}
const action = actionTarget.dataset.action;
if (this.actions[action]) {
this.actions[action](actionTarget, e);
}
},
initEventListeners() {
const preCleanLink = (e) => {
if (e.target.closest(`#${State.dom.panelId}`)) return;
const link = Utils.findLinkInEvent(e);
if (link && !link.dataset[State.cleanedAttrName] && !link.dataset[State.invalidAttrName]) {
if (Utils.isValidHttpLink(link)) {
const cleanedHref = Core.cleanUrl(link.href);
if (link.href !== cleanedHref) {
Logger.log('Link purified on hover:', { from: link.href, to: cleanedHref });
link.href = cleanedHref;
}
link.dataset[State.cleanedAttrName] = cleanedHref;
if (link.hostname !== window.location.hostname) {
link.setAttribute('referrerpolicy', 'no-referrer');
}
} else {
link.dataset[State.invalidAttrName] = 'true';
}
}
};
document.addEventListener('mouseover', preCleanLink, true);
const finalClickFix = e => {
if (e.target.closest(`#${State.dom.panelId}`)) return;
const link = Utils.findLinkInEvent(e);
if (link && typeof link.dataset[State.invalidAttrName] === 'undefined') {
const cleanedHref = link.dataset[State.cleanedAttrName] || Core.cleanUrl(link.href);
if (link.href !== cleanedHref) {
Logger.warn('Link purified on click (final fix):', { from: link.href, to: cleanedHref });
link.href = cleanedHref;
}
if (link.hostname !== window.location.hostname) {
link.setAttribute('referrerpolicy', 'no-referrer');
}
e.stopImmediatePropagation();
}
};
['mousedown', 'click', 'contextmenu'].forEach(evt => document.addEventListener(evt, finalClickFix, true));
const wrapHistoryMethod = (method) => {
const original = history[method];
history[method] = function (state, title, url, ...rest) {
const originalUrl = url ? url.toString() : '';
const cleanedUrl = Core.cleanUrl(originalUrl);
if (originalUrl !== cleanedUrl) {
Logger.log(`history.${method} intercepted and URL purified.`, {
from: originalUrl,
to: cleanedUrl,
state: state
});
}
return original.apply(this, [state, title, cleanedUrl, ...rest]);
};
};
wrapHistoryMethod('pushState');
wrapHistoryMethod('replaceState');
// 沙盒模式下window.open无法正确拦截，所以需要使用unsafeWindow
const openContext = isFallbackMode ? sandboxUnsafeWindow : window;
if (openContext) {
const originalOpen = openContext.open;
if (typeof originalOpen === 'function') {
openContext.open = function (url, ...args) {
const originalUrl = url ? url.toString() : '';
const cleanedUrl = Core.cleanUrl(originalUrl);
if (originalUrl !== cleanedUrl) {
Logger.log('window.open call intercepted and URL purified.', {
from: originalUrl,
to: cleanedUrl,
target: args[0] || '_blank'
});
}
return originalOpen.apply(openContext, [cleanedUrl, ...args]);
};
} else {
Logger.warn('window.open is not a function and could not be patched.');
}
} else {
Logger.warn('window context is not available for patching window.open.');
}
window.addEventListener('ulc-open-settings', () => {
if (State.dom.settingsPanel) {
State.dom.settingsPanel.remove();
State.dom.settingsPanel = null;
return;
}
const open = () => {
UI.createSettingsPanel();
State.ui.isDarkMode = window.matchMedia('(prefers-color-scheme: dark)').matches;
if (State.ui.isDarkMode) {
State.dom.settingsPanel.classList.add('theme-dark');
}
State.ui.view = 'list';
State.ui.activeTab = GENERAL_TAB_ID;
State.ui.activeRuleIndex = -1;
UI.renderPanel();
State.dom.settingsPanel.style.display = 'flex';
};
document.body ? open() : document.addEventListener('DOMContentLoaded', open);
});
window.addEventListener('ulc-config-updated', (event) => {
Logger.log('Configuration synced from another tab. Updating state...');
const newRawConfig = event.detail;
// 更新配置
State.config = newRawConfig;
State.ruleCache.clear();
Logger.log('[Cache] Rules cache cleared due to cross-tab sync.');
if (State.dom.settingsPanel) {
State.ui.view = 'list';
if (State.ui.activeTab !== GENERAL_TAB_ID) {
const ruleIndex = State.config.rules.findIndex(r => Utils.getRuleTabId(r) === State.ui.activeTab);
if (ruleIndex === -1) {
State.ui.activeTab = GENERAL_TAB_ID;
State.ui.activeRuleIndex = -1;
} else {
State.ui.activeRuleIndex = ruleIndex;
}
}
UI.renderPanel();
}
});
}
};
// --- 初始化 ---
function main() {
const normalizedConfig = Utils.normalizeConfig(sandboxConfig.config);
const normalizedDefaultConfig = Utils.normalizeConfig(sandboxConfig.defaultConfig);
State.init(normalizedConfig, normalizedDefaultConfig);
Events.onSearchInputDebounced = Utils.debounce((e) => {
Events._performSearch(e.target.value);
}, 250);
State.cleanedAttrName = Utils.randomString();
State.invalidAttrName = Utils.randomString();
const cleanedPageUrl = Core.cleanUrl(window.location.href);
if (window.location.href !== cleanedPageUrl) {
history.replaceState(history.state, '', cleanedPageUrl);
}
Events.handlePanelClick = Events.handlePanelClick.bind(Events);
Events.initEventListeners();
}
main();
})();
},
inject(injectedConfig = {}) {
const nonce = document.querySelector('script[nonce]')?.nonce || document.querySelector('style[nonce]')?.nonce;
const injectedScript = document.createElement('script');
injectedScript.id = 'ulc-injected-script';
injectedScript.nonce = nonce;
const scriptContent = `
((injectedCode) => {
const injectedOptions = ${JSON.stringify(injectedConfig)};
injectedCode(injectedOptions);
})(${this.injectedCode.toString()});
`;
if (window.trustedTypes && window.trustedTypes.createPolicy) {
try {
const policy = window.trustedTypes.createPolicy('UniversalLinkCleanerPolicy', { createScript: s => s });
injectedScript.textContent = policy.createScript(scriptContent);
} catch (e) {
injectedScript.textContent = scriptContent;
}
} else {
injectedScript.textContent = scriptContent;
}
(document.head || document.documentElement).appendChild(injectedScript);
injectedScript.remove();
}
};
// --- 主执行流程 ---
function main() {
const PANEL_ID = 'p' + Math.random().toString(36).substring(2, 10);
const activeLocale = I18nManager.getActiveLocale();
const defaultLocale = I18nManager.getDefaultLocale()
Sandbox.loadConfig();
Sandbox.init(activeLocale);
StyleInjector.inject(PANEL_ID);
let injectionSuccessful = false;
const successListener = () => {
injectionSuccessful = true;
window.removeEventListener('ulc-injection-success', successListener);
};
window.addEventListener('ulc-injection-success', successListener);
// 注入配置项
const INJECT_CONFIG = {
sandboxConfig: {
config: Sandbox.config,
defaultConfig: Sandbox.DEFAULT_CONFIG
},
IS_DEBUG,
PANEL_ID,
locale: activeLocale,
defaultLocale: defaultLocale,
}
// 注入模式
CodeInjector.inject(INJECT_CONFIG);
setTimeout(() => {
if (!injectionSuccessful) {
// 注入失败，降级为沙盒模式
window.removeEventListener('ulc-injection-success', successListener);
CodeInjector.injectedCode({
...INJECT_CONFIG,
isFallbackMode: true,
sandboxUnsafeWindow: unsafeWindow
});
}
}, 0);
}
main();
})();