liufumingren 6818da707e build(extension): 分发用压缩产物(esbuild minify,不混淆)
MV3 没有编译产物,桌面安装包会把插件源码装在 <安装目录>\extension,用户能直接看到
带注释的代码并随手改。这里加一层「压缩」:去注释、压空白、缩短标识符,体积 71KB → 30KB。

- backend/scripts/deploy/build-extension.cjs(新):esbuild 逐文件 minify 输出 extension/dist,
  不做 bundle(importScripts('lib/rules.js') 与各处路径原样有效),无 eval/Function,
  满足 MV3 的 CSP 与商店「代码可读」要求;
- publish-extension.cjs:打包/压缩包一律从 dist 取源;商店 zip 改用自写的
  zip-util.cjs —— PowerShell 5.1 的 Compress-Archive 会把条目名写成 `src\x.js`,
  8.3 短路径下还会多出前导 `/`,商店会当成怪文件名;
- desktop csproj 改为打 ..\extension\dist\**,installer/build.ps1 在 dotnet publish 前
  自动跑一次 bundle(找不到 node/esbuild 明确报错,避免打进上次的旧 dist);
- extension:rules.js 的兜底 urlTemplate/fallback 从 localhost:7301 改为线上站点
  (和服务端默认值保持一致),版本 1.1.2;
- backend 增加 esbuild devDependency 与 npm run extension:bundle;文档同步。

验证:5 个 js 全部 node --check 通过;dist 里 manifest 引用的 14 个文件都在;
Chrome --pack-extension 成功(扩展 ID 不变);zip 条目全部是标准 `/` 且 manifest.json 在根目录、
可正常解压;desktop Debug 编译 0 警告 0 错误,输出目录里是指向 dist 的压缩版(无 keys/README/test)。

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-11-01 03:53:13 +08:00

826 lines
34 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

'use strict';
/**
* 云仓视频溯源 · 扫码入口注入 —— 规则引擎(零构建,浏览器/扩展通用)
*
* 这个文件同时被三处引入:
* - content script(manifest.content_scripts.js,跑在第三方页面里)
* - 配置页 options.html
* - 弹窗 popup.html
* 所以不能写成 ES module(没有打包步骤),统一挂在 globalThis.PSTRules 上。
*
* 职责边界:
* 本文件只做「纯逻辑」——配置归一化、正则编译、文本命中、DOM 标记、地址拼接。
* 与 chrome.* 打交道的部分集中在 loadConfig / saveConfig 两个函数里。
*/
(function (root) {
const STORAGE_KEY = 'pstConfig';
// 网页模板(openMode = window / tab 时用):打开官网的单号页
// ⚠️ 只是**兜底默认值**:正常情况由服务端配置下发(平台管理 → 插件配置)。
// 绝不能写成 localhost —— 插件装在员工浏览器里,那会打开他们自己的机器。
const DEFAULT_URL_TEMPLATE = 'https://pack.wms.gztbyc.com/local?code={code}';
// 协议模板(openMode = app 时用):**直接唤起本机软件**并带上单号
// ⚠️ 自定义协议拿不到任何结果(成功/没装/用户点取消在网页侧一模一样),
// 所以 content script 必须配合超时兜底(弹「下载安装 / 在网页中查看」)。
const DEFAULT_APP_URL_TEMPLATE = 'yuncang://open?code={code}';
/** 兜底页:协议唤不起时「去网页看看」(页面里会提示下载安装、并能在浏览器里直接查) */
const DEFAULT_FALLBACK_URL = 'https://pack.wms.gztbyc.com/local?code={code}';
/** 点击后的打开方式:app = 协议唤起本机软件;window = 独立小窗;tab = 新标签页 */
const OPEN_MODES = ['app', 'window', 'tab'];
const DEFAULT_BUTTON_TEXT = '查看打包视频';
const MARK_STYLES = ['underline', 'highlight', 'chip'];
/**
* 加工方式:
* button(默认)—— 完全不动命中元素,只在它旁边插一个按钮;
* chip —— 命中元素本身可点(加类名 / 改 title / 接管点击)。
*/
const ACTION_MODES = ['button', 'chip'];
/** 这些元素的文本不参与匹配(避免破坏表单/脚本/媒体) */
const SKIP_TAGS = new Set([
'SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT', 'OPTION',
'TITLE', 'HEAD', 'BUTTON', 'LABEL', 'IFRAME', 'CANVAS', 'VIDEO', 'AUDIO',
'OBJECT', 'EMBED',
]);
/**
* 单号前缀表(**要维护就改这一行**):新出现的快递公司前缀直接往数组里加就行,
* 只要是以前没出现过、又确实出现在单号开头的,加进来即可 —— 通用文本规则就靠它认单号。
* ⚠️ 数字前缀(如 32 / 77)最容易把内部 ID、订单号一起点亮,发现误标再回来调整。
*/
const EXPRESS_PREFIXES = [ 'YT', 'SF', 'JD', 'ZTO', 'YTO', 'STO', 'EMS', 'DBL', '32', '77' ];
/** 通用运单号文本规则:前缀 + 10~16 位数字 */
const EXPRESS_PATTERN = '\\b(?:' + EXPRESS_PREFIXES.join('|') + ')\\d{10,16}\\b';
/** 上一版 express 的正则:只有用户没改过它时,才在升级时跟着换新 */
const LEGACY_EXPRESS_PATTERN = '\\b(?:YT|SF|JD|ZTO|YTO|STO|EMS|DBL)\\d{10,16}\\b';
/** 已经移除的示例规则 id(老配置升级时从用户的规则里剔掉) */
const REMOVED_RULE_IDS = [ 'wms-waybill', 'numeric', 'legacy-postnum', 'dom-attr' ];
/** 配置版本:升版本号 = 下次打开页面时跑一次 upgradeRules() */
const CONFIG_VERSION = 4;
/**
* 内置规则:**只留这一条通用文本规则**。
* (2026-10-17 起把 WMS 选择器 / 纯数字 / legacy postNum / data-attr 这四条示例规则都删了 ——
* 实测「前缀 + 10~16 位数字」已经盖住真实页面的运单号,不够用再加前缀即可。)
*
* 前缀表见 EXPRESS_PREFIXES:新前缀往那里加,不用改正则本身。
*/
const DEFAULT_RULES = [
{
id: 'express',
name: '快递单号(YT / SF / JD / ZTO / YTO / STO / EMS / 32 / 77… 通用文本规则)',
enabled: true,
match: 'text',
pattern: EXPRESS_PATTERN,
flags: 'gi',
exclude: '',
selector: '',
attr: '',
hostPatterns: ['*'],
actionMode: '', // 空 = 跟随全局(默认 button:旁边插按钮,不碰宿主元素)
style: '',
urlTemplate: '',
},
];
/* ---------------------------------------------------------------- 配置 */
function defaultConfig() {
return JSON.parse(JSON.stringify({
version: CONFIG_VERSION,
enabled: true,
hosts: ['*'],
urlTemplate: DEFAULT_URL_TEMPLATE,
appUrlTemplate: DEFAULT_APP_URL_TEMPLATE,
fallbackUrl: DEFAULT_FALLBACK_URL,
downloadUrl: '', // 软件安装包/下载页;空 = 兜底卡片只给「去网页查看」
openMode: 'app', // app = 直接唤起本机软件(默认);window = 独立小窗;tab = 新标签页
actionMode: 'button', // button = 旁边插按钮(默认,不碰宿主元素);chip = 元素本身可点
buttonText: DEFAULT_BUTTON_TEXT,
markStyle: 'underline',
showIcon: true,
scanDelay: 400, // DOM 变动后延迟多久重扫(毫秒)
maxNodes: 5000, // 单次扫描最多看多少个文本节点
maxMarks: 400, // 单页最多标记多少处
rules: DEFAULT_RULES,
}));
}
function normalizeConfig(raw) {
const dft = defaultConfig();
const src = raw && typeof raw === 'object' ? raw : {};
const cfg = Object.assign(dft, src);
cfg.version = CONFIG_VERSION;
cfg.enabled = cfg.enabled !== false;
cfg.hosts = toStrArray(cfg.hosts, ['*']);
cfg.urlTemplate = String(cfg.urlTemplate || '').trim() || DEFAULT_URL_TEMPLATE;
cfg.appUrlTemplate = String(cfg.appUrlTemplate || '').trim() || DEFAULT_APP_URL_TEMPLATE;
cfg.fallbackUrl = String(cfg.fallbackUrl || '').trim() || DEFAULT_FALLBACK_URL;
cfg.downloadUrl = String(cfg.downloadUrl || '').trim();
cfg.remote = normalizeRemote(cfg.remote);
cfg.openMode = OPEN_MODES.indexOf(cfg.openMode) >= 0 ? cfg.openMode : 'app';
// v3 把「协议模板」当成了 urlTemplate 的默认值(当时没有 openMode=app 这个概念);
// 升到 v4:模板还原成网页模板,改用 openMode='app' 表达「直接唤起」,行为不变。
if (Number(src.version || 1) < 4 && String(src.urlTemplate || '').trim() === DEFAULT_APP_URL_TEMPLATE) {
cfg.urlTemplate = DEFAULT_URL_TEMPLATE;
cfg.openMode = 'app';
}
cfg.actionMode = ACTION_MODES.indexOf(cfg.actionMode) >= 0 ? cfg.actionMode : 'button';
cfg.buttonText = String(cfg.buttonText == null ? '' : cfg.buttonText).trim() || DEFAULT_BUTTON_TEXT;
cfg.markStyle = MARK_STYLES.indexOf(cfg.markStyle) >= 0 ? cfg.markStyle : 'underline';
cfg.showIcon = cfg.showIcon !== false;
cfg.scanDelay = clampInt(cfg.scanDelay, 0, 5000, 400);
cfg.maxNodes = clampInt(cfg.maxNodes, 100, 50000, 5000);
cfg.maxMarks = clampInt(cfg.maxMarks, 1, 5000, 400);
// rules 缺失(首次安装 / 数据损坏)才回落到内置规则;用户主动删空就保持空
if (!Array.isArray(src.rules)) {
cfg.rules = dft.rules;
} else {
cfg.rules = src.rules.map(normalizeRule).filter(Boolean);
// 老版本的配置(version < CONFIG_VERSION)跟着扩展升级一次:删掉已移除的示例规则、刷新内置规则的前缀表
if (Number(src.version || 1) < CONFIG_VERSION) cfg.rules = upgradeRules(cfg.rules);
}
return cfg;
}
/**
* 配置升级(只在 version 变高时跑一次):
* 1. 剔掉已经移除的内置示例规则(REMOVED_RULE_IDS);
* 2. 内置的 express 若还是老正则(用户没自己改过),就换成带新前缀表的正则。
* 用户自己加的规则一律不动。
*/
function upgradeRules(rules) {
return rules
.filter(rule => REMOVED_RULE_IDS.indexOf(rule.id) < 0)
.map(rule => {
if (rule.id !== 'express') return rule;
if (String(rule.pattern).trim() !== LEGACY_EXPRESS_PATTERN) return rule; // 用户改过就尊重他的
return Object.assign({}, rule, {
name: DEFAULT_RULES[0].name,
match: 'text',
pattern: EXPRESS_PATTERN,
flags: 'gi',
});
});
}
/* ------------------------------------------- 服务器下发(集中配置) */
/**
* 服务器下发信息(只做展示/版本判断,不参与识别)
*
* `version` 用来判断"配置变没变":相同就不重写 storage,页面不会被无谓地重扫一遍。
*/
function normalizeRemote(raw) {
const src = raw && typeof raw === 'object' ? raw : {};
return {
version: Number(src.version) || 0,
syncedAt: String(src.syncedAt || ''),
updatedAt: src.updatedAt ? String(src.updatedAt) : null,
prefixes: toStrArray(src.prefixes, []),
minDigits: Number(src.minDigits) || 0,
maxDigits: Number(src.maxDigits) || 0,
error: String(src.error || ''),
};
}
/**
* 把服务器配置合并进本地配置(插件**只执行**,不提供编辑)
*
* 服务端已经拼好正则(`pattern`),这里直接当成唯一一条 `text` 规则:
* - 前缀/位数变了 → pattern 变 → 规则变;
* - `hosts` 决定"在哪些站点工作";
* - `openMode` 这类本机偏好保持原值,不被覆盖。
*/
function applyRemote(prev, remote) {
const base = normalizeConfig(prev || {});
const pattern = String((remote && remote.pattern) || '').trim();
const hosts = toStrArray(remote && remote.hosts, ['*']);
const rules = pattern
? [ {
id: 'remote',
name: '单号(服务器下发)',
enabled: true,
match: 'text',
pattern,
flags: String((remote && remote.flags) || 'g'),
exclude: '',
urlTemplate: '',
} ]
: [];
return normalizeConfig(Object.assign({}, base, {
enabled: !(remote && remote.enabled === false),
hosts,
urlTemplate: String((remote && remote.urlTemplate) || '').trim() || DEFAULT_URL_TEMPLATE,
appUrlTemplate: String((remote && remote.appUrlTemplate) || '').trim() || DEFAULT_APP_URL_TEMPLATE,
downloadUrl: String((remote && remote.downloadUrl) || '').trim(),
rules,
remote: Object.assign({}, normalizeRemote(remote), { syncedAt: new Date().toISOString(), error: '' }),
}));
}
function normalizeRule(raw) {
if (!raw || typeof raw !== 'object') return null;
return {
id: String(raw.id || '').trim() || 'r-' + Math.random().toString(36).slice(2, 8),
name: String(raw.name == null ? '' : raw.name).trim() || '未命名规则',
enabled: raw.enabled === true,
match: raw.match === 'selector' ? 'selector' : 'text',
pattern: String(raw.pattern == null ? '' : raw.pattern),
flags: String(raw.flags == null ? '' : raw.flags),
exclude: String(raw.exclude == null ? '' : raw.exclude),
selector: String(raw.selector == null ? '' : raw.selector),
attr: String(raw.attr == null ? '' : raw.attr).trim(),
hostPatterns: toStrArray(raw.hostPatterns, ['*']),
actionMode: ACTION_MODES.indexOf(raw.actionMode) >= 0 ? raw.actionMode : '', // 空 = 跟随全局
style: MARK_STYLES.indexOf(raw.style) >= 0 ? raw.style : '',
urlTemplate: String(raw.urlTemplate == null ? '' : raw.urlTemplate).trim(),
};
}
/* -------------------------------------------------------- 规则编译 */
/**
* 把配置里的规则编译成「可直接跑」的形态,编译失败的规则会被跳过并收集原因
* (而不是让整页注入挂掉)。
* @returns {{rules: Array, errors: Array<{id:string,name:string,message:string}>}}
*/
function compileRules(rules) {
const list = [];
const errors = [];
for (const rule of Array.isArray(rules) ? rules : []) {
if (!rule || rule.enabled === false) continue;
try {
const ptn = String(rule.pattern || '').trim();
const ex = String(rule.exclude || '').trim();
const excludeRe = ex ? new RegExp(ex, 'g') : null;
let re = null;
if (rule.match === 'selector') {
const sel = String(rule.selector || '').trim();
if (!sel) throw new Error('CSS 选择器不能为空');
if (typeof document !== 'undefined') {
// 仅做语法校验:非法选择器会让 querySelector 直接抛异常
document.createDocumentFragment().querySelector(sel);
}
// 选择器模式下正则是**可选**的:填了就用来从取到的属性值/文本里再抽一次编号。
// 典型场景:<a href="javascript:MM_openTrace('../system/view-trace!viewTrace.jspb?postNum=202610101621&wareHouseId=5400')">
// —— 编号藏在 href 里,整条属性值不能当编号,必须再抽一层。
if (ptn) re = new RegExp(ptn, normalizeFlags(rule.flags));
} else {
if (!ptn) throw new Error('正则表达式不能为空');
re = new RegExp(ptn, normalizeFlags(rule.flags));
}
list.push({ rule, re, excludeRe });
} catch (e) {
errors.push({ id: rule.id, name: rule.name, message: shortMessage(e) });
}
}
return { rules: list, errors };
}
/** 只保留安全 flag,并且强制带上 g(exec 循环依赖它) */
function normalizeFlags(flags) {
const keep = [];
for (const ch of String(flags || '').toLowerCase()) {
if ('imsug'.indexOf(ch) >= 0 && keep.indexOf(ch) < 0) keep.push(ch);
}
if (keep.indexOf('g') < 0) keep.push('g');
return keep.join('');
}
/* ---------------------------------------------------------- 文本匹配 */
function extractCode(m) {
const picked = m.length > 1 && m[1] != null ? m[1] : m[0];
return String(picked == null ? '' : picked).trim();
}
/**
* 在一段文本里找出所有命中(多条规则合并,按位置排序,重叠的只保留最靠前的那个)
* @param {string} text
* @param {{rules:Array}} compiled compileRules() 的结果
* @param {number} [maxPerNode] 单个文本节点最多取多少条,默认 20
*/
function matchText(text, compiled, maxPerNode) {
const out = [];
if (!text) return out;
const cap = maxPerNode || 20;
for (const c of (compiled && compiled.rules) || []) {
if (!c.re) continue;
const re = c.re;
re.lastIndex = 0;
let m;
while ((m = re.exec(text)) !== null) {
if (!m[0]) { re.lastIndex++; continue; } // 零宽匹配兜底,否则死循环
const code = extractCode(m);
if (!code) continue;
if (c.excludeRe) {
c.excludeRe.lastIndex = 0;
if (c.excludeRe.test(m[0])) continue;
}
out.push({ rule: c.rule, code, text: m[0], index: m.index });
if (out.length >= cap) break;
}
}
// 长的优先,避免短规则把长规则切碎
out.sort((a, b) => (a.index - b.index) || (b.text.length - a.text.length));
const kept = [];
let end = -1;
for (const h of out) {
if (h.index < end) continue;
kept.push(h);
end = h.index + h.text.length;
}
return kept;
}
function acceptTextNode(node, markClass) {
const v = node.nodeValue;
if (!v || !v.trim()) return false;
const p = node.parentElement;
if (!p) return false;
// 跳过 SVG / MathML —— 超出 HTML 命名空间,插 HTML 元素会出问题
if (p.namespaceURI && p.namespaceURI !== 'http://www.w3.org/1999/xhtml') return false;
if (SKIP_TAGS.has(p.tagName)) return false;
if (p.isContentEditable) return false;
// 已经加工过的(chip 标记 / text 模式的定位 span / 按钮)都不再处理:
// 一律看 data-pst-code —— button 模式不会给宿主元素加类名,只看类名会漏。
if (p.closest && p.closest('.' + markClass + ', [data-pst-code], [data-pst-skip]')) return false;
return true;
}
/* ---------------------------------------------------------- DOM 标记 */
/**
* 扫描 rootEl 并按规则「二次加工」,= 两种匹配 × 两种加工方式:
*
* 匹配:text 规则(遍历文本节点按正则找) / selector 规则(CSS 选择器命中元素)
* 加工:button(默认)= **完全不碰命中元素**,只在它旁边插一个兄弟按钮
* chip = 命中元素本身可点(会加类名 / 改 title / 接管点击)
*
* button 方式下宿主元素只被写两个 data-* 属性当「已处理」记号,
* 类名 / title / role / tabindex 一律不动 —— 所以元素的外观和它自己的点击行为都不受影响。
* 自己新建的元素一律带 data-pst-code,acceptTextNode 见到就跳过,保证不会自我嵌套。
*
* @param {Element|Document} rootEl
* @param {{rules:Array}} compiled
* @param {object} opts 见下方 o.* 读取处
* @returns {{items:Array, marks:Array, truncated:boolean}}
* items —— 去重后的命中清单(给 popup 展示)
* marks —— 新建/标记的元素(配置页试跑用来取 outerHTML 预览)
*/
function applyMarks(rootEl, compiled, opts) {
const o = opts || {};
const doc = (rootEl && rootEl.ownerDocument) || (typeof document !== 'undefined' ? document : null);
const markClass = o.markClass || 'pst-trace-mark';
const maxNodes = clampInt(o.maxNodes, 100, 50000, 5000);
const maxMarks = clampInt(o.maxMarks, 1, 5000, 400);
const defaultAction = ACTION_MODES.indexOf(o.defaultActionMode) >= 0 ? o.defaultActionMode : 'button';
const buttonText = String(o.buttonText == null ? '' : o.buttonText).trim() || DEFAULT_BUTTON_TEXT;
const items = [];
const marks = [];
const seen = new Set();
let truncated = false;
if (!rootEl || !doc) return { items, marks, truncated };
function urlFor(rule, code) {
// 「直接唤起本机软件」:用协议模板(规则级的网页模板不参与)
if (o.openMode === 'app') {
return buildUrl(o.appUrlTemplate || DEFAULT_APP_URL_TEMPLATE, code, o.host);
}
const tpl = rule.urlTemplate || o.urlTemplate || DEFAULT_URL_TEMPLATE;
return buildUrl(tpl, code, o.host);
}
function pushItem(rule, code, text, url) {
const key = rule.id + '\u0000' + code;
if (seen.has(key)) return;
seen.add(key);
if (items.length < 60) {
items.push({ ruleId: rule.id, ruleName: rule.name, code, text, url });
}
}
/** 这条规则用哪种加工方式(规则自己没写就跟随全局) */
function actionOf(rule) {
return ACTION_MODES.indexOf(rule.actionMode) >= 0 ? rule.actionMode : defaultAction;
}
/** 「查看打包视频」按钮:自己带 markClass,所以点击处理和命中计数都跟 chip 模式走同一条路 */
function makeButton(rule, code) {
const btn = doc.createElement('button');
btn.type = 'button';
btn.className = markClass + ' pst-trace-btn';
btn.textContent = buttonText;
btn.setAttribute('data-pst-code', code);
btn.setAttribute('data-pst-rule', rule.id);
const url = urlFor(rule, code);
if (url) {
btn.setAttribute('data-pst-url', url);
btn.title = url;
}
return btn;
}
/** 按钮插到哪儿:命中元素自己;它若在 <a> 里则退到那个 <a> 之后(<button> 嵌进 <a> 是非法嵌套) */
function insertRef(el) {
if (!el) return null;
if (el.tagName === 'A') return el;
return (el.closest && el.closest('a')) || el;
}
/** 已经插过就复用,避免增量重扫插出一排按钮 */
function existingButton(el) {
const ref = insertRef(el);
const nxt = ref && ref.nextElementSibling;
return nxt && nxt.classList && nxt.classList.contains('pst-trace-btn') ? nxt : null;
}
const allRules = (compiled && compiled.rules) || [];
const selRules = allRules.filter(c => c.rule.match === 'selector' && c.rule.selector);
// ⚠️ 必须按 match 过滤,不能只看 c.re:选择器规则也可能带正则(用于从属性里抽号),
// 否则它会被当成文本规则去扫全页面。
const txtRules = allRules.filter(c => c.rule.match !== 'selector' && c.re);
/* --- 1) selector 规则:处理宿主元素本身 --- */
if (selRules.length && typeof rootEl.querySelectorAll === 'function') {
for (const c of selRules) {
let els = [];
try {
els = Array.prototype.slice.call(rootEl.querySelectorAll(c.rule.selector));
} catch (_) { continue; }
for (const el of els) {
if (marks.length >= maxMarks) { truncated = true; break; }
if (el.hasAttribute('data-pst-skip')) continue;
if (!hostAllowed(o.hostname, o.host, c.rule.hostPatterns)) continue;
const raw = c.rule.attr ? el.getAttribute(c.rule.attr) : el.textContent;
let code = raw == null ? '' : String(raw).trim();
if (!code) continue;
// 选择器 + 正则:从取到的属性值/文本里再抽一次编号(第 1 个捕获组优先)
if (c.re) {
c.re.lastIndex = 0;
const m = c.re.exec(code);
code = m ? extractCode(m) : '';
}
if (!code) continue;
if (c.excludeRe) {
c.excludeRe.lastIndex = 0;
if (c.excludeRe.test(code)) continue;
}
const url = urlFor(c.rule, code);
/* ---------- button:宿主元素只被写两个 data-* 记号,其余一律不动 ---------- */
if (actionOf(c.rule) === 'button') {
const changed = el.getAttribute('data-pst-code') !== code;
let btn = existingButton(el);
if (btn && changed) {
btn.setAttribute('data-pst-code', code);
btn.setAttribute('data-pst-rule', c.rule.id);
if (url) { btn.setAttribute('data-pst-url', url); btn.title = url; }
else { btn.removeAttribute('data-pst-url'); btn.removeAttribute('title'); }
}
if (!btn) {
const ref = insertRef(el);
if (!ref || !ref.parentNode) continue;
btn = makeButton(c.rule, code);
ref.parentNode.insertBefore(btn, ref.nextSibling);
}
if (changed) {
el.setAttribute('data-pst-code', code);
el.setAttribute('data-pst-rule', c.rule.id);
}
marks.push({ el: btn, rule: c.rule, code, text: code, index: -1 });
pushItem(c.rule, code, code, url);
continue;
}
/* ---------- chip:命中元素本身可点 ---------- */
if (el.classList.contains(markClass)) continue;
const style = c.rule.style || o.defaultStyle || 'underline';
el.classList.add(markClass, 'pst-mode-selector', 'pst-style-' + style);
if (o.showIcon !== false) el.classList.add('pst-has-icon');
el.setAttribute('data-pst-code', code);
el.setAttribute('data-pst-rule', c.rule.id);
if (!el.hasAttribute('role')) el.setAttribute('role', 'link');
if (!el.hasAttribute('tabindex')) {
el.tabIndex = 0;
el.setAttribute('data-pst-tab', '1'); // 记下来,撤销时才知道是我加的
}
// title 可能是页面自己的,先存原值
if (!el.hasAttribute('data-pst-title')) {
el.setAttribute('data-pst-title', el.hasAttribute('title') ? el.getAttribute('title') : '');
}
if (url) {
el.setAttribute('data-pst-url', url);
el.setAttribute('title', url);
}
marks.push({ el, rule: c.rule, code, text: code, index: -1 });
pushItem(c.rule, code, code, url);
}
}
}
/* --- 2) text 规则:遍历文本节点,按命中切分后包 span --- */
if (txtRules.length && !truncated && typeof doc.createTreeWalker === 'function') {
const walker = doc.createTreeWalker(rootEl, NodeFilter.SHOW_TEXT, {
acceptNode(node) {
return acceptTextNode(node, markClass) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
},
});
const targets = [];
let node;
while ((node = walker.nextNode())) {
if (targets.length >= maxNodes) { truncated = true; break; }
targets.push(node);
}
const compiledText = { rules: txtRules };
for (const tn of targets) {
if (marks.length >= maxMarks) { truncated = true; break; }
if (!tn.parentNode) continue;
const text = tn.nodeValue;
const hits = matchText(text, compiledText, 20);
if (!hits.length) continue;
const frag = doc.createDocumentFragment();
let cursor = 0;
for (const h of hits) {
if (marks.length >= maxMarks) { truncated = true; break; }
if (!hostAllowed(o.hostname, o.host, h.rule.hostPatterns)) continue;
if (h.index > cursor) frag.appendChild(doc.createTextNode(text.slice(cursor, h.index)));
const url = urlFor(h.rule, h.code);
if (actionOf(h.rule) === 'button') {
// text 模式没法「凭空插到某个位置」,所以包一层**纯定位用**的 span:
// 不带 markClass、不加任何视觉、点击也不拦,只用来承载 data-pst-code 并给按钮定位。
const anchor = doc.createElement('span');
anchor.className = 'pst-wrap pst-trace-anchor';
anchor.setAttribute('data-pst-code', h.code);
anchor.setAttribute('data-pst-rule', h.rule.id);
anchor.textContent = h.text;
frag.appendChild(anchor);
frag.appendChild(makeButton(h.rule, h.code));
marks.push({ el: anchor.nextSibling, rule: h.rule, code: h.code, text: h.text, index: h.index });
} else {
const span = doc.createElement('span');
const style = h.rule.style || o.defaultStyle || 'underline';
span.className = markClass + ' pst-wrap pst-style-' + style + (o.showIcon !== false ? ' pst-has-icon' : '');
span.setAttribute('data-pst-code', h.code);
span.setAttribute('data-pst-rule', h.rule.id);
span.setAttribute('role', 'link');
span.tabIndex = 0;
span.setAttribute('data-pst-tab', '1');
if (url) {
span.setAttribute('data-pst-url', url);
span.setAttribute('title', url);
}
span.textContent = h.text; // 原文照抄,页面 textContent 不变
frag.appendChild(span);
marks.push({ el: span, rule: h.rule, code: h.code, text: h.text, index: h.index });
}
pushItem(h.rule, h.code, h.text, url);
cursor = h.index + h.text.length;
}
if (cursor < text.length) frag.appendChild(doc.createTextNode(text.slice(cursor)));
tn.parentNode.replaceChild(frag, tn);
}
}
return { items, marks, truncated };
}
/** 撤销所有加工,把页面还原成原样(关掉开关 / 改规则时调用) */
function unmark(rootEl, markClass) {
const sel = '.' + (markClass || 'pst-trace-mark');
const el = rootEl || (typeof document !== 'undefined' ? document : null);
if (!el || typeof el.querySelectorAll !== 'function') return 0;
const doc = el.ownerDocument || (typeof document !== 'undefined' ? document : null);
let n = 0;
// 1) 先删我们插进去的按钮(button 模式下唯一动过的东西)
for (const b of Array.prototype.slice.call(el.querySelectorAll('.pst-trace-btn'))) {
b.remove();
n++;
}
// 2) 我们自己 wrap 出来的 span 换回纯文本:
// chip 模式的定位 span、 button 模式的 pst-trace-anchor 都带 pst-wrap
for (const w of Array.prototype.slice.call(el.querySelectorAll('.pst-wrap'))) {
if (w.parentNode && doc) {
w.parentNode.replaceChild(doc.createTextNode(w.textContent), w);
n++;
}
}
// 3) button 模式留在宿主元素上的两个 data-* 记号(它没有 markClass,第 4 步选不到)
for (const h of Array.prototype.slice.call(el.querySelectorAll('[data-pst-rule]:not(' + sel + ')'))) {
h.removeAttribute('data-pst-code');
h.removeAttribute('data-pst-rule');
n++;
}
// 4) chip 模式:把加在宿主元素上的痕迹抹掉
const classes = ['pst-mode-selector', 'pst-has-icon', 'pst-open',
'pst-style-underline', 'pst-style-highlight', 'pst-style-chip'];
for (const host of Array.prototype.slice.call(el.querySelectorAll(sel + ':not(.pst-wrap)'))) {
host.classList.remove(sel.slice(1));
for (const c of classes) host.classList.remove(c);
host.removeAttribute('data-pst-code');
host.removeAttribute('data-pst-rule');
host.removeAttribute('data-pst-url');
// tabindex 只有我们能确定是自己加的时候才删(用 data-pst-tab 记过账)
if (host.hasAttribute('data-pst-tab')) {
host.removeAttribute('tabindex');
host.removeAttribute('data-pst-tab');
}
if (host.getAttribute('role') === 'link') host.removeAttribute('role');
if (host.hasAttribute('data-pst-title')) {
const prev = host.getAttribute('data-pst-title');
host.removeAttribute('data-pst-title');
if (prev) host.setAttribute('title', prev); else host.removeAttribute('title');
}
n++;
}
return n;
}
/* ------------------------------------------------------------ 站点/地址 */
function hostAllowed(hostname, host, patterns) {
const list = toStrArray(patterns, ['*']);
if (list.indexOf('*') >= 0) return true;
const targets = [String(hostname || ''), String(host || '')].filter(Boolean);
if (!targets.length) return true; // 拿不到 host(比如配置页试跑)就不拦
return list.some(p => targets.some(t => globMatch(p, t)));
}
function globMatch(pattern, value) {
const p = String(pattern || '').trim();
if (!p) return false;
if (p === '*') return true;
const body = p.split('*').map(escapeRe).join('[^\\s]*');
try {
return new RegExp('^' + body + '$', 'i').test(String(value));
} catch (_) {
return false;
}
}
/** 把 {code} 换成编号、{host} 换成当前站点;URL 模板里可以重复出现 */
function buildUrl(template, code, host) {
const tpl = String(template || '').trim() || DEFAULT_URL_TEMPLATE;
const c = code == null ? '' : String(code);
return tpl
.replace(/\{code\}/gi, encodeURIComponent(c))
.replace(/\{host\}/gi, encodeURIComponent(String(host || '')))
.replace(/\{rawcode\}/gi, c);
}
/* ------------------------------------------------------- 存储(chrome) */
function hasChromeStorage() {
try {
return typeof chrome !== 'undefined' && chrome.storage && chrome.storage.local;
} catch (_) {
return false;
}
}
async function loadConfig() {
if (!hasChromeStorage()) return defaultConfig();
let raw = null;
try {
if (chrome.storage.sync) {
const r = await chrome.storage.sync.get(STORAGE_KEY);
raw = r && r[STORAGE_KEY];
}
} catch (_) { /* sync 不可用(企业策略)时退到 local */ }
if (raw == null) {
try {
const r = await chrome.storage.local.get(STORAGE_KEY);
raw = r && r[STORAGE_KEY];
} catch (_) { /* ignore */ }
}
const cfg = normalizeConfig(raw);
// 老配置(version 低)刚被迁移过:顺手把结果落盘一次,省得每次读取都要再迁一遍
if (raw && Number(raw.version || 1) < CONFIG_VERSION) {
try {
await saveConfig(cfg);
} catch (_) { /* 写不进去也不影响本次使用 */ }
}
return cfg;
}
/**
* 存配置。chrome.storage.sync 单个条目上限 8KB,规则多了会超 —— 超了就落到 local,
* 并把警告返回给调用方展示(而不是静默丢配置)。
*/
async function saveConfig(cfg) {
const value = normalizeConfig(cfg);
if (!hasChromeStorage()) return { ok: true, area: 'none' };
if (chrome.storage.sync) {
try {
await chrome.storage.sync.set({ [STORAGE_KEY]: value });
return { ok: true, area: 'sync' };
} catch (e) {
try {
await chrome.storage.local.set({ [STORAGE_KEY]: value });
} catch (e2) {
return { ok: false, message: shortMessage(e2) };
}
return {
ok: true,
area: 'local',
warning: '配置超出同步配额(sync 单项 8KB),已存到本机:换设备不会自动同步。原因:' + shortMessage(e),
};
}
}
try {
await chrome.storage.local.set({ [STORAGE_KEY]: value });
return { ok: true, area: 'local' };
} catch (e) {
return { ok: false, message: shortMessage(e) };
}
}
/* ------------------------------------------------------------ 小工具 */
function toStrArray(v, fallback) {
const arr = Array.isArray(v) ? v : (typeof v === 'string' ? v.split(/[\s,;]+/) : []);
const out = arr.map(x => String(x == null ? '' : x).trim()).filter(Boolean);
return out.length ? out : fallback.slice();
}
function clampInt(v, min, max, dft) {
const n = Number.parseInt(v, 10);
if (!Number.isFinite(n)) return dft;
return Math.min(max, Math.max(min, n));
}
function escapeRe(s) {
return String(s).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}
function escapeHtml(s) {
return String(s == null ? '' : s)
.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
.replace(/"/g, '&quot;').replace(/'/g, '&#39;');
}
function shortMessage(e) {
const m = e && e.message ? String(e.message) : String(e || '');
return m.length > 160 ? m.slice(0, 160) + '…' : m;
}
root.PSTRules = {
STORAGE_KEY,
DEFAULT_URL_TEMPLATE,
DEFAULT_APP_URL_TEMPLATE,
DEFAULT_FALLBACK_URL,
OPEN_MODES,
MARK_STYLES,
defaultConfig,
normalizeConfig,
normalizeRemote,
applyRemote,
normalizeRule,
compileRules,
matchText,
applyMarks,
unmark,
extractCode,
hostAllowed,
globMatch,
buildUrl,
loadConfig,
saveConfig,
escapeHtml,
};
})(typeof globalThis !== 'undefined' ? globalThis : this);