，混进列表会污染翻页。
inst.galleryList = [];
inst.galleryIndex = -1;
} else {
try {
inst.galleryList = collectGalleryImages(img);
inst.galleryIndex = Math.max(0, inst.galleryList.indexOf(img));
} catch (e) { inst.galleryList = [img]; inst.galleryIndex = 0; }
}
zoomedImg.onload = () => {
if (inst.generation !== generation || instance !== inst) return; // 过期代际/实例回调直接丢弃
// 「软 404」防护：服务器对不存在路径返回 200 + 空/非图响应时 naturalWidth=0，按加载失败处理；
// 同判据也覆盖真实像素 ≤1×1 的占位/跟踪像素。
if (!(zoomedImg.naturalWidth > 0 && zoomedImg.naturalHeight > 0) ||
(zoomedImg.naturalWidth <= 1 && zoomedImg.naturalHeight <= 1)) {
FSM.dispatch('ERROR', inst);
return;
}
if (inst.wheelZoom && zoomedImg.naturalWidth > 0 && zoomedImg.naturalHeight > 0) {
const nextRatio = zoomedImg.naturalWidth / zoomedImg.naturalHeight;
// ★ w/h 提升到外层作用域：下方「非 center 显示位置重锚」(placement near/around) 也要用。
// 原来只在内层 if（宽高比变化才进入）里 const 声明 → 宽高比未变时下方引用 w 会
// ReferenceError: w is not defined（around/near + wheelZoom + 高清图与原图同比例必现）。
let w = Math.max(1, Math.round(inst.zoomBaseW * inst.currentZoom));
let h = Math.max(1, Math.round(inst.zoomBaseH * inst.currentZoom));
if (nextRatio > 0 && Math.abs(nextRatio - inst.imageRatio) > 0.0001) {
inst.imageRatio = nextRatio;
inst.zoomBaseH = Math.max(1, inst.zoomBaseW / nextRatio);
w = Math.max(1, Math.round(inst.zoomBaseW * inst.currentZoom));
h = Math.max(1, Math.round(inst.zoomBaseH * inst.currentZoom));
inst.container.style.setProperty('width', w + 'px', 'important');
inst.container.style.setProperty('height', h + 'px', 'important');
zoomedImg.style.setProperty('width', w + 'px', 'important');
zoomedImg.style.setProperty('height', h + 'px', 'important');
}
// ★ 兜底：滚轮模式下高清图/大比例图加载后，仍须遵守「自适应初始放大不超视口」语义。
// 无黑边竖图不会触发 cropBlackBars 的 kFit，这里统一把初始盒收进可用空间（含 capbar 预留）。
{
const capRes = capbarReserve();
const follow = (sizeStepIndex() === 3);
// ★ 跟随视口档：宽度基本不设限（仅在极端横图超过视口宽时兜底），纵向用「页面高度 − 信息栏」；
// 小/中/大档保留 60px 边距（与 computeAdaptiveSize 的档位框一致）。
const availW = Math.max(160, window.innerWidth - (follow ? 0 : 60));
const availH = Math.max(160, visualInnerH() - (follow ? capRes : (60 + capRes)));
const kFit = Math.min(1, availW / w, availH / h);
if (kFit < 1) {
w = Math.max(1, Math.round(w * kFit));
h = Math.max(1, Math.round(h * kFit));
inst.container.style.setProperty('width', w + 'px', 'important');
inst.container.style.setProperty('height', h + 'px', 'important');
zoomedImg.style.setProperty('width', w + 'px', 'important');
zoomedImg.style.setProperty('height', h + 'px', 'important');
// ★ 同步滚轮缩放基准：kFit 改变了显示尺寸，若不更新 zoomBaseW/H，
// 首次滚轮会按旧基准重算（zoomBaseW × newZoom）→ 尺寸跳变
// （竖图"首次滚轮先变很大"bug，与 cropBlackBars 滚轮分支同款处理）。
const cz = Number(inst.currentZoom) > 0 ? inst.currentZoom : 1;
inst.zoomBaseW = Math.max(1, w / cz);
inst.zoomBaseH = Math.max(1, h / cz);
}
}
// 重采样分级：缩小 / ≈1:1 → auto（平滑）；放大超原图且 ≤3 倍 → crisp-edges（锐利）；>3 倍 → auto（防马赛克）。
try {
const dispW = parseFloat(zoomedImg.style.width) || 0;
const natW = zoomedImg.naturalWidth || 0;
if (dispW > 0 && natW > 0) {
zoomedImg.style.imageRendering = (dispW > natW + 1 && dispW / natW <= 3) ? 'crisp-edges' : 'auto';
}
} catch (e) { }
// ★ 非 center 显示位置：高清换图重算尺寸后收拢锚点（仍按当前倍率的盒子算，
// 不干预用户此后的滚轮放大/平移自由）
if (inst.placementMode === 'near') {
const c = inst.container;
const fitAxis = (cur, half, total) =>
(half * 2 + 16 > total) ? total / 2
: Math.max(half + 8, Math.min(cur, total - half - 8));
c.style.left = fitAxis(parseFloat(c.style.left) || window.innerWidth / 2, w / 2, window.innerWidth) + 'px';
c.style.top = fitAxis(parseFloat(c.style.top) || window.innerHeight / 2, h / 2, window.innerHeight) + 'px';
} else if (inst.placementMode === 'around' && inst.aroundSide && inst.aroundRect) {
// around 不能走上面的视口 clamp（会把 createInstance 算好的锚点抹掉 → 退化为居中盖住原图）；
// 这里按当时的选侧与原图矩形重算锚点。
const c = inst.container;
const curW = c.offsetWidth || w;
const curH = c.offsetHeight || h;
const a = computeAroundAnchor(inst.aroundSide, inst.aroundRect, curW, curH);
if (a) {
c.style.left = Math.round(a.cx) + 'px';
c.style.top = Math.round(a.cy) + 'px';
}
}
}
// 加载成功的图未必是建实例时的图（如后台探活替换的高清图），比例不同时需按新比例重做 contain 适配，
// 否则内联 object-fit:fill 会把图片拉伸变形。
if (!inst.wheelZoom && zoomedImg.naturalWidth > 0 && zoomedImg.naturalHeight > 0) {
refitInstanceImage(inst);
}
// 黑边裁剪对「滚轮缩放模式」同样启用（否则换高清图后带黑边会撑大预览超页）；
// cropBlackBars 内部已有滚轮保护分支。
cropBlackBars(zoomedImg);
updateImageInfo(inst);
// 信息栏构建完成后再校正一次尺寸：用实际信息栏高度重算可用高度并等比校正；仅「初始未缩放」时生效，不干扰滚轮。
try {
if (inst.wheelZoom && Math.abs(Number(inst.currentZoom) - Number(inst.initialZoom)) < 0.001) {
// ★ 必须用 stepCaps() 按档位取框（此时 capbarReserve() 已能拿到实际信息栏高度）；
// 若对所有档统一用「视口−边距−信息栏」，小/中/大三档会被一起放大到同一上限 → 档位被抹平。
const caps2 = stepCaps();
const availW2 = caps2.w, availH2 = caps2.h;
const curW = inst.container.offsetWidth, curH = inst.container.offsetHeight;
if (curW > 0 && curH > 0) {
const k2 = Math.min(availW2 / curW, availH2 / curH);
if (Math.abs(k2 - 1) > 0.01) {
const nw = Math.max(1, Math.round(curW * k2));
const nh = Math.max(1, Math.round(curH * k2));
inst.container.style.setProperty('width', nw + 'px', 'important');
inst.container.style.setProperty('height', nh + 'px', 'important');
inst.imgEl.style.setProperty('width', nw + 'px', 'important');
inst.imgEl.style.setProperty('height', nh + 'px', 'important');
const cz = Number(inst.currentZoom) > 0 ? inst.currentZoom : 1;
inst.zoomBaseW = Math.max(1, nw / cz);
inst.zoomBaseH = Math.max(1, nh / cz);
if (inst.placementMode === 'around' && inst.aroundSide && inst.aroundRect) {
const a = computeAroundAnchor(inst.aroundSide, inst.aroundRect, nw, nh);
if (a) { inst.container.style.left = Math.round(a.cx) + 'px'; inst.container.style.top = Math.round(a.cy) + 'px'; }
} else if (inst.placementMode === 'near') {
const c = inst.container;
const fitAxis = (cur, half, total) => (half * 2 + 16 > total) ? total / 2 : Math.max(half + 8, Math.min(cur, total - half - 8));
c.style.left = fitAxis(parseFloat(c.style.left) || window.innerWidth / 2, nw / 2, window.innerWidth) + 'px';
c.style.top = fitAxis(parseFloat(c.style.top) || window.innerHeight / 2, nh / 2, window.innerHeight) + 'px';
}
}
}
}
} catch (e) { }
if (!inst.revealed) {
inst.revealed = true;
FSM.dispatch('LOADED', inst);
}
};
zoomedImg.onerror = () => {
if (inst.generation !== generation || instance !== inst) return;
// ★ 防盗链绕过兜底：URL 无尺寸指令（无升级候选）且尚未用脚本身份抓取过时，
// 原图直连失败就直接用 GM 身份重新抓取（带 referer 被 403 的典型防盗链场景）。
if (hdCandidates.length === 0 && !zoomedImg.__zoomBlobUrl) {
gmFetchBlobUrl(fallbackSrc)
.then((blobUrl) => applyHiRes(fallbackSrc, blobUrl))
.catch(() => { FSM.dispatch('ERROR', inst); });
return;
}
FSM.dispatch('ERROR', inst);
};
zoomedImg.src = fallbackSrc;
// ★ 智能高清升级器：两段式探测 —— 先探「规则链结果」（够用就停，不浪费流量），
// 不够用/不可用再探「尺寸档位变体」；全失败再走防盗链抓取；都失败保持源图。
const hd = (function () {
try { return buildHdCandidates(fallbackSrc); } catch (e) { return { primary: [], variants: [] }; }
})();
const hdPrimary = (function () {
const arr = [];
if (hiResSrc) arr.push(hiResSrc); // 只先探「规则链的最终结果」
return arr;
})();
// 站点自声明的大图（srcset / / data-* 原图）排在备选池最前：比盲猜尺寸变体可信
const elSources = (function () {
try { return collectElementSources(img, HD_MAX_CANDIDATES); } catch (e) { return []; }
})();
const hdExtra = elSources.concat(hd.primary, hd.variants)
.filter(function (u, i, a) { return u && a.indexOf(u) === i && hdPrimary.indexOf(u) < 0; })
.slice(0, HD_MAX_CANDIDATES);
const hdCandidates = hdPrimary.concat(hdExtra);
const ac = currentAbort;
const applyHiRes = (finalUrl, blobUrl) => {
if (ac && ac.signal.aborted) return;
if (inst.generation !== generation) return;
if (!zoomedImg.isConnected) { if (blobUrl) releaseBlobUrl(blobUrl); return; }
if (!blobUrl && zoomedImg.src === finalUrl) return;
if (zoomedImg.__zoomBlobUrl) releaseBlobUrl(zoomedImg.__zoomBlobUrl);
zoomedImg.__zoomBlobUrl = blobUrl || null;
delete zoomedImg.dataset.zoomCropped;
inst.usingHiRes = true;
inst.infoSrc = finalUrl;
zoomedImg.src = blobUrl || finalUrl;
updateImageInfo(inst);
};
if (hdCandidates.length) {
if (HV_DEBUG) { inst.hdDiag = '最终结果' + hdPrimary.length + '·备选' + hdExtra.length; updateImageInfo(inst); }
const dpr = Math.max(1, Math.min(3, window.devicePixelRatio || 1));
const availNow = Math.min(
Math.min(window.innerWidth - 60, config.maxWidth),
Math.min(window.innerHeight - 60, config.maxHeight)
);
// 够用标准 = 预览可能的最大显示尺寸 × 设备像素比（不加余量：宁可取小一档，也别为了清晰抓巨图）
const needMax = Math.max(600, Math.min(2400, Math.round(availNow * dpr)));
// 源图较长边 = 负升级闸门下界。取法有二，按图片元素形态二选一：
// ① 元素是 ![]()
：currentSourcePixelWidth 给文件像素宽（srcset 场景已按 w 描述符换算），
// 再按自然比例推长边（密度校正对宽高同比例，故比例可信）。
// ② 元素不是 ![]()
（背景图宿主 div）：只能靠预览里那张图的真实文件尺寸。
// 都取不到 → 0，闸门失效（fail-open，与本改动前行为一致）。
const sourceLongSide = (function () {
try {
const base = (img.ownerDocument && img.ownerDocument.baseURI) || location.href;
const w = currentSourcePixelWidth(img, base);
const nw = img.naturalWidth || 0, nh = img.naturalHeight || 0;
if (w > 0) return (nw > 0 && nh > 0) ? Math.max(w, Math.round(w * nh / nw)) : w;
const zw = zoomedImg.naturalWidth || 0, zh = zoomedImg.naturalHeight || 0;
return (zw > 0 && zh > 0) ? Math.max(zw, zh) : 0;
} catch (e) { return 0; }
})();
const finishWith = (loaded, extra) => {
if (ac && ac.signal.aborted) return;
const best = pickBestCandidate(loaded, needMax, sourceLongSide);
if (HV_DEBUG) { inst.hdDiag = hdCandidates.length + '候选·探成' + loaded.length + '·选' + (best ? Math.max(best.w, best.h) + 'px' : '无') + '·需' + needMax + '·源' + sourceLongSide + (extra || ''); }
if (best) { applyHiRes(best.url, null); return; }
// 全部直连失败（一个都没加载成功）→ 防盗链绕过（以脚本身份抓第一候选）
// 注意：候选「加载成功但都比源图小」不算失败，此时保持源图预览，不做负升级。
if (!loaded.length) {
gmFetchBlobUrl(hdCandidates[0])
.then((blobUrl) => applyHiRes(hdCandidates[0], blobUrl))
.catch(() => { if (HV_DEBUG) updateImageInfo(inst); /* 静默回退：保持源图预览 */ });
return;
}
if (HV_DEBUG) updateImageInfo(inst);
};
if (hdPrimary.length) {
probeCandidates(hdPrimary, 2500).then((loaded1) => {
if (ac && ac.signal.aborted) return;
const enough = loaded1.filter((c) => Math.max(c.w, c.h) >= needMax);
if (enough.length || !hdExtra.length) { finishWith(loaded1, enough.length ? '·够用即停' : ''); return; }
// 规则结果不够用/不可用 → 再探备选（中间态 + 尺寸变体）
probeCandidates(hdExtra, 2500).then((loaded2) => finishWith(loaded1.concat(loaded2), '·含备选'));
});
} else {
probeCandidates(hdExtra, 2500).then((loaded) => finishWith(loaded, '·仅备选'));
}
}
if (zoomedImg.complete && zoomedImg.naturalWidth > 0 && !inst.revealed) {
inst.revealed = true;
setTimeout(() => {
if (inst.generation === generation && instance === inst) FSM.dispatch('LOADED', inst);
}, 10);
}
container.appendChild(zoomedImg);
document.body.appendChild(container);
return inst;
} catch (error) {
console.warn('[FSM] 创建放大实例失败:', error);
return null;
}
}
const actions = {
startPending(img) {
clearPending();
pendingImg = img;
pendingImageForIndicator = img;
scheduleHoverWaitIndicator(img);
pendingTimer = setTimeout(() => FSM.dispatch('TIMER_FIRE', img), config.delay);
state = S.PENDING;
},
cancel() {
clearPending();
generation++; // ★ 作废在途异步任务
if (currentAbort) { currentAbort.abort(); currentAbort = null; }
state = S.IDLE;
},
show(payload) {
// payload 两种形态：① 裸元素（![]()
，既有调用方）② { el, srcOpts }（背景图等「无 ![]()
可读地址」的来源）
const el = (payload && payload.el) || payload;
const srcOpts = (payload && payload.srcOpts) || null;
if (!el) { hideHoverWaitIndicator(); state = S.IDLE; wheelManager.sync(); return; }
// ★ 等待动画保持显示，直到该实例真正 LOADED/ACTIVE。
// 新目标：作废上一代在途任务并开启新代（ADR-002）
if (currentAbort) currentAbort.abort();
currentAbort = new AbortController();
generation++;
const inst = createInstance(el, srcOpts);
if (!inst) {
hideHoverWaitIndicator();
state = S.IDLE;
wheelManager.sync();
return;
}
instance = inst;
state = S.SHOWING;
wheelManager.sync();
},
activate(inst) {
if (inst.generation !== generation || inst !== instance) return;
hideHoverWaitIndicator();
// ★ 入场动画（动画模式由 ptEnter 接管显示观感；返回 false 时退回纯淡入）
if (!ptEnter(inst)) {
inst.container.style.opacity = '1';
inst.imgEl.style.opacity = '1';
}
// 容器已完全显示，此刻刷新信息浮层并亮出（加载阶段先不显）
updateImageInfo(inst);
// ★ 历史记录：预览真正显示出来才记（图集翻页每张各记一条）
recordHistory(inst);
// ★ 反馈截图：留一份小尺寸快照（仅本地，供面板「反馈问题」附带）
capturePreviewShot(inst);
// 图片超出视口时提示当前滚轮操作（1200ms 后自动消失，避免遮挡）
if (inst.container.offsetHeight > window.innerHeight && !inst.toastShown) {
inst.toastShown = true;
showToast(config.wheelZoom ? '滚动滚轮缩放图片' : '图片超出屏幕，滚动滚轮查看其余部分', 800);
}
state = S.ACTIVE;
// ★ 邻图预加载：图集里把前后张的高清地址预热进缓存，翻页零等待（实例已换/已收起则自动放弃）
scheduleGalleryPrefetch(inst, function () { return instance === inst && state === S.ACTIVE; });
// ★ 通知其他 frame：本 frame 已有 ACTIVE 预览
arbiterStartRenew();
// ★ P1 竞态修复：准入检查与占位是两次独立读写，两帧可能同时通过。
// 这里在复核窗口后再确认归属，输的一方主动让出，保证屏幕上只有一个预览。
(function verifyArbiter() {
const gen = generation, instRef = inst;
setTimeout(() => {
// 期间已切图 / 已收起 → 不属于本次仲裁范围，不动
if (instance !== instRef || generation !== gen) return;
if (!arbiterElectionLost()) return; // 赢得选举 → 正常保留
arbiterCooldownUntil = Date.now() + ARBITER_COOLDOWN;
arbiterStopRenew();
// 回退：HOVER_NONE(force) 会走 beginFade，一并释放仲裁
FSM.dispatch('HOVER_NONE', { x: lastMouse.x, y: lastMouse.y, force: true });
}, ARBITER_SETTLE);
})();
},
onError(inst) {
if (inst.generation !== generation || inst !== instance) return;
if (inst.usingHiRes) {
inst.usingHiRes = false;
inst.imgEl.src = inst.fallbackSrc;
return;
}
if (currentAbort) { currentAbort.abort(); currentAbort = null; }
fadeOutContainer(inst.container);
instance = null;
state = S.IDLE;
wheelManager.sync();
// 源图直连、高清候选、GM 兜底抓取全部失败：给出明确提示，避免用户「悬停后空白框一闪 / 无反应」却不知为何。
try { showToast('图片加载失败，已跳过'); } catch (e) { }
},
beginFade() {
clearPending();
generation++; // ★ 离开/切换：立即作废在途任务（ADR-003）
if (currentAbort) { currentAbort.abort(); currentAbort = null; }
if (instance) {
fadeOutContainer(instance.container);
instance = null;
}
state = S.FADING;
arbiterStopRenew(); // ★ 预览开始淡出即释放仲裁
setTimeout(() => { if (state === S.FADING) state = S.IDLE; }, FADE_MS);
wheelManager.sync();
},
// 最大倍率：按原图分辨率动态放宽，但不生成失控的超大 DOM（拿不到原图尺寸时用保守上限）
maxZoomFor(inst) {
const naturalW = Number(inst && inst.sourceImg && inst.sourceImg.naturalWidth) || 0;
const naturalH = Number(inst && inst.sourceImg && inst.sourceImg.naturalHeight) || 0;
const basePixels = naturalW > 0 && naturalH > 0 ? naturalW * naturalH : 0;
const resolutionZoom = basePixels > 0
? Math.sqrt((12000000) / basePixels) * Math.max(1, Math.min(4, Math.max(naturalW, naturalH) / 1200))
: 24;
return Math.max(20, Math.min(50, resolutionZoom));
},
// 把某个倍率真正落到容器/图片上。★ 滚轮与键盘走同一条路径，避免两套缩放逻辑跑偏。
// force=true 时即使倍率没变也重新应用（旋转/翻转只改朝向，倍率不变）。
applyZoom(inst, wantZoom, force) {
if (!inst) return false;
const c = inst.container, im = inst.imgEl;
if (!c || !im) return false;
const sourceW = Number(inst.sourceW) || (inst.sourceImg ? inst.sourceImg.getBoundingClientRect().width : 0);
const sourceH = Number(inst.sourceH) || (inst.sourceImg ? inst.sourceImg.getBoundingClientRect().height : 0);
if (!(sourceW > 0 && sourceH > 0)) return false;
// 始终以 1× 为下限；上限按原图分辨率动态计算。
const current = Number.isFinite(inst.currentZoom) ? inst.currentZoom : 1;
const nextZoom = Math.max(1, Math.min(actions.maxZoomFor(inst), Number(wantZoom) || 1));
if (!force && Math.abs(nextZoom - current) < 0.0001) return false;
inst.currentZoom = nextZoom;
// 宽高始终由同一个缩放倍率计算，绝不分别缩放，保证横竖图比例恒定。
// 缩放基准固定为实例当前的 zoom=1 尺寸。
// 裁剪、高清图替换等异步过程不会再把这个基准重置成容器尺寸。
const baseW = Number(inst.zoomBaseW) > 0 ? inst.zoomBaseW : sourceW;
const ratio = Number(inst.imageRatio) > 0 ? inst.imageRatio : (sourceW / Math.max(1, sourceH));
const baseH = Number(inst.zoomBaseH) > 0 ? inst.zoomBaseH : (baseW / ratio);
// ★ 旋转/翻转：旋转 90/270 时「显示比例」要交换，旋转施加在容器上
// （图片只负责填满容器，容器整体旋转 → 比例天然正确，也不干扰图片自身的平移逻辑）。
const rot = ((Number(inst.rotation) || 0) % 360 + 360) % 360;
const swapped = (rot % 180) !== 0;
// 容器盒子：旋转后要占的位（90/270 时与图片自身宽高互换）
const visW = swapped ? baseH : baseW;
const visH = swapped ? baseW : baseH;
const w = Math.max(1, Math.round(visW * nextZoom));
const h = Math.max(1, Math.round(visH * nextZoom));
// 图片自身尺寸：★ 始终按自身比例，绝不跟着容器交换 ——
// 否则图片会被拉伸变形（旋转是靠容器转，图片只要居中即可）。
const iw = Math.max(1, Math.round(baseW * nextZoom));
const ih = Math.max(1, Math.round(baseH * nextZoom));
const tf = ['translate(-50%, -50%)'];
if (rot) tf.push('rotate(' + rot + 'deg)');
if (inst.flipH) tf.push('scaleX(-1)');
if (inst.flipV) tf.push('scaleY(-1)');
c.style.setProperty('width', w + 'px', 'important');
c.style.setProperty('height', h + 'px', 'important');
c.style.setProperty('max-width', 'none', 'important');
c.style.setProperty('max-height', 'none', 'important');
c.style.setProperty('overflow', 'visible', 'important');
c.style.transform = tf.join(' ');
// 旋转/翻转时隐藏信息栏（外壳保留）：文字跟着倒转或镜像会很难读。
// 同时改 class 与内联 opacity —— 内联样式才能稳定压过后面的 setOpacity 同步。
try {
const hideCap = !!(rot || inst.flipH || inst.flipV);
c.classList.toggle('hv-nocap', hideCap);
const bar = c.querySelector('.hv-capbar');
if (bar) bar.style.opacity = hideCap ? '0' : '1';
} catch (e) { }
// 不在这里 clamp 锚点：滚轮放大后允许超出视口 + 平移查看；收拢只发生在 createInstance 与高清换图重算尺寸后。
inst.panY = 0;
im.style.setProperty('width', iw + 'px', 'important');
im.style.setProperty('height', ih + 'px', 'important');
im.style.setProperty('max-width', 'none', 'important');
im.style.setProperty('max-height', 'none', 'important');
im.style.setProperty('min-width', '0', 'important');
im.style.setProperty('min-height', '0', 'important');
im.style.setProperty('object-fit', 'contain', 'important');
// 重采样分级：缩小 / ≈1:1 → auto（平滑）；放大超原图时 ≤3 倍用 crisp-edges（锐利）、>3 倍用 auto（防马赛克）。
try {
const nw2 = im.naturalWidth || 0, nh2 = im.naturalHeight || 0;
if (nw2 > 0 && nh2 > 0) {
const up = (iw > nw2 + 1) || (ih > nh2 + 1);
const k = Math.max(iw / nw2, ih / nh2);
im.style.imageRendering = (up && k <= 3) ? 'crisp-edges' : 'auto';
}
} catch (e) { }
if (swapped) {
// 旋转 90/270：容器盒子与图片宽高互换，图片必须居中才不会被转偏
im.style.setProperty('left', '50%', 'important');
im.style.setProperty('top', '50%', 'important');
im.style.setProperty('transform', 'translate(-50%, -50%)', 'important');
} else {
// 未旋转：保持既有定位（平移逻辑依赖 left/top 为 0）
im.style.setProperty('left', '0px', 'important');
im.style.setProperty('top', '0px', 'important');
im.style.setProperty('transform', 'none', 'important');
}
// 外壳 hull 必须跟「图片」定盒而非容器盒（旋转 90/270 时容器盒与图片宽高互换，按容器定盒会导致框不跟转）。
try {
const hull = c.querySelector('.hv-hull');
if (hull) {
const hw = iw + 20, hh = ih + 20;
hull.style.setProperty('width', hw + 'px', 'important');
hull.style.setProperty('height', hh + 'px', 'important');
hull.style.setProperty('left', Math.round((w - hw) / 2) + 'px', 'important');
hull.style.setProperty('top', Math.round((h - hh) / 2) + 'px', 'important');
hull.style.setProperty('right', 'auto', 'important');
hull.style.setProperty('bottom', 'auto', 'important');
}
} catch (e) { }
return true;
},
// 乘法步进缩放（键盘 +/- 与滚轮共用同一条路径）
zoomBy(factor) {
if (!instance) return false;
const current = Number.isFinite(instance.currentZoom) ? instance.currentZoom : 1;
return actions.applyZoom(instance, current * factor);
},
// 回到「进入预览时的尺寸」（撤销所有缩放）：不能写成 applyZoom(instance, 1)——currentZoom 是相对缩略图尺寸的倍数。
resetZoom() {
if (!instance) return false;
const base = Number.isFinite(instance.initialZoom) && instance.initialZoom > 0
? instance.initialZoom
: (Number.isFinite(instance.currentZoom) ? instance.currentZoom : 1);
return actions.applyZoom(instance, base);
},
// ★ 保存图片：优先存「高清原图」地址。
// inst.infoSrc 始终是真实来源地址（高清升级成功时已换成升级后的），
// 而 imgEl.src 在黑边裁剪后可能是 blob:，不能拿来下载。
saveImage() {
if (!instance) return false;
const inst = instance;
const url = String(inst.infoSrc || inst.fallbackSrc || '').trim();
if (!url) { showToast('没有可保存的图片地址', 1600); return true; }
const name = buildDownloadName(inst, url);
// 1) 首选 GM_download：能正确处理跨域 / 防盗链，也不会把页面导航走
try {
if (typeof GM_download === 'function') {
GM_download({
url: url,
name: name,
saveAs: false,
onload: function () { showToast('已保存：' + name, 1800); },
onerror: function () { downloadViaAnchor(url, name); }
});
return true;
}
} catch (e) { }
// 2) 降级：
downloadViaAnchor(url, name);
return true;
},
// 图集打包下载（z）：把当前图集整组抓下来打成一个 ZIP
async downloadGalleryZip() {
return await downloadGalleryZipFor(instance);
},
// 复制图片地址（c）
copyLink() {
if (!instance) return false;
const url = String(instance.infoSrc || instance.fallbackSrc || '').trim();
if (!url) { showToast('没有可复制的地址', 1600); return true; }
copyText(url).then(function (ok) {
showToast(ok ? '已复制图片地址' : '复制失败（浏览器限制）', 1600);
});
return true;
},
// 复制图片本体（Shift+C）
copyImage() {
if (!instance) return false;
copyImageBody(instance).then(function (r) {
if (r === 'ok') showToast('已复制图片', 1500);
else if (r === 'unsupported') showToast('此浏览器不支持复制图片', 1800);
else if (r === 'tainted') showToast('该图片受跨域限制，无法复制', 2000);
else showToast('复制图片失败', 1600);
});
return true;
},
// 顺时针旋转 90°（r）
rotateBy() {
if (!instance) return false;
instance.rotation = (((Number(instance.rotation) || 0) + 90) % 360);
actions.applyZoom(instance, instance.currentZoom, true);
showToast('已旋转 ' + instance.rotation + '°', 900);
return true;
},
// 水平翻转（Shift+R）
flipHorizontal() {
if (!instance) return false;
instance.flipH = !instance.flipH;
actions.applyZoom(instance, instance.currentZoom, true);
showToast(instance.flipH ? '已水平翻转' : '已还原水平方向', 900);
return true;
},
// 图集翻页（← / →）。复用 beginFade + startPending，绕过"光标下必须是这张图"的检查。
switchGallery(dir) {
const inst = instance;
if (!inst) return false;
const list = inst.galleryList || [];
if (list.length < 2) { showToast('当前不是图集', 1000); return true; }
let i = list.indexOf(inst.sourceImg);
if (i < 0) i = inst.galleryIndex || 0;
const next = (i + dir + list.length) % list.length;
const target = list[next];
if (!target || !target.isConnected || target === inst.sourceImg) {
showToast('第 ' + (next + 1) + ' 张不可用', 1000);
return true;
}
actions.beginFade();
// ★ 记住翻页时的光标位置：本次预览显示的是"不在光标下"的另一张图，
// 需要让心跳的几何校验放行，否则新图一显示就被判为无效而取消。
galleryHoldAt = { x: lastMouse.x, y: lastMouse.y };
actions.startPending(target);
showToast((next + 1) + '/' + list.length, 800);
return true;
},
// 全屏（f）。对 documentElement 全屏：预览本来就是覆盖全页居中的，无需改动布局，
// 只需在进出时按屏幕重算一次缩放基准。
toggleFullscreen() {
try {
const isFs = !!(document.fullscreenElement || document.webkitFullscreenElement);
if (isFs) {
const exit = document.exitFullscreen || document.webkitExitFullscreen;
if (exit) exit.call(document);
} else {
const el = document.documentElement;
const req = el.requestFullscreen || el.webkitRequestFullscreen;
if (!req) { showToast('此环境不支持全屏', 1500); return true; }
const p = req.call(el);
if (p && p.catch) p.catch(function () { showToast('全屏被拒绝', 1500); });
}
} catch (e) { showToast('全屏失败', 1500); }
return true;
},
// 进出全屏时重算缩放基准：全屏下让图片按整个屏幕适配，退出时还原原基准与倍率
applyFullscreenLayout(on) {
const inst = instance;
if (!inst) return;
if (on) {
if (inst.fsSaved) return;
inst.fsSaved = { baseW: inst.zoomBaseW, baseH: inst.zoomBaseH, zoom: inst.currentZoom, ratio: inst.imageRatio };
const zImg = inst.imgEl;
const natW = (zImg && zImg.naturalWidth) || inst.zoomBaseW || 1;
const natH = (zImg && zImg.naturalHeight) || inst.zoomBaseH || 1;
const ratio = (natW > 0 && natH > 0) ? (natW / natH) : (inst.imageRatio || 1.5);
const vw = Math.max(100, window.innerWidth - 40);
const vh = Math.max(100, window.innerHeight - 40);
let fw = vw, fh = vw / ratio;
if (fh > vh) { fh = vh; fw = fh * ratio; }
inst.zoomBaseW = Math.max(1, Math.round(fw));
inst.zoomBaseH = Math.max(1, Math.round(fh));
inst.imageRatio = ratio;
inst.currentZoom = 1;
inst.fullscreen = true;
} else {
if (!inst.fsSaved) return;
inst.zoomBaseW = inst.fsSaved.baseW;
inst.zoomBaseH = inst.fsSaved.baseH;
inst.imageRatio = inst.fsSaved.ratio;
inst.currentZoom = inst.fsSaved.zoom;
inst.fsSaved = null;
inst.fullscreen = false;
}
actions.applyZoom(inst, inst.currentZoom, true);
},
zoomByWheel(e) {
// 缩放使用乘法倍率，避免不同基础倍率下出现“滚轮一下反而缩小一点”的视觉抖动。
// 向上放大约 8%，向下缩小约 7.4%。
actions.zoomBy(e.deltaY < 0 ? 1.08 : (1 / 1.08));
},
pan(e) {
if (!instance) return;
const c = instance.container, im = instance.imgEl;
const move = e.deltaY > 0 ? -config.scrollSpeed : config.scrollSpeed;
// 情况1：img 超出容器 → 容器内平移 img
const imgOverflow = im.offsetHeight - c.clientHeight;
if (imgOverflow > 0) {
const minTop = Math.min(0, -imgOverflow);
const cur = parseFloat(im.style.top) || 0;
im.style.top = Math.max(minTop, Math.min(0, cur + move)) + 'px';
return;
}
// 情况2：容器超出视口 → 整体平移容器，查看溢出部分
const overY = c.offsetHeight - window.innerHeight;
if (overY > 0) {
const limit = overY / 2; // 居中定位下，上下各溢出 overY/2
let cur = (instance.panY || 0) + move;
cur = Math.max(-limit, Math.min(limit, cur));
instance.panY = cur;
c.style.transform = `translate(-50%, calc(-50% + ${cur}px))`;
}
}
};
const FSM = {
get state() { return state; },
hasActiveZoom() { return state === S.SHOWING || state === S.ACTIVE; },
// 当前显示的是否为「背景图来源」的预览。仅供背景图触发层判断「该不该由我来收」，
// 避免它无条件收起时误伤用户正常的 ![]()
预览。
isBgActive() { return !!instance && instance.srcKind === 'bg' && (state === S.SHOWING || state === S.ACTIVE); },
getSourceRect() { return instance && instance.sourceImg && instance.sourceImg.isConnected ? instance.sourceImg.getBoundingClientRect() : null; },
heartbeat() {
if (!isEnabled || isHomepageZoomDisabled()) { FSM.dispatch('RESET'); return; }
// ★ 窗口切换后的恢复保护：必须等用户真实移动鼠标后才恢复 hover 裁决。
// 防止 Alt+Tab / 原生窗口切换时浏览器仅收到 focus/mouseover 等事件，
// 使用旧的 lastMouse 坐标再次触发放大，造成“先收起、再自动放大”。
if (resumeBlockedUntilMouseMove) return;
// ★ 窗口失焦且关闭了“失焦时收起”：保留当前预览，等待切回。
// 文件管理器等原生窗口覆盖浏览器时，浏览器可能收到 mouseout + blur；
// 此时不能把“窗口失焦”误判成“鼠标离开原图”。
if (!pointerInWindow) {
if (!browserWindowFocused && !config.blurDismiss) return;
if (state === S.PENDING) actions.cancel();
else if ((state === S.SHOWING || state === S.ACTIVE) && instance) actions.beginFade();
return;
}
const x = lastMouse.x, y = lastMouse.y;
if (x < 0) return;
if (state === S.PENDING && pendingImg) {
if (galleryHoldAt || canTriggerNow(pendingImg, x, y)) {
pendingFails = 0;
return;
}
pendingFails++;
if (pendingFails >= 2) actions.cancel();
return;
}
if (state === S.SHOWING || state === S.ACTIVE) {
if (!instance) { state = S.IDLE; return; }
// 只要在原图区域内就保持；离开原图（即使在放大图上方）→ 淡出
const sRect = instance.sourceImg.isConnected ? instance.sourceImg.getBoundingClientRect() : null;
if (!galleryHoldAt && !inRect(x, y, sRect)) actions.beginFade();
return;
}
},
orphanCheck() {
if (instance && instance.sourceImg && !instance.sourceImg.isConnected) actions.beginFade();
},
dispatch(event, payload) {
switch (event) {
case 'HOVER': {
const img = payload.img, x = payload.x, y = payload.y;
if (!isEnabled || isHomepageZoomDisabled()) break;
if (config.avoidClickConflict && isImageInLightboxMode()) break;
if (!img || !img.isConnected) break;
const anchor = canTriggerNow(img, x, y);
if (!anchor) {
if (state === S.PENDING && pendingImg === img) actions.cancel();
break;
}
if (state === S.SHOWING || state === S.ACTIVE) {
if (!instance) break;
if (img === instance.sourceImg) break; // 还是当前这张 → 保持不动
const zr = instance.container.getBoundingClientRect();
if (inRect(x, y, zr)) {
if (Date.now() - lastMouse.t < 300) {
actions.beginFade();
actions.startPending(img);
}
break;
}
actions.beginFade();
actions.startPending(img);
break;
}
if (state === S.PENDING) {
if (pendingImg !== img) actions.startPending(img);
} else {
actions.startPending(img); // IDLE / FADING
}
break;
}
case 'HOVER_NONE': {
const x = payload.x, y = payload.y;
// force=true 时跳过"lastMouse 在原图矩形内"的保活检查：
// 鼠标离开浏览器/窗口失焦时 lastMouse 是陈旧坐标，光标实际已不在图上
if (!(payload && payload.force) && (state === S.SHOWING || state === S.ACTIVE) && instance) {
const sr = instance.sourceImg.isConnected ? instance.sourceImg.getBoundingClientRect() : null;
if (inRect(x, y, sr)) break;
}
if (state === S.PENDING) actions.cancel();
else if (state === S.SHOWING || state === S.ACTIVE) actions.beginFade();
break;
}
case 'SHOW': {
// 显式请求直接显示（不走 PENDING 等待）：背景图触发层已经自己等过 config.delay
actions.show(payload);
break;
}
case 'TIMER_FIRE': {
if (state === S.PENDING && pendingImg === payload) {
// ★ 图集翻页保持：翻页时目标图不在光标下，canTriggerNow 必为 false。
// 必须与心跳分支（3673 处 galleryHoldAt 放行）保持一致，此处也认可 galleryHoldAt，
// 否则定时器一到就落入 cancel()，导致「按 ←/→ 预览直接消失」。
if (galleryHoldAt || canTriggerNow(payload, lastMouse.x, lastMouse.y)) {
actions.show(payload);
break;
}
const img = payload;
const r = img.isConnected ? img.getBoundingClientRect() : null;
const stillOk = r && isImgVisibleNow(img) && !isImgClippedAway(img) &&
lastMouse.x >= r.left - 120 && lastMouse.x <= r.right + 120 &&
lastMouse.y >= r.top - 120 && lastMouse.y <= r.bottom + 120;
if (stillOk && !pendingGraceUsed) {
pendingGraceUsed = true;
pendingFails = 0;
if (pendingTimer) clearTimeout(pendingTimer);
pendingTimer = setTimeout(() => FSM.dispatch('TIMER_FIRE', img), Math.max(300, config.delay));
} else {
actions.cancel();
}
}
break;
}
case 'LOADED':
actions.activate(payload);
break;
case 'ERROR':
actions.onError(payload);
break;
case 'WHEEL': {
if (state === S.ACTIVE && instance && isEnabled) {
payload.preventDefault && payload.preventDefault();
payload.stopPropagation && payload.stopPropagation();
lastWheelEvent = payload;
if (!wheelTicking) {
wheelTicking = true;
requestAnimationFrame(() => {
wheelTicking = false;
if (!lastWheelEvent || state !== S.ACTIVE || !instance) return;
if (config.wheelZoom) actions.zoomByWheel(lastWheelEvent);
else actions.pan(lastWheelEvent);
});
}
return true;
}
return false;
}
// ★ 键盘动作入口（键位系统调用）。缩放与滚轮共用 applyZoom，行为完全一致。
case 'ZOOM_IN':
case 'ZOOM_OUT':
case 'ZOOM_RESET': {
if (state === S.ACTIVE && instance && isEnabled) {
if (event === 'ZOOM_IN') actions.zoomBy(1.08);
else if (event === 'ZOOM_OUT') actions.zoomBy(1 / 1.08);
else actions.resetZoom();
return true;
}
return false;
}
// 保存当前预览的图片（S 键）
case 'SAVE_IMAGE': {
if (state === S.ACTIVE && instance && isEnabled) { actions.saveImage(); return true; }
return false;
}
// 复制地址 / 复制图片 / 旋转 / 翻转
case 'COPY_LINK': {
if (state === S.ACTIVE && instance && isEnabled) { actions.copyLink(); return true; }
return false;
}
case 'COPY_IMAGE': {
if (state === S.ACTIVE && instance && isEnabled) { actions.copyImage(); return true; }
return false;
}
case 'ROTATE': {
if (state === S.ACTIVE && instance && isEnabled) { actions.rotateBy(); return true; }
return false;
}
case 'FLIP': {
if (state === S.ACTIVE && instance && isEnabled) { actions.flipHorizontal(); return true; }
return false;
}
// 图集翻页 / 全屏
case 'GALLERY_PREV': {
if ((state === S.ACTIVE || state === S.SHOWING) && instance && isEnabled) { actions.switchGallery(-1); return true; }
return false;
}
case 'GALLERY_NEXT': {
if ((state === S.ACTIVE || state === S.SHOWING) && instance && isEnabled) { actions.switchGallery(1); return true; }
return false;
}
case 'GALLERY_ZIP': {
if ((state === S.ACTIVE || state === S.SHOWING) && instance && isEnabled) { actions.downloadGalleryZip(); return true; }
return false;
}
case 'TOGGLE_FULLSCREEN': {
if ((state === S.ACTIVE || state === S.SHOWING) && instance && isEnabled) { actions.toggleFullscreen(); return true; }
return false;
}
case 'FULLSCREEN_LAYOUT': {
if (instance) { actions.applyFullscreenLayout(!!(payload && payload.on)); return true; }
return false;
}
// 主动关闭预览（Esc / 自定义键）
// 全屏状态下不拦截 Esc —— 交给浏览器先退出全屏，再按一次才关闭预览
case 'CLOSE': {
// 全屏下 Esc 只退出全屏、不关预览。
// 某些环境（无窗口装饰/自动化）不会自动响应 Esc 退全屏，需显式退出。
if (document.fullscreenElement || document.webkitFullscreenElement) {
try {
const exit = document.exitFullscreen || document.webkitExitFullscreen;
if (exit) exit.call(document);
} catch (e) { }
return true;
}
if (state === S.PENDING) { actions.cancel(); return true; }
if (state === S.SHOWING || state === S.ACTIVE) { actions.beginFade(); return true; }
return false;
}
case 'DISMISS': {
if (state === S.PENDING) actions.cancel();
else if (state === S.SHOWING || state === S.ACTIVE) actions.beginFade();
break;
}
case 'RESET': {
generation++;
if (currentAbort) { currentAbort.abort(); currentAbort = null; }
clearPending();
if (instance) {
const c = instance.container;
const zImg = c.querySelector('img');
if (zImg && zImg.__zoomBlobUrl) {
URL.revokeObjectURL(zImg.__zoomBlobUrl);
zImg.__zoomBlobUrl = null;
}
if (c.parentNode) c.parentNode.removeChild(c);
instance = null;
}
document.querySelectorAll('.image-zoom-container[data-iz-owner="fsm"]').forEach(c => {
const zImg = c.querySelector('img');
if (zImg && zImg.__zoomBlobUrl) {
URL.revokeObjectURL(zImg.__zoomBlobUrl);
zImg.__zoomBlobUrl = null;
}
c.remove();
});
state = S.IDLE;
wheelManager.sync();
break;
}
}
return false;
}
};
return FSM;
})();
const wheelManager = (function() {
let attached = false;
function handler(e) {
if (zoomFSM.dispatch('WHEEL', e)) return;
bilibiliVolumeModule.onWheel(e);
}
function sync() {
const need = zoomFSM.hasActiveZoom() || bilibiliVolumeModule.isFullscreenActive();
if (need && !attached) {
// 必须挂 window（不能挂 document）：部分站点在 window 级 capture 就 stopPropagation，挂 document 收不到滚轮。
window.addEventListener('wheel', handler, { capture: true, passive: false });
attached = true;
} else if (!need && attached) {
window.removeEventListener('wheel', handler, { capture: true });
attached = false;
}
}
document.addEventListener('fullscreenchange', sync);
document.addEventListener('webkitfullscreenchange', sync);
return { sync };
})();
// 键位系统：默认键表见 KEYMAP_DEFAULTS，可在配置里覆盖；新增动作 = ACTIONS 注册实现 + KEYMAP_DEFAULTS 给默认键。
// 接管原则：① 只在预览显示时接管；② 输入框/可编辑区不接管；③ 带 Ctrl/Cmd/Alt 的组合键不接管；
// ④ 只有动作确实消费了该键才 preventDefault。
const keymapModule = (function () {
// 动作注册表：返回 true 表示已消费该按键
const ACTIONS = {
close: function () {
// ★ 视频预览优先关闭：开着视频预览时 Esc 先收视频，再收图片预览
if (videoPreviewModule.hide()) return true;
return zoomFSM.dispatch('CLOSE');
},
zoomIn: function () { return zoomFSM.dispatch('ZOOM_IN'); },
zoomOut: function () { return zoomFSM.dispatch('ZOOM_OUT'); },
resetZoom: function () { return zoomFSM.dispatch('ZOOM_RESET'); },
saveImage: function () { return zoomFSM.dispatch('SAVE_IMAGE'); },
copyLink: function () { return zoomFSM.dispatch('COPY_LINK'); },
copyImage: function () { return zoomFSM.dispatch('COPY_IMAGE'); },
rotate: function () { return zoomFSM.dispatch('ROTATE'); },
flip: function () { return zoomFSM.dispatch('FLIP'); },
prevImage: function () { return zoomFSM.dispatch('GALLERY_PREV'); },
nextImage: function () { return zoomFSM.dispatch('GALLERY_NEXT'); },
galleryZip: function () { return zoomFSM.dispatch('GALLERY_ZIP'); },
fullscreen: function () { return zoomFSM.dispatch('TOGGLE_FULLSCREEN'); }
};
// 归一化：**字母保留大小写** —— 这样 Shift 组合（C 复制图片、R 翻转）
// 才能与小写（c 复制地址、r 旋转）区分开；其余键名（+ - _ Escape ArrowLeft…）原样。
function normalizeKey(k) {
return (typeof k === 'string') ? k : '';
}
function isTypingTarget(el) {
if (!el) return false;
const tag = (el.tagName || '').toLowerCase();
return tag === 'input' || tag === 'textarea' || tag === 'select' || el.isContentEditable === true;
}
// 按键 → 动作名
function resolveAction(key) {
if (!key) return null;
const table = (config && config.keymap) || KEYMAP_DEFAULTS;
const actions = Object.keys(ACTIONS);
for (let i = 0; i < actions.length; i++) {
const name = actions[i];
const list = (Array.isArray(table[name]) && table[name].length) ? table[name] : (KEYMAP_DEFAULTS[name] || []);
for (let j = 0; j < list.length; j++) {
if (normalizeKey(list[j]) === key) return name;
}
}
return null;
}
function handler(e) {
if (!isEnabled) return;
if (e.defaultPrevented) return;
if (e.ctrlKey || e.metaKey || e.altKey) return;
if (isTypingTarget(e.target) || isTypingTarget(document.activeElement)) return;
const imageActive = zoomFSM.hasActiveZoom();
const videoActive = videoPreviewModule.isActive();
if (!imageActive && !videoActive) return; // 预览（图片/视频）没显示就不掺和
const action = resolveAction(normalizeKey(e.key));
if (!imageActive && videoActive) {
// ★ 视频预览独占键盘：Esc 关闭；←/→ 控制播放进度（±5s）。
// 方向键按原生语义直取（不参与图片图集的 prev/next 键位映射），
// iframe（YouTube/B站 embed）无法控制进度时放行、不拦按键。
if (e.key === 'ArrowLeft') {
if (videoPreviewModule.seek(-5)) { e.preventDefault(); e.stopPropagation(); }
return;
}
if (e.key === 'ArrowRight') {
if (videoPreviewModule.seek(5)) { e.preventDefault(); e.stopPropagation(); }
return;
}
if (action === 'close') {
const closeFn = ACTIONS[action];
if (closeFn && closeFn() === true) { e.preventDefault(); e.stopPropagation(); }
}
return;
}
if (!action) return;
const fn = ACTIONS[action];
if (fn && fn() === true) {
e.preventDefault();
e.stopPropagation();
}
}
let attached = false;
function init() {
if (attached) return;
window.addEventListener('keydown', handler, { capture: true });
attached = true;
}
return { init: init, resolveAction: resolveAction };
})();
// 视频悬停预览：① 悬停页面内