31:I[521715,["/_next/static/chunks/44ai52rgqqds0.js","/_next/static/chunks/3wozj3p9vvy37.js","/_next/static/chunks/1vatemh5hic3u.js","/_next/static/chunks/0zdgmo8em-2pr.js","/_next/static/chunks/0wpkmza7ts0b-.js","/_next/static/chunks/1lpa6xctxdzlc.js","/_next/static/chunks/30qx4v8yu08u0.js","/_next/static/chunks/1hl2z-0dyvxvx.js","/_next/static/chunks/0dmt37fg2dzw1.js","/_next/static/chunks/2daogplj-6hr5.js","/_next/static/chunks/2m07j1pc6vhcg.js","/_next/static/chunks/2nho6xfpkimdh.js","/_next/static/chunks/1-9y922i2usd6.js","/_next/static/chunks/0_rr8933gemfs.js","/_next/static/chunks/0bokmc_-by_04.js","/_next/static/chunks/0d28bcd0xzm7_.js","/_next/static/chunks/3c53s5hs52ls0.js","/_next/static/chunks/2onag7enl99yw.js","/_next/static/chunks/1r3zgvapx3p_s.js","/_next/static/chunks/3kkf1em5spirv.js","/_next/static/chunks/39oof5r4gnv1l.js","/_next/static/chunks/30d9r72c20rt4.js","/_next/static/chunks/0uwzrk5-1up9i.js","/_next/static/chunks/294yi6gp4bwx2.js","/_next/static/chunks/3z6l58_k-2emg.js","/_next/static/chunks/377epn4rpz2b_.js","/_next/static/chunks/0czs2ys0g3s_l.js"],"default"] 32:T6a133,// ==UserScript== // @name Mutex草稿纸 // @namespace marvis.fenbi.enhance // @version 0.7 // @description // @match *://spa.fenbi.com/* // @match *://*.fenbi.com/* // @match *://fenbi.com/* // @run-at document-idle // @grant none // ==/UserScript== // // 功能清单 // ① 每道题 .title-left 内追加 .marvis-lbox，内含 A/B/C/D 四个字母按钮， // 点击即选中该题对应选项（label.click()）；盒子 z-index:260 高于草稿画板 130。 // ② 盒子内 D 之后追加「下一题」按钮，点击滚动到下一题并强制打开该题草稿； // 点击后目标题滚动到视口垂直居中位置（不再贴顶）； // 题目高于一屏时改为顶部留白对齐，保证题干头部可见； // 按钮样式与 ABCD 字母按钮保持一致（白底蓝字蓝边，hover/active 实心蓝白字）。 // ③ 每个 .draft-container 高度锁定为「题干+选项」区域高度（app-question-choice // 的 bottom 相对 .ti 顶部），top 固定 0，解析展开时 .ti 变高不拉伸画布； // 每次扫描幂等校准高度，退出重开草稿后自动恢复锁定高度。 // ④ 页面加载后自动批量打开所有题的草稿（点击 li.draft.tool）； // 自动打开每题只尝试一次，用户手动关闭后不会被重新打开。 // ⑤ 「笔刷设置」面板：笔色黑（默认）/蓝/红三色切换 + 粗细滑块（0.4×~4× 无级）； // 默认内联显示在页面顶部「设置」按钮左侧（锚点 app-setting，插到其前一个兄弟位置， // 与工具栏同一行）；锚点始终缺失时才兜底为左下角 fixed（答题卡 z-index 500 会遮挡， // 故 fixed 不作常驻位置），锚点出现后自动挪回工具栏。 // 通过 hook CanvasRenderingContext2D 的 strokeStyle / fillStyle / lineWidth / arc // 作用于 canvas#draft，改写时保留原有 alpha（预览 0.1 / 终稿 1）； // 只影响绘制调用，不写页面状态、不改动上面 ①~④ 的任何逻辑。 // ⑥ ABCD 按钮本身变色：点击后按判分结果显示绿/红（背题），做题模式无判分时显示深蓝。 // ⑦ 退出重进回填：页面重新渲染时按 DOM 既有状态给按钮补色—— // 已判分看 div.input-radio 的 correct/correctLost/wrong；未判分（做题选中）多信号识别： // input.checked 属性 / checked 内容属性 / aria-checked / div.input-radio 与 label 的 // selected 类。粉笔选中样式是 input:checked + .input-radio 兄弟选择器、本身不加 class， // 但重进恢复可能走 setAttribute / class / aria 等路径（property 赋值不产生 childList // 变化，childList-only 的 MutationObserver 完全看不到——做题模式不回填的根因）， // 因此补：setter hook + change 捕获 + MO 属性级监听（checked/class/aria，按题精准同步） // + 前 30s 持续定时补偿 + pageshow / visibilitychange / focus 生命周期兜底。 // ⑧ 资料分析「一拖五」支持（v2.3.0，基于 2026-10-23 实测结构）： // 组 = 一个 div.ti，内部 app-resizable 左右分栏：左 .left-section > app-materials // （材料，页面无草稿入口）；右 .questions-anchors（a.tab#nav0..4 受控 tab） // + .questions-container（5 个 app-ti.question-multiple 预渲染堆叠、容器滚动切换， // tab 点击只切 active 类、不滚动容器）。子题不是 .ti，旧版「一个 .ti = 一道题」 // 的假设在组上全面失效（盒只装第一个子题 / 按钮映射错题 / 下一题跳过组内子题 / // 组级原生草稿 absolute 覆盖全组、吃掉全部指针事件——「不可用」的直接原因）。 // 现按组作用域重构： // - 每个子题独立注入字母盒（含下一题）与草稿画布，tab 切换即就位； // - 「下一题」优先推进组内下一个 tab（并自行滚动 questions-container），组末才进下一题； // - 材料区配独立草稿画布（B2）：absolute 覆盖整个材料、可完全打开、五题共享， // 笔迹按归一化坐标存 localStorage、退出重进自动重放；带「演算/穿透」切换 // （穿透模式下可选中/复制材料文字）与两步确认的「清空」； // - 组级原生草稿直接隐藏（实测无副作用；粉笔重载会自动恢复打开，故每次扫描都压制）。 // ⑨ 性能护栏（v2.3.0）：110 题全开画布在低配/软件渲染环境 tile 内存超限卡死（实测复现）。 // 草稿与自制画布改为只在题目接近视口（上 0.6 / 下 1.6 屏）时才自动创建，滚动即按需补开； // 字母盒与回填（廉价）仍保持全量就绪。控制台 __MARVIS_FENBI_OPEN_ALL__() 可强制全开。 // ⑩ 材料智能适应（v2.4.0 引入缩放；v2.7.0 升级为三层自适应）： // 材料画布工具条「适应」按钮 = 一键让整块材料一屏完整显示、文字尽量大： // L1 缩放：CSS zoom 布局级缩放 + 宽度补偿，可读性下限 55%； // L2 宽度：缩放低于 GOOD(0.82) 时自动收窄材料栏（直接设左栏宽度，实测 Angular // 不重置）——图表 max-width:100% 随栏变矮、材料整体变矮，从而在 100%（或更高 // 缩放倍率）下完整显示；正文文字不缩只重排。分隔条本就可供用户手动拖，此处是 // 程序化代拖； // L3 兜底：最窄栏(420px) + 下限缩放，仍装不下则提示滚动查看剩余部分。 // 关键修复（旧版量错地方白点）：真实高度锁在内层 .material-body（固定高 + // overflow:auto，内容 901px 裁在 572px 盒里），宿主 scrollHeight 被内层裁成盒高 // → 算出缩放比 ≥1 直接不缩（用户反馈「点了没反应」的根因）。现在先解锁内层滚动盒 // 再量（取子树最大 scrollHeight）；锁态布局下还会连带把该组高度链展平让内容能流动， // 还原时若展平由适应触发（用户关了全局展平）则一并收回。 // 另一修复：zoom 继承会二次缩放子孙 px 长度（实测 computed 1751px 渲染成 1051px）， // 画布 CSS 高度改按视觉高/zoom 设置，缩放态下画布仍满覆盖材料。 // 缩放/栏宽偏好按组存 localStorage，切题重进自动恢复并重新断言。 // ⑪ 一拖五「解锁盒子」（v2.6.x，按用户澄清迭代）：痛点本源是盒子高度写死 70vh // （.resizable-container / .nz-resizable.left 内联 height:70vh），5 道子题只能盒内 // 滚动翻题。做法（v2.6.2 定稿）：**保持左右两栏**（材料在左向下延伸、题目在右向下 // 延伸，页面整体滚动），只解锁高度（relaxCol：height auto / max-height none， // 仅 absolute/fixed 层连带解锁宽度/偏移）；两栏宽度不动（左栏 615px、分隔条保留 // 可拖）；tab 栏隐藏；questions-container overflow visible；子题逐层解锁宽度 // （relaxEl，原始 style 存 data-marvis-relax 供还原）；expandScrollBoxes 解除组内 // 残留内滚盒子；expandAncestorBoxes（v2.6.3）把组外祖先滚动壳一并解除——SPA 的 // 滚动可能发生在任意祖先层，只展开组内仍会被外层壳兜住；body/html overflow // hidden 时显式放开。材料画布/子题画布照常，「下一题」组内推进 = 页面滚动。 // 默认开启；控制台 __MARVIS_FENBI_FLATTEN__() 切换（持久化），__MARVIS_FENBI_DIAG__() // 输出结构自检（含祖先壳链路）。 // ⑫ 脚本总开关（v2.6.6）：底部水印条样式的胶囊（「粉笔自动全开草稿 / 粉笔脚本君出品 / // 脚本开 · v版本」三段同字体同字号 15px，蓝／灰／绿三色），点按 = 整个脚本开/关 // （刷新生效；关闭态不注入任何功能，胶囊是唯一重新入口）。 // 画布默认模式按类型且不记忆（v2.7.6 起）——材料默认「当前可书写」（写写画画）， // 子题默认「当前可触摸」（题目区常需滚动/点选），每次打开/刷新都按此重置； // 「穿透」改名「当前可触摸」；两档按钮文案均为短词， // 用户切到「当前可书写」时顶部弹全句提示：材料=「材料区域草稿已打开，当前可书写， // 不可触摸。」，子题=「第N题的题目区域草稿已打开，当前可书写，不可触摸。」； // 切到「当前可触摸」同样弹（…已让位，当前可触摸，不可书写。）； // 胶囊字体 15px → 7.5px（用户要求减半，v2.6.7）；v2.6.8 曾对齐水印栏改回 15px // （状态+版本文字缩为 10px）；v2.7.3 用户反馈「占的地方太大」再次减半——主文字 // 7.5px、状态+版本 5px，padding 6px 12px→3px 6px、gap 10px→5px、圆角 10px→5px // 等比缩，占地约 350×34 → ~172×18；画布工具按钮字号保持 12px。 // ⑬ 材料工具条改顶部通栏 band + 左栏吸顶（v2.7.1，用户两个实测痛点）： // 痛点1「左边三个按钮把材料文字挡了」：材料工具条（当前可书写/适应/清空）从 // 悬浮右上角改为钉在材料顶部的通栏 band（白底+下边框），材料内容用 // .marvis-mat-host .material-body 的 padding-top 让位——按钮有独立一行，不再压字； // 痛点2「滚右侧小题时材料要一直完整贴在左边」：两栏延伸形态下左栏 // position:sticky（top=固定页头高+8），align-self:flex-start 中和 flex 拉伸 // （否则左栏被拉到右栏等高、sticky 无行程），max-height 收进视口、装不下时 // 栏内 overflow-y:auto 自滚；滚过组内最后一题（分栏容器底边过去）后自然释放 // 随页面滚走。配套修复：cvMeasure 量尺寸时不再无脑 removeProperty('align-self') // （会把吸顶样式抹掉），改为原样写回；expandScrollBoxes 跳过吸顶栏。 // ⑭ 修复「材料显示不全」（v2.7.2，用户实测：图片/文字都显示不全）： // 根因（真机 CDP 去因实验定位）：v2.7.1 为打断 flex 拉伸链给材料链五层写了 // flex:0 0 auto + align-self:flex-start——flex-basis:auto 让各层按内容 // max-content 宽度排布，材料文字 max-content 1664px 时整条链被撑到 1704px， // 而左栏只有 996px，overflow-x:hidden 把右半全部裁掉（文字横切、表格/图片横切）。 // 修复：链上各层显式 width:100%（宿主按当前 zoom 补偿 100/s%，且不用 !important， // cvZoomApply 的补偿值要能覆盖）+ min-width:0 + box-sizing:border-box——横向恒等 // 栏宽（拖分隔条/适应收窄时跟随重排），纵向拉伸链修复不受影响；另加 CSS 规则 // .materials-container img/table/svg{max-width:100%} 让超宽素材收缩适应 // （覆盖 Angular 动态渲染的新素材）；cvZoomApply 还原时 width 固定回 100% // （置空会退回 max-content 排布再次撑爆）。 // 同批修复（真机实测）：① cvMeasure 量尺寸时宿主宽度也不能置空（同样触发 // max-content：文字材料整块不换行塌成一行，1196px 被量成 ~250px → 误判「装得下」 // 不缩放），固定 100% 量可见排版下的真实高度；② 被栏宽钳制的媒体(图片/表格， // 渲染宽≈栏宽)缩放会被宽度补偿抵消（媒体随补偿放大回原尺寸）——这类材料优先走 // L2 收窄（往往 100% 装下），必须缩放时不做补偿，让缩放真正生效。 // 二批修复（v2.7.2 收尾，真机 CDP 定位）：③ L2 收窄档位去重写反（w<=lastW // continue）——档位比值递减，第一档之后全部被跳过，高图材料只量一档就收尾、 // 最优窄档永远摸不到；改为「没有变得更窄才跳」。④ 补偿三处复活路径封死： // stickLeftCol 每次重扫都按 zoom 重算补偿（不认媒体标记会把 '100%' 覆盖回 // 100/s%，图被横向裁出栏外 271px）；cvFitRestoreState 在适应成功后被 // cvToast 触发的全量重扫二次施加（此时 zoom 已生效，探测器坐标系不一致会假阴性） // ——加「已在目标状态不重复断言」门（含拖栏采纳新宽）+ 用户拖动分隔条后采纳 // 新栏宽不被还原；cvHasWidthBoundMedia 改 zoom 归一（测量前临时摘 zoom）， // 任何调用时机可跑，自愈路径随之闭合（刷新后图片才到达：先按文字口径补状态， // 图到位后自愈撤补偿、补标记，不再横向裁切）。 // ⑮ 左下角「答题卡」折叠把手全透明（v2.7.4，用户反馈小白卡挡题面文字）： // 白卡不是背景色而是 .answer-card-tag 内 SVG path 的 fill/stroke（另有一条 // ::after 白条），只能 CSS 褪；折叠/展开是 fixed 容器 transform 位移——不增删 // 节点不挂类（MutationObserver 无声），三态类名又完全相同，没有状态类可钩； // 且展开态下该 tag 就是答题卡面板头部，一概全透会穿帮。故按容器位置 // （rect.top ≥ 视口高 = 折叠态）打 .marvis-ac-clear 类只透折叠态： // scan() 内调用 + 400ms 轮询兜底。该把手是全页唯一答题卡入口，只褪色不隐藏。 // ⑯ 资料分析「适应」按钮默认就是适应而非百分之百（v2.7.5，用户要求）： // 原来每次扫描都从 localStorage 恢复上次的缩放/收窄，打开资料分析题（含切题 // 重渲染）按钮直接显「100%」、材料被自动缩放。cvFitRestoreState 改为不再恢复： // 打开即原始 100%，要缩放用户自己点；按钮文字只按 DOM 实际状态校正（点了适应 // 再被 cvToast 触发的全量重扫时文字不能错）；顺手清掉旧版遗留的持久化键。 // ⑰ 资料分析子题「整页草稿纸」（v2.7.7，用户要求：可书写区从题目框扩到整页， // 且明确只在资料分析生效，别的题型不许变）： // 子题画布锚在题目框里、书写区只有「单选题这一篇」。fpEligible 的画布 // （仅资料分析组内子题——普通题走粉笔原生草稿、材料画布本就通栏，都不动） // 切到「当前可书写」时展开 body 级透明全屏层，整页即这道题的草稿纸。 // 机制（真机 CDP 实验 4/4 验证，tools/cdp-research-fp.js）： // ① 层 fixed inset:0 + pointer-events:none——对 HitTesting 完全隐身， // 手指滚动/点击/选答案全部原生直达页面（实测轻点穿透到 // choice-radio-label、拖动 scrollY 0→235）； // ② window 捕获层监听 pointerdown：笔/鼠标落笔时 setPointerCapture 到层内 // canvas（捕获可打在 pointer-events:none 元素上，move/up 照达——实测 // pen/mouse 均全程出字）+ preventDefault/stopPropagation 抢在原生处理器前； // ③ 鼠标点到按钮(button/label/radio…)不捕获→原生点击；笔在按钮上轻点 // (短按小位移)转发一次 click 并丢掉该点——平板上用笔点答案不误画； // ④ 我们自己的悬浮控件(工具条/笔刷面板/胶囊/答题卡) closest 排除，保持可点。 // 工具条收进右上角常驻胶囊（题目工具条会随滚动离开视口，退出/清空要随时够得着）。 // 笔迹按题独立存储（复用 sub-，归一化到视口），刷新保留、模式照旧不记忆； // 旧版题目框坐标系的笔迹首次展开时按框位置重映射进视口坐标系，老笔迹不丢。 // ⑱ 修复「适应后材料右侧仍被裁」+ 画布模式不再记忆（v2.7.6，用户实测反馈）： // 问题A（裁剪根因，真机 CDP 定位）：v2.7.2 给缩放加的宽度补偿 100/s% 是错的—— // Blink 的 zoom 模型里百分比宽度在被缩放元素的自身坐标系解析：探针实测（父 600px） // width:100%+zoom:0.858 视觉宽恰 600px（本已铺满），width:116.55%+zoom:0.858 // 视觉宽 699px=600/0.858。补偿让宿主视觉宽=栏宽/s，右侧溢出 (1/s-1)×栏宽被 // .left-section 的 overflow-x:hidden 裁掉（真机：s=0.858 时视觉 1161px vs // 栏宽 996px，右 165px 被裁——即用户报「材料图片还是会被裁剪」）。修复： // cvZoomApply/stickLeftCol 缩放时宽度恒 100%，补偿与 CV_NOCOMP_ATTR 机制 // 整体删除（cvHasWidthBoundMedia 保留：媒体布局宽被钳在栏宽/zoom 上，视觉尺寸 // 恒由栏宽决定、zoom 缩不动它——「优先 L2 收窄」的策略结论不变）。 // 问题B（模式记忆）：画布模式原来从 localStorage 恢复（用户切过一次就记住）。 // 改为不读不依：材料画布恒默认「当前可书写」，题目画布恒默认「当前可触摸」， // 每次打开/刷新都按类型重置（笔迹存取不受影响）。 // ⑲ 整页草稿态锁定滚动 + 删材料区草稿 + 删红框提示 + 笔迹落盘坐标修正（v2.7.8）： // ① 整页草稿打开时，笔书写和手指滚动冲突（写写画画时页面被带着滚）。 // 定稿：可书写态 = 纯书写状态，页面不许滚。实现上**不用** html/body // overflow:hidden——文档滚动容器一消失 Chrome 会把 scrollY 钳回 0， // 用户正在看的那道题瞬间跳走（真机实测 42934→0）；而且粉笔自己的 JS // 还会把 html 行内 style 重写成「overflow-y:auto !important」盖回来。 // 改为 document 捕获层拦 touchmove + wheel（passive:false），页面停在原位、 // 手指拖不动、滚轮也不滚；笔的 pointer 流不受影响（书写照常），轻点也 // 不受影响。弹窗文案同步改为「当前整个页面都可书写，页面滚动已锁定」。 // ② 材料区的「可书写/可触摸」按钮 + 画布整个删除（整页草稿已覆盖材料书写， // 按钮无用）；「适应」是独立功能保留，材料工具条只剩「适应」一个按钮。 // ③ 草稿范围淡红框提示删除（用户觉得没用）：fpHintRect/fpHintViewport/ // fpHintSub/fpScanHints 及 CSS 全部移除。 // ④ 修 v2.7.7 的笔迹落盘 bug（真机 E2E 才发现）：fpFinish 把 [x,y] 数组当 // 对象读（p.x/p.y → NaN → JSON 存成 null），结果「当次会话看得见、刷新后 // 全丢」；这些 null 再被 fpMigrate 迁移会压成同一个常量点，整笔退化成一点。 // 修正为下标读取；存储版本升到 v=2 标记「已迁移到视口坐标」（原先迁移标记 // 只在内存，刷新即丢 → 每次重开又迁一次、笔迹越跑越偏）；加载时 // cvSanitize 清洗历史坏数据（丢 null 点、丢所有点重合的坏笔）。 // ⑳ 整页草稿两态化 + 工具条不再飞右上角（v2.7.9，用户 iPad 实测反馈）： // ① 工具条留在原地：用户「非得把当前可触摸这个按钮移动再点击变成当前可书写后， // 就要飞到右上角吗？我觉得停留在原地就挺好的」——右上角常驻胶囊(pill)整体 // 删除，toggle/清空永远留在题目工具条原位。书写态滚动已锁、按钮必在视口内， // 不需要再靠胶囊兜「够得着」。 // ② 可触摸 = 锁定态而非退出：会话仍然开着（笔迹照旧显示），但页面只放行 // 这道题的 ABCD + 下一题 + 清空 + 本切换按钮，其余点击一律吃掉 // （用户：「别的按钮应该都覆盖掉」）。实现用 document 捕获层 click 过滤 // （放行我们自己注入的 .marvis-lbox/.marvis-lbtn/.marvis-next 与工具条）， // 不遮罩、不改布局、不影响滚动；只拦可信(isTrusted)的真实点击，页面 // 自己的程序化点击照常。 // ③ 可书写态手指点按无效并提示「当前不可触摸」（用户要求）：pointerdown + // touchstart 双保险拦掉手指（preventDefault touchstart 才能确保不合成 // click），只有工具条（切换/清空）放行——否则退不出去。 // ④ 退出会话：长按切换按钮 650ms，或点「下一题」（换题即退出）。退出后 // 页面完全恢复普通态，笔迹已落盘，回来点「当前可触摸」可再开。 // ㉑草稿竖条：切换/清空/退出收进「原生草稿工具条」形态（v2.8.0，用户 iPad 反馈）： // 用户原话「把『当前可触摸』和『当前可书写』集成到原生那个草稿按钮吧，然后清空 // 也集成到原生的这个草稿按钮中；当前可书写时弹出『当前不可触摸』这个弹窗没用， // 取消掉」。实测（tools/cdp-probe-native-draft*.js）：资料分析组的原生草稿是 // **整组一条**（.ti > .draft-container > app-draft > canvas#draft + .tools-container， // 撤销/反撤/橡皮/清空/退出），且被本脚本整体隐藏（组级画布会吃掉全组指针事件）； // 每道子题自己的「草稿」入口是 .title-right > li.draft.tool（笔图标）。 // 所以： // ① 子题宿主不再挂任何悬浮小白按钮（toggle/清空全删），改为一条与原生同款 // （#3c464f 深色、竖排、贴屏幕右边缘、12px 圆角、20px 描边图标 + 11px 白字） // 的「草稿竖条」#marvis-fp-dock，只放这套草稿真正用得上的三项： // 当前可书写 / 当前可触摸（切换）· 清空（两步确认）· 退出 // 竖条 position:fixed 右侧居中——原生那条是绝对定位钉在题目顶部的，长题滚下去 // 就够不着了，钉屏幕才能随时按。 // ② 入口 = 原生草稿笔图标（li.draft.tool，每道子题一个）：点它打开这道题的整页 // 草稿（document 捕获层拦掉粉笔自己的组级草稿逻辑），再点一次即退出；会话所属 // 那道题的图标高亮（.marvis-fp-pen-on）。普通题的笔图标完全不动（照旧开原生草稿）。 // ③ 可书写态手指点按从「拦截 + 弹提示」改为**静默拦截**（用户：弹窗没用，取消掉）。 // ④ 锁定态白名单扩到：ABCD / 下一题 / 竖条 / 本题草稿图标；别处点击照旧吃掉并 // 提示「当前只可点 ABCD / 下一题 / 右侧草稿按钮」。 // ⑤ 出口变明确：竖条「退出」按钮（替代 v2.7.9 的长按 650ms）、再点草稿图标、 // 或点「下一题」，三条路都退出会话并立即落盘。 // ㉒ v2.8.1 修 v2.8.0 的越界（用户：这功能只能在一拖五用，别把别的题也改了）： // `app-ti.question-multiple` 是**全站题目**的组件名——普通单题也是它（真机实测 // 第 1~8 题全是），v2.8.0 用 `closest('app-ti.question-multiple')` 当子题判据， // 结果普通题一按草稿笔图标也被拽进整页草稿 + 冒出一条右侧竖条。 // 现在唯一判据是 fpGroupOfSub()：所在的 .ti 必须含 .materials-container / // .questions-anchors（与 processTi 建画布口径完全一致），并且 // fpPenEntry / fpToggleSession / ensureSubCanvas 三处都上这道闸； // scan() 还会自愈清掉 v2.8.0 误建在普通题上的 fpEligible 画布（cvPurgeStrayFp）。 // ㉓ v2.8.2 右下角胶囊改成**可展开的设置面板**（用户：「帮我做一个可以展开的……再给我 // 加一个选项，就是我可以停掉资料分析这种 1 拖 5 类似的板块的功能」「再搞一个全部 // 关闭」）：点胶囊 = 展开/收起（不再点一下就刷新），面板两行开关： // ① 资料分析 · 1拖5 → localStorage `marvis-fb-group`，关掉 = 该板块完全不介入 // （processTi 组分支直接 return：不隐藏原生组草稿、不展平、不加字母盒、 // 不建材料画布；fpGroupOfSub 同时返回 null，整页草稿/竖条/笔图标一律不受理）； // ② 全部题目 → `marvis-fb-enabled`（原总开关 =「全部关闭」）。 // 两个开关都走刷新生效（半途拆装会留下内联样式/属性残渣）；胶囊状态串会显示 // 「脚本开 · 分析关 · v2.8.2」，一眼能看出当前是部分关闭。 // ㉔性能优化（v2.9.29）：行为不变，砍掉六处常驻浪费（低配平板/长卷 110 题实测痛点）： // ① 分栏看门狗（700ms）不再每轮「全量量尺寸+全量重绘」。旧版每轮做： // 两侧 appSizeSide（画布高度压 0 → appContentBottom 最深 80 层 DOM walk， // 每层一次 getBoundingClientRect → 每轮 4 次强制回流） // + appRedraw（3 张画布清空重画全部笔画，几百笔时单轮 10ms+，空转也烧）。 // 改为事件驱动自愈：内容 childList/characterData 变化（Angular 增删改节点）、 // 图片 load（尺寸晚于 DOM 到位）、撤销/重做/清空、转窗 → 脏标记 → // rAF 一帧内补量重绘（比旧轮询更快）；看门狗只留廉价检查（连线/顶栏/行内样式/ // 列宽漂移/孤儿笔/画布重挂），另每 8 轮（约 5.6s）兜底全量一次， // 盖住无信号的布局变化。空转 tick 的 CPU 占用接近归零。 // ② 选项列数指纹按「代际」跳过：旧版看门狗每轮查列数缓存前都要把全部选项 // textContent 串一遍（110 题 × 4 选项的 DOM 序列化，纯浪费）。现在同代际 // （无内容变化）且栏宽没变的 ul 直接跳过；任何内容变化（含 Angular 就地改 // 文本节点）由 ① 的内容监听换代，落回指纹路径重算。 // ③ 全量 scan() 不再对每个 .ti 逐个 getBoundingClientRect（110+ 次/轮，MO 突发 // ≥300ms 一轮）：IO 环境下远近直接查 nearSet（进出场时已判定）， // IO 进场回调与滚动补扫都显式带 near:true 免去重复量测； // 无 IO 的旧环境退化回 nearViewport 就地量，行为不变。 // ④ 滚动补扫（scanNear）不再每帧 querySelectorAll('.ti') 全表 + 逐题成员判定： // IO 进出场维护 nearArr（WeakSet 不可枚举的可迭代副本），滚动只处理数组内的 // 几道题；补扫同时跳过回填同步——回填在 IO 进场那次 processTi 已做， // 滚动不改变作答状态（变化自有 MO 属性监听 / setter hook / change 捕获兜底）。 // ⑤ 答题卡折叠把手（⑮）由 400ms 常驻轮询改为 IntersectionObserver 位移驱动： // 折叠/展开是 transform 位移，gBCR 与 IO 口径一致（都含 transform）， // 位移即触发回调（比轮询更跟手）；有 IO 时轮询降为 2s 低频兜底， // 无 IO 的旧环境维持 400ms 原频。回调内仍按 gBCR 判定（含 -2px 容差），口径不变。 // ⑥ 启动回填补偿提前收摊：旧版前 30s 每秒全量 syncAllFeedback（110 题逐题 // 多次 querySelector，启动期 ~1600 次/秒，恰逢 Angular 渲染高峰）。 // 现在连续 5 轮（约 5s）没有任何实际写入即停——恢复动作一旦落地（任一题 // class 变化）立即清零计数继续跑满 30s；setter hook / change 捕获 / // MO 属性监听 / pageshow / focus 兜底仍在，晚到不漏。syncFeedback 返回 // 是否真的写过 DOM，作为收摊判据。 // ⑦ 指针旁观器的诊断采集瘦身——后续在 v2.9.30（㉕）随诊断子系统整体删除， // 只留 downIds/penSeen 两项书写功能依赖的最小记账。 // ㉕移除「笔迹自检」（v2.9.30，用户要求：右下角胶囊去掉该行、功能彻底删除）： // 诊断子系统整体下线 —— penStat 事实采集（指针流计数 / 生命周期台账 / 原始 // 时间线 / 合并采样密度 / 丢弃计数）、原生画布像素指纹（「双画者」检测）、 // 诊断浮层 penDiagOverlay、控制台 API __MARVIS_FENBI_PEN__() / // __MARVIS_FENBI_PEN_OVERLAY__()、胶囊「笔迹自检」行全部删除。 // 保留两项书写功能依赖的最小记账（零分配）： // · penDownIds —— pointerdown 登记，落笔归属判定（fpStrokeOwns）分辨 // 「真·第二指针」与「浏览器中途换 id」仍需要； // · penSeen —— 见过 pointerType=pen 即置位，fpOnDown 的 touch-as-pen // 自适应（会报 pen 的设备上 touch 一律当手指挡掉）仍需要。 // 胶囊结构版本 r9 → r10（旧面板含该行，强制重建）；书写/存储/开关行为零改动。 // ㉖整页草稿「手缩放 + 笔写字」+ 提示残留修复（v2.9.31，小米平板 + 焦点触控笔 Pro 实测反馈）： // ① 可书写态双指缩放放行。旧版可书写态把手指的路全堵死（touchstart/pointerdown(touch)/ // touchmove 三层全拦），双指捏合缩放也起不来；而胶囊/竖条连点两下反而触发 // WebView 的双击放大——页面被放大后没有任何路能缩回去（「回不去了」的由来）。 // 现在：双指 = 浏览器页面缩放（touchstart 不再 preventDefault、touchmove ≥2 触点 // 放行、html[data-marvis-fp-draw] body{touch-action:manipulation}）；单指 = 仍然 // 锁定（单指 touchmove preventDefault，页面不滚）；笔 = pointer 路径照常书写 // （小米焦点触控笔 Pro 在 Chromium 上报 pointerType='pen'，已是既适配路径）； // 手指点按仍然无效（touchend preventDefault 杜绝合成 click）。PC 端 Ctrl+滚轮 // 缩放同步放行。touchAsPen 设备（不报 pen 的壳浏览器）不受影响：手指本来就是笔。 // ② 双击放大根治：胶囊与草稿竖条加 touch-action:manipulation（连点不再放大页面）。 // ③ 草稿提示文字残留修复（点草稿图标→退出后，提示文字固定在原地不走）： // cvToast 此前只把 opacity 归零、元素常驻 DOM，个别内核上过渡失效就成了常驻 // 文字 → 现在淡出后整个摘掉节点（450ms 内来了新 toast 则复用不摘）； // 草稿竖条退出改为行内 display:none 兜底（不再依赖样式表完好才隐藏）。 // 适配代价：touchstart 的 preventDefault 撤掉后，「不选中文字 / 不弹长按菜单 / // 不双击放大」改由 html[data-marvis-fp-draw] 的 CSS + touchend 拦截兜住。 // ㉗焦点触控笔 Pro 手势适配：橡皮（v2.9.32~v2.9.33，用户要求「先试试看」并勘误）： // 这支笔没有实体按键，只有五种智能手势（轻捏/双击笔身/上下滑动/悬停/旋转）。 // 手势本身由 HyperOS/小米创作 App 消费（调色盘/切工具/翻页/截屏等），网页收不到； // 唯一下沉到网页的是「双击笔身 → 切橡皮」：切换后笔尖接触以工具橡皮位到达 // （pointerdown button=5 / buttons 含 32；v2.9.27 的实测里 button=2 的来源 // 同理是手势下沉的按键位，不是实体侧键——v2.9.33 勘误）。 // 落地： // ① penEraser(e) 只认 buttons 含 32；penWritable 对「按键位 pointerdown // （笔尖未接触）」维持旧判「不是落笔」，对橡皮意图放行——旧版把橡皮态 // 接触也拦掉（v2.9.27 的「不落墨」一刀切），所以此前橡皮态完全无反应。 // ② 自制画布（整页草稿层/材料/子题/分栏左右与草稿纸）支持橡皮笔程： // destination-out 圆点+圆头粗线逐点增量擦（penEraseDot/Seg/Path/Advance， // 与 penAdvance 同一 done 契约）；落账 {e:1, pts 归一化, r}， // penReplay/cvSanitize/fpMigrate 同步适配；分栏走 acts 管线（t:'erase'）， // 撤销/重做天然可用（撤掉橡皮=墨迹恢复）；橡皮半径 12px×笔刷滑块。 // ③ 续写判定区分笔画/橡皮（不把笔画续成橡皮）；悬停 move（buttons=0 或 // 手势按键位=2）不再进补密路径——旧版会把悬停 move 也送去补密、白耗。 // 粉笔原生草稿（canvas#draft）的橡皮行为由粉笔自己决定：它若不支持笔橡皮， // 用户仍可用它工具栏自带的橡皮；我们的笔刷 hook 对其行为零改动。 // ㉘扫描基础设施再提速（v2.9.34）：行为不变，砍每轮扫描的常数开销—— // ① localStorage 内存缓存：getItem 是同步 I/O，每轮扫描/看门狗/转窗都要读 // masterEnabled/appModeOn/fitMatOn/fitRightOn 等开关（还要 JSON.parse）； // 写穿透 + storage 事件失效后，这些路径上的 localStorage 读全部归零。 // ② isGroupTi 按结构代际记忆化：110 题里组是极少数，旧版每轮扫描对每个 .ti // 做 2 次全子树 querySelector（processTi + syncFeedback 各一次）≈ 200+ 次 // 空查/轮；同代际内每题只查一次，childList 换代重查。 // ③ 滚动补扫加 DOM 代际闸：滚动本身不产生 mutation，近视口集在两次 mutation // 之间不会变（进出视口由 IO 事件即时处理）→ 纯滚动时整段 scanNear 跳过 // （旧版每滚动帧仍要对每道近视口题 buildBox+lockDraft，约 90 次 querySelector // + 30 次 gBCR/帧）。窗口 load 捕获（图片晚到改布局）推代际；另有 2s 兜底， // 任何无信号的布局变化最迟 2s 被补上。 // ④ MO 补观察 characterData：Angular 就地改绑定文本（改文本节点 data，没有 // childList/属性记录）也计入代际并按题精准同步，文本重排后 lockDraft 高度 // 不再陈旧；文本节点目标上溯父元素分类，不会触发全量 scan。 // ⑤ app-setting / answer-card-container 锚点元素缓存：再省每轮 2 次全文档 // querySelector（元素断连自动重查）。 // ㉙收尾三处小修（v2.9.35，无行为变化）： // ① MO 自有 UI 白名单补全——草稿竖条/提示条/笔刷面板/分栏顶栏/草稿纸/滑块都挂 // 在 body 上，不在白名单时每次挂载或改文字会被当成「.ti 外的结构变化」 // 触发一次无谓全量 scan；现在统一认 MO_OWN_SEL。 // ② buildBox 快路径：字母盒缓存在 .ti 上（__mvBoxEl），同题同版本且盒子还挂在 // .title-left 上时，3 次子树查询降为 1 次；被页面摘走/搬走/换题自动失效。 // ③ quizPage 500ms 缓存：非做题页上每轮 scan 的「是不是做题页」确认（最多 3 次 // 全文档查询）不再重复；SPA 切页最迟 500ms 被下一轮 scan 纠正。 // ㉚题目字号可调（v2.9.36，用户反馈「有的题目实在太小」）： // 右下角胶囊面板新增「题目字号」行：A－ / 当前% / A＋，90%~160%、步进 10%， // 即点即生效、localStorage 记忆（marvis-fb-fontzoom）、重开页面保持。 // 实现：CSS zoom 作用在 app-question-choice（普通题与资料分析子题的题干+选项 // 容器）——不猜粉笔内部文字类名，文字/图片一起放大、排版不破。 // 「字体变大后草稿纸没有相应变大」的解法：草稿纸尺寸全靠实时测量——字号变化 // 时推一次 DOM 代际 + scan() 全量重断言（原生草稿 lockDraft 按新排版重新锁定） // + 分栏 appMarkDirty（appSizeSide/appRedraw/选项列数全部重算），草稿纸自动 // 跟着变大变小。材料区不适用此档（那里有「适应」的一整套缩放补偿，两层 zoom // 会打架）；面板结构版本 r10 → r11（旧面板强制重建出字号行）。 // ㉛胶囊放大 + 普通题草稿纸跟随字号（v2.9.37，用户反馈）： // ① 右下角胶囊整体放大一档：主字号 10.5→14px、内边距 3×6→5×10、面板 12→14px // （行距/开关徽标/字号按钮同步放大，面板宽 158→210px），待机透明度 .3→.5 // （不然放大了也看不清）；结构版本 r11→r12，旧胶囊强制重建。 // ② 非资料分析选择题的草稿纸跟随字号：粉笔原生草稿的绘图缓冲区只在「开草稿 // 那一刻」按容器尺寸建，字号放大后容器变高、缓冲区还是旧的——粉笔按 1:1 // 像素落笔（不缩放），新扩出来的区域写不上字。fontZoomReopenDrafts 对 // 「已开草稿且缓冲尺寸对不上新容器」的题做一次「关-开」：粉笔按新尺寸重建 // buffer 并重放 strokeStack，笔迹不丢；没开草稿的题不碰，连点 A± 每题只排 // 一次，重开链路最迟 ~1.2s 走完后再收一次 scan 把新容器锁定。 // ㉜分栏顶栏「题目字号」下拉菜单（v2.9.38，用户要求：点开资料分析草稿后就能调字号）： // 顶栏（笔刷粗细 A−/A+ 右侧）新增「字号 N%」按钮，点开竖排档位列表 // （90%~160% 步进 10%，当前档蓝色高亮打 ✓），点选即生效并收起；触屏友好 // （行高 10px 内边距）。档位与胶囊面板共用同一套 fontZoomSet —— 在哪里调 // 都是同一份记忆，草稿纸跟随/分栏重排/顶栏标签同步全部自动发生；点菜单外 // 任意处收起；退出分栏菜单跟着顶栏一起退场。MO_OWN_SEL 补菜单节点 // （挂载/更新不再触发无谓全量扫描）。 // ㉝字号菜单交互重做（v2.9.39，用户反馈竖排档位列表「不好选择」）： // 菜单改为横排大按钮 [A－] [120%] [A＋]，与右下角胶囊同一套操作—— // 连点 A± 逐步调（菜单保持打开方便连续点）、点中间百分比重置 100%、 // 点菜单外才收起；按钮 16px 字号 + 40px 高触屏友好。 // ㉞字号上限 220% + 分栏右栏适应让位字号（v2.9.41，用户反馈「字号 160% 也不够大」）： // ① FONTZOOM_MAX 1.6 → 2.2，胶囊面板/顶栏菜单同一套档位自动扩展； // ② 根因：分栏右栏「选项一屏」按放大后的内容高重算缩小比（scale = 视口高/内容高）， // 字号放大多少缩小比就降多少，两相抵消——五道子题顺排内容远超一屏， // 160% 档实际字高仍只有原生六成上下，字号在右栏形同虚设。 // 现在：字号 >100% 时右栏不再自动缩小凑一屏，按所选字号排版、超出走两侧 // 滑块滚动；字号回到 ≤100% 才恢复一屏适应。左栏「材料一屏」有自己的 // 55% 可读性下限补偿体系，不在此列。 // 适配：MutationObserver（childList + 属性级 checked/class/aria）+ rAF 节流与按题精准同步， // 覆盖 SPA 增量渲染与属性级作答恢复； // 注入以「题号 + 版本戳」为 key 去重，元素复用渲染新题、脚本升级时自动重建。 // (function () { 'use strict'; // ---------- 脚本总开关 + 分栏草稿开关 ---------- // 右下角胶囊 = 设置入口（v2.8.2 起不再「点一下就刷新」）：点它展开/收起面板。 // 面板现在只有两行可见开关： // ① 全部题目：关掉 = 整套脚本不注入（原来的总开关，也就是「全部关闭」）； // ② 分栏草稿 APP式：关掉 = 不进左右分栏，回到粉笔原生草稿。 // v2.9.16：「资料分析 · 1拖5」那一行已隐藏（用户：这个开关已经没用了）—— // 行还留在 DOM 里（display:none）以便老结构对齐，但点了不做任何事， // groupEnabled() 恒返回 true，存量 `marvis-fb-group=0` 会被清掉。 var MASTER_LS = 'marvis-fb-enabled'; var GROUP_LS = 'marvis-fb-group'; // v2.8.2：资料分析（1拖5）板块开关（v2.9.16 起恒开） var SCRIPT_VER = '0.7'; /* ---------- localStorage 封装（v2.9.26） ---------- 统一 try/catch（隐私模式 / 禁用存储时 getItem 会抛），语义保持不变：读失败返回 null（调用方沿用「!== '0' 即开」的默认值约定），写失败返回 false。 */ /* v2.9.34：localStorage 内存缓存 —— getItem 是同步 I/O，扫描/看门狗/转窗每轮都要读 masterEnabled/appModeOn/fitMatOn/fitRightOn 等开关，全走缓存后这些路径上的 localStorage 读与 JSON.parse 归零；写穿透缓存，storage 事件兜住他页改动。 */ var lsCache = {}; try { window.addEventListener('storage', function (e) { if (e && e.key) delete lsCache[e.key]; else lsCache = {}; }); } catch (e0) {} function lsGet(k) { if (k in lsCache) return lsCache[k]; var v = null; try { v = localStorage.getItem(k); } catch (e) { v = null; } lsCache[k] = v; return v; } /* v2.9.39：lsSet 必须如实返回成功与否 —— 旧版恒 return true，于是 cvSave 里「!lsSet(...) → cvEvictLRU 腾地方再重试」那条配额兜底永远进不去（死代码），注释里写的「真爆配额由 lsSet 失败路径被动淘汰兜底」根本不存在。后果：CV_MAX_BYTES=200000 × 110 题远超 5MB 配额，写到爆之后每道题的笔迹都在静默失败，而且缓存还被写成「已存」，cvLoad 读到一份没落盘的数据 —— 长卷写久了刷新就没了，就是这个。 */ function lsSet(k, v) { var ok = true; try { localStorage.setItem(k, v); } catch (e) { ok = false; } if (ok) lsCache[k] = v == null ? null : v; else delete lsCache[k]; // 写失败就别污染缓存，下次读回真实值 return ok; } function lsRemove(k) { try { localStorage.removeItem(k); } catch (e) {} lsCache[k] = null; } function lsJSON(k) { var raw = lsGet(k); if (raw == null) return null; try { return JSON.parse(raw); } catch (e) { return null; } } /* ---------- 命名常量（v2.9.26：原魔法数字） ---------- */ var DRAFT_BOTTOM_PAD = 48; // 草稿锁定高 = 题干+选项底边 + 48px 工具按钮留白 var NEAR_MARGIN_BELOW = 0.6; // 视口门控：视口上方 0.6×vh 内的题算「接近」 var NEAR_MARGIN_ABOVE = 1.6; // 视口门控：视口下方 1.6×vh 内的题算「接近」 var APP_BOTTOM_PAD = 80; // 分栏画布底部留白（最后一行下面照样能写） var APP_ORPHAN_MS = 1500; // 孤儿笔（pointer cancel 后没交回来）多久当已抬笔 var MO_FULLSCAN_GAP = 300; // 全量 scan 最小间隔：连发 mutation 只补一次 /* ---------- v2.9.27 运行环境探测（Via / 小米平板 / 触控笔） ---------- 为什么必须探测，而不是写死 UA： · Via 是 Android WebView 壳：没有控制台、没有 GM_* API、注入时机偏晚，且它把页面按手机视口渲染 —— 窄屏下分栏/材料一屏/选项一屏会按实际栏宽算出挤成一团的排版（列数算法本身没错，是给 PC 视口设计的）； · 小米平板（HyperOS）+ 焦点触控笔 Pro：系统按 TOOL_TYPE_STYLUS 上报， Chromium 映射成 pointerType='pen'，和 iPad 一致；笔无实体按键，但智能手势（双击笔身切工具等）会以「按键位」形态下沉到网页——见 button=5（橡皮）/ 2（次要键）的 pointerdown，那不是落笔；另外 Android 上笔悬停会产生 pressure=0、buttons=0 的 pointermove； · 手机/平板分屏会让视口变窄，转屏会变宽 —— 所以全部做成函数，每次用时现算（启动时算一次会被转屏打脸）。 */ var PAD_NARROW_W = 600; // 窄视口阈值：小于它 = 手机 / Via / 平板分屏 function padViewportW() { try { return window.innerWidth || 0; } catch (e) { return 0; } } /* 窄视口。宽 0 = 还没量到（早期注入）→ 不判窄，交给后续 scan 再定。 v2.9.30：环境探测只留窄视口判定（padEnvInfo/padTouch/padAndroid/padIsVia 原本只服务已删除的「笔迹自检」诊断，一并移除）。 */ function padNarrow() { var w = padViewportW(); return w > 0 && w < PAD_NARROW_W; } /* 当前页面是不是做题页。@match 已放宽到整个 fenbi.com（Via 里的跳转链更绕），所以胶囊/笔刷面板/扫描都必须先确认页面上真有题目，否则会在官网首页、课程页挂一堆没用的 UI。 */ /* v2.9.35：500ms 负缓存——非做题页（官网/课程页）上每次 scan 都要做最多 3 次全文档查询确认「是不是做题页」；做题页首次判定后走正缓存，SPA 切页最迟 500ms 后被下一轮 scan 纠正（本来就有 300ms 全扫节流，感知不到）。 */ var quizPageCache = null, quizPageAt = 0; function quizPage() { try { var now = Date.now(); if (quizPageCache !== null && now - quizPageAt < 500) return quizPageCache; var v = !!(document.querySelector('.ti') || document.querySelector('app-question-choice') || document.querySelector('.draft-container')); quizPageCache = v; quizPageAt = now; return v; } catch (e) { return false; } } /* v2.9.27：这一支指针算不算「落笔」—— 专门治 Android 触控笔的两个新坑。 ① 按键位 pointerdown：焦点触控笔 Pro 没有实体按键，但智能手势（双击笔身切工具等）经 HyperOS 会以笔「按键位」形态下沉到网页——实测见 button=5（橡皮）或 2（次要键）的 pointerdown，那不是落笔。脚本 v2.9.32 前没有橡皮实现，一旦照单全收就会凭空多一条线。pointerdown 的 button 语义是「触发这次事件的键」：0=笔尖，>0=其它键；pointermove 恒为 -1，所以这条判定只对 down 生效，不会误伤笔程（v2.9.32 起：button=5 的橡皮意图放行，见 penEraser）。 ② 悬停：笔尖离屏 1cm 内 Chromium 会持续派发 pointermove（buttons=0、pressure=0）。这些 move 由「没有 fpDown 就不收」天然挡住，这里不再重复判断 —— 反过来按 pressure 判会误杀「轻压落笔」（pressure 可能正好 0）。鼠标保持原样：右键/中键在调用点各有自己的判定。 */ function penWritable(e) { if (!e || e.pointerType !== 'pen') return true; if (e.type === 'pointerdown' && typeof e.button === 'number' && e.button > 0) { /* v2.9.32：橡皮意图放行（见 penEraser）——双击笔身切到橡皮后的笔尖接触不再被当成「误触按键」拦掉；其余按键位 pointerdown（笔尖没接触）依旧视为不是落笔。 */ return penEraser(e); } return true; } /* v2.9.33：这一支笔当前是不是「橡皮」——焦点触控笔 Pro 的手势适配落点。这支笔没有实体按键，只有智能手势（轻捏/双击笔身/上下滑动/悬停/旋转），手势本身由 HyperOS/小米创作 App 消费，网页收不到；唯一下沉到网页的是「双击笔身 → 切橡皮」：切换后笔尖接触以工具橡皮位到达——pointerdown button=5 / buttons 含 32。只认 32 一条：不做「bit2+笔尖=橡皮」的引申（笔无实体侧键，bit2 来源未知，引申反而可能把未知手势误判成擦除）。手指/鼠标永远不算。 */ function penEraser(e) { if (!e || e.pointerType !== 'pen') return false; var b = 0; try { b = e.buttons | 0; } catch (e2) { return false; } return !!(b & 32); } /* ---------- v2.8.12 跨世界实例守卫 ---------- 问题的来源：Via 这类「自带脚本注入器」的浏览器（iOS 版 = WKWebView 壳），注入语义和 Tampermonkey 不同： · 可能把用户脚本注入到**独立的 content world**（JS 全局不与页面共享，但 DOM 共享）→ 我们在 window 上装的捕获监听与页面里的粉笔原生草稿 **互不可见**，stopPropagation 也拦不住对方 → 同一次书写被两个画者各画一遍 → 屏幕上就是「两条交错的线」； · 也可能在同一次页面加载里**重复注入**两次 → 两个实例各建一层画布、各抢各的 fpPen → 笔画被拆到不同画布上。修法：守卫标记写在 **DOM 属性**上（DOM 跨 content world 共享，JS 全局不共享），同版本重复注入直接退出，保证「页面上永远只有一个实例、一个画者」。 */ var INST_ATTR = 'data-marvis-fb-inst'; try { var _instRoot = document.documentElement; if (_instRoot) { if (_instRoot.getAttribute(INST_ATTR) === SCRIPT_VER) { return; // 同版本已有实例在跑 → 本次注入直接退出 } _instRoot.setAttribute(INST_ATTR, SCRIPT_VER); } } catch (e) {} function masterEnabled() { return lsGet(MASTER_LS) !== '0'; } /* v2.9.16：胶囊面板里的「资料分析 · 1拖5」开关已隐藏（用户：这个开关已经没用了）。板块因此恒为开启。存量里存过 '0' 的一并清掉 —— 面板里已经没有这个开关了，再让那个 0 生效就是「明明什么都没关、资料分析却什么增强都没有」的隐形故障。真要退回去用粉笔原生：关「全部题目」（MASTER_LS）或关「分栏草稿 APP式」。 */ function groupEnabled() { if (lsGet(GROUP_LS) === '0') lsRemove(GROUP_LS); return true; } function chipReload() { try { location.reload(); } catch (e) {} } // 面板里一行开关的样式/文案同步（浅绿=开，灰=关，整行无效时压暗） function chipSetRow(row, on, effective) { if (!row) return; var sw = row.querySelector('.mv-sw'); if (sw) { sw.textContent = on ? '开' : '关'; sw.style.background = on ? '#E8F5E9' : '#F1F3F5'; sw.style.color = on ? '#3B6D11' : '#8A9099'; } row.style.opacity = effective ? '1' : '.45'; row.style.pointerEvents = effective ? 'auto' : 'none'; } function chipSync(el) { var on = masterEnabled(); var t3 = el.querySelector('.mv-t3'); if (t3) { /* v2.9.16：不再有「分析关」这个状态（板块开关已隐藏、板块恒开） */ var txt = (on ? '脚本开' : '脚本关') + ' · v' + SCRIPT_VER; if (t3.textContent !== txt) t3.textContent = txt; t3.style.color = on ? '#3B6D11' : '#9AA0A8'; t3.style.fontWeight = '600'; } var p = el.querySelector('#marvis-flat-panel'); if (p) { /* v2.9.27：窄视口下「资料分析 / 材料一屏 / 选项一屏」这三行整体置灰—— appModeOn/fitMatOn/fitRightOn 已经返回 false，但只改返回值不够：用户点一下以为能开、其实没反应。这里连可点状态一起关掉，并在底部提示一句为什么，省掉「开关坏了」的误会。 */ var narrow = padNarrow(); var appOn = appModeOn(); chipSetRow(p.querySelector('.mv-row[data-k="all"]'), on, true); chipSetRow(p.querySelector('.mv-row[data-k="appmode"]'), appOn, on && !narrow); chipSetRow(p.querySelector('.mv-row[data-k="fitmat"]'), fitMatOn(), on && !narrow && appOn); chipSetRow(p.querySelector('.mv-row[data-k="rightfit"]'), fitRightOn(), on && !narrow && appOn); var fval = p.querySelector('.mv-fval'); // v2.9.36：字号档位百分比标签 if (fval) fval.textContent = Math.round(fontZoomGet() * 100) + '%'; var tip = p.querySelector('.mv-tip'); if (tip) { var tipTxt = narrow ? '窄屏（<' + PAD_NARROW_W + 'px）已自动关闭分栏；横屏或宽屏可用' : '关闭后刷新页面生效'; if (tip.textContent !== tipTxt) tip.textContent = tipTxt; } } el.title = '点按展开/收起设置：可关闭「资料分析」，或全部关闭'; } /* v2.9.5：面板结构版本号。每次改面板行（增删）就改一下这里。原因：masterChip 以前「已有 #marvis-flat-chip 就直接复用」，但复用只拿到旧 DOM —— 同一页面里先跑过一次脚本（脚本热更新 / 旧实例残留 / SPA 未刷新）时，后来新增的行（分栏草稿、笔迹自检）就永远不会出现在面板里，用户翻不到开关。 */ var CHIP_STRUCT = 'r12'; /* r12（v2.9.37）：胶囊/面板整体放大一档（r11 面板强制重建） */ /* ---------- v2.9.36 题目字号（A－ / 重置 / A＋） ---------- 痛点：有的题目字太小。实现用 zoom 作用在 app-question-choice（普通题与资料分析子题的题干+选项容器），档位 90%~160%、步进 10%，localStorage 记忆。「字体变大后草稿纸没有相应变大」的解法：草稿纸尺寸全靠实时测量（原生草稿 lockDraft / 分栏 appSizeSide 都按 gBCR 现算），字号变化后推一次 DOM 代际 + 全量重断言 + 分栏脏标记，草稿纸/画布随新排版自动变大变小。材料区不适用（那里有「适应」的一整套缩放补偿，两层 zoom 会打架）。 */ var FONTZOOM_LS = 'marvis-fb-fontzoom'; /* v2.9.41：上限 160% → 220%（用户反馈 160% 仍不够大；右栏适应让位见 appFitMat） */ var FONTZOOM_MIN = 0.9, FONTZOOM_MAX = 2.2, FONTZOOM_STEP = 0.1; function fontZoomGet() { var v = parseFloat(lsGet(FONTZOOM_LS)); if (!isFinite(v)) return 1; return Math.min(FONTZOOM_MAX, Math.max(FONTZOOM_MIN, Math.round(v * 10) / 10)); } function fontZoomSet(s) { s = Math.min(FONTZOOM_MAX, Math.max(FONTZOOM_MIN, Math.round(s * 10) / 10)); lsSet(FONTZOOM_LS, String(s)); fontZoomApply(); } function fontZoomApply() { try { document.documentElement.style.setProperty('--marvis-font-zoom', String(fontZoomGet())); } catch (e0) {} /* 草稿纸跟着长：lockDraft/appSizeSide 全是实时测量——推代际让滚动补扫重新校准近视口题，scan() 全量重断言，分栏开着重排重画 */ domEpoch++; /* v2.9.39：分栏开着时不做全量 scan —— 分栏里题目是 position:fixed 的组壳， scan() 的 processTi 会去展平、重建材料画布，跟分栏自己的布局打架（改字号时画面抖一下就是这个）。分栏的尺寸/列数/重绘交给下面这条链： appMarkDirty → 一帧内 appSizeAll+appRedraw，再补一次一屏缩放重算（字号一变右栏内容高度就变，不重算 scale 会溢出或留白）。 */ if (!appCur) { try { scan(); } catch (e1) {} } try { appMarkDirty(); } catch (e2) {} if (appCur) { try { appFitMat(); } catch (e7) {} // 字号变了 → 材料/选项一屏的 scale 要重算 try { appOptColsFix(true); } catch (e8) {} // 折行结果变了 → 选项列数要重排 try { appBarSync(); } catch (e6) {} // 顶栏字号标签同步 } /* 已打开的普通题原生草稿要按新尺寸重建绘图缓冲（见 fontZoomReopenDrafts），重开链路最迟 ~1.2s 走完，收一次尾保证新容器被锁定 */ try { fontZoomReopenDrafts(); } catch (e3) {} if (!appCur) { try { setTimeout(function () { try { scan(); } catch (e4) {} }, 1500); } catch (e5) {} } } /* v2.9.37：字号变化后让普通题草稿纸跟上——粉笔原生草稿的绘图缓冲区只在「开草稿那一刻」按容器尺寸建，之后题目变高（字号放大）缓冲区不变，而粉笔按 1:1 像素映射落笔（不缩放，v2.7.8 的压缩 bug 同源）→ 新扩出来的区域写不上字。直接改 canvas.width/height 会清空位图且不触发粉笔重绘，所以用「关-开」：粉笔自己按新容器尺寸重建 buffer 并重放 strokeStack，笔迹不丢。没开草稿的题（含用户手动关掉的）不碰；连点 A± 时每题只排一次重开。 */ function fontZoomReopenDrafts() { if (!quizPage()) return; var list = tis(); for (var i = 0; i < list.length; i++) { (function (ti) { try { if (isGroupTi(ti)) return; // 组级草稿被隐藏，不参与 if (ti.__mvFzReopen) return; // 连点 A± 去重 var dc = ti.querySelector('.draft-container'); var cv = dc && dc.querySelector('canvas#draft'); if (!cv || !dc) return; // 没开草稿的题不动 var wantW = Math.round(dc.clientWidth || 0); var wantH = Math.round(draftTargetHeight(ti) || 0); if (!wantW || !wantH) return; if (cv.width === wantW && cv.height === wantH) return; var tool = ti.querySelector('li.draft.tool'); if (!tool) return; ti.__mvFzReopen = true; tool.click(); // 关（粉笔随即拆掉容器） var tries = 0; (function reopen() { var still = ti.querySelector('.draft-container'); if (still && tries++ < 20) { setTimeout(reopen, 60); return; } // 等容器拆掉 ti.__mvFzReopen = false; var tool2 = ti.querySelector('li.draft.tool'); if (tool2 && !ti.querySelector('.draft-container')) tool2.click(); // 重开：按新尺寸重建 })(); } catch (e0) { ti.__mvFzReopen = false; } })(list[i]); } } function masterChip() { /* v2.9.27：@match 已放宽到整个 fenbi.com，非做题页（官网首页 / 课程页 / 订单页）不挂胶囊 —— 挂上去只会白占一块屏幕，还容易被当成广告。关闭态例外：那时胶囊是用户唯一的「重新开启」入口，必须留着。 */ if (masterEnabled() && !quizPage()) return; var el = document.getElementById('marvis-flat-chip'); if (el && el.getAttribute('data-mchip') !== CHIP_STRUCT) { try { el.remove(); } catch (e) { try { el.parentNode && el.parentNode.removeChild(el); } catch (e2) {} } el = null; } if (!el) { if (!document.body) { // document-start 兜底：等 body 就绪再挂 if (document.addEventListener) document.addEventListener('DOMContentLoaded', masterChip); return; } el = document.createElement('div'); el.id = 'marvis-flat-chip'; el.setAttribute('data-mchip', CHIP_STRUCT); /* v2.9.37：待机透明度 .3 → .5（用户反馈看不清；样式改为无条件更新，免得旧页面残留的 .3 版本挡住新值） */ var idleSt = document.getElementById('marvis-chip-idle'); if (!idleSt) { idleSt = document.createElement('style'); idleSt.id = 'marvis-chip-idle'; (document.head || document.documentElement).appendChild(idleSt); } idleSt.textContent = '#marvis-flat-chip{opacity:.5;transition:opacity .25s ease}' + '#marvis-flat-chip:hover,#marvis-flat-chip:focus-within{opacity:1}'; // 样式对齐粉笔底部水印条：「粉笔一页成卷 / 粉笔脚本君出品」那条的观感 // v2.9.37：整体放大一档（用户反馈看不清）——主字号 10.5→14px、内边距/圆角同步加大 el.style.cssText = 'position:fixed;right:10px;bottom:66px;z-index:2147483000;' + 'display:inline-flex;align-items:center;gap:7px;max-width:calc(100vw - 20px);' + 'touch-action:manipulation;' + /* v2.9.31：禁双击放大（整页草稿态连点胶囊曾把页面放大且缩不回） */ 'padding:5px 10px;border-radius:7px;background:rgba(248,249,250,.97);' + 'border:1px solid #E4E6EB;box-shadow:0 2px 10px rgba(0,0,0,.08);' + 'font-family:-apple-system,BlinkMacSystemFont,"PingFang SC","Helvetica Neue",Arial,sans-serif;' + 'font-size:14px;font-weight:600;line-height:1.3;letter-spacing:.01em;' + 'cursor:pointer;user-select:none;-webkit-user-select:none;'; /* v0.7：按用户要求去掉「粉笔自动全开草稿 / 粉笔脚本君出品」两段文字—— 胶囊只留「状态 · 版本号」和展开箭头，更小更低调 */ el.innerHTML = '' + '▾' + // 展开面板：向上弹（胶囊贴在屏幕右下，下面没有空间） ''; // 点胶囊本体 = 展开/收起面板（旧版是「点一下就关脚本」，v2.8.2 改成入口） el.addEventListener('click', function (ev) { ev.preventDefault(); ev.stopPropagation(); var p = el.querySelector('#marvis-flat-panel'); if (!p) return; var open = p.style.display === 'flex'; p.style.display = open ? 'none' : 'flex'; var caret = el.querySelector('.mv-caret'); if (caret) caret.textContent = open ? '▾' : '▴'; el.setAttribute('data-open', open ? '0' : '1'); }); // 面板两行：各自独立的开关，改完刷新 [].slice.call(el.querySelectorAll('.mv-row')).forEach(function (row) { row.addEventListener('click', function (ev) { ev.preventDefault(); ev.stopPropagation(); var k = row.getAttribute('data-k'); if (k === 'appmode') { // v2.9.0：分栏草稿开关——即改即生效，不用刷新 if (!masterEnabled()) return; lsSet(APP_LS, appModeOn() ? '0' : '1'); if (!appModeOn() && appCur) appClose(true); chipSync(el); return; } if (k === 'fitmat') { /* v2.9.25：材料一屏开关——即改即生效，分栏开着就直接重排 */ lsSet(FITMAT_LS, fitMatOn() ? '0' : '1'); try { appFitMat(); appApplyCols(); } catch (e2) {} chipSync(el); return; } if (k === 'rightfit') { /* v2.9.25：选项一屏开关——即改即生效 */ lsSet(FITRIGHT_LS, fitRightOn() ? '0' : '1'); try { appFitMat(); } catch (e2) {} chipSync(el); return; } if (k === 'font') { /* v2.9.36：题目字号 A－/重置/A＋，即点即生效；草稿纸跟着长由 fontZoomApply 里的代际推送 + 全量重断言 + 分栏脏标记完成 */ if (!masterEnabled()) return; var fb = (ev.target && ev.target.closest) ? ev.target.closest('.mv-fbtn') : null; var act = fb ? fb.getAttribute('data-f') : 'plus'; var cur = fontZoomGet(); if (act === 'minus') fontZoomSet(cur - FONTZOOM_STEP); else if (act === 'reset') fontZoomSet(1); else fontZoomSet(cur + FONTZOOM_STEP); chipSync(el); return; } // 剩下只有「全部题目」（总开关）：关掉 = 整套脚本不注入 lsSet(MASTER_LS, masterEnabled() ? '0' : '1'); chipReload(); }); }); // 点空白处收起（capture：整页点击过滤器 stopPropagation 也挡不住它） if (!document.__marvisChipOutside) { document.__marvisChipOutside = 1; document.addEventListener('click', function (ev) { var c = document.getElementById('marvis-flat-chip'); var p = c && c.querySelector('#marvis-flat-panel'); if (!p || !c || c.contains(ev.target)) return; if (p.style.display === 'flex') { p.style.display = 'none'; var caret = c.querySelector('.mv-caret'); if (caret) caret.textContent = '▾'; c.setAttribute('data-open', '0'); } }, true); } document.body.appendChild(el); } chipSync(el); } // 自检/单测入口：按当前 localStorage 重画胶囊与面板开关状态（不注入任何功能） window.__MARVIS_FENBI_CHIP__ = masterChip; if (!masterEnabled()) { masterChip(); return; } // 关闭态：不注入任何功能，只留设置入口 if (window.__MARVIS_FENBI_ENHANCE__) return; window.__MARVIS_FENBI_ENHANCE__ = true; masterChip(); var DLOCK_ATTR = 'data-marvis-dlock'; var AUTO_ATTR = 'data-marvis-autoopen'; var BOX_ATTR = 'data-marvis-boxkey'; var BOXVER_ATTR = 'data-marvis-boxver'; // 盒子结构版本戳：升级换代时强制重建 var BOX_VER = '2'; // v2：下一题支持组内子题推进 var CV_ATTR = 'data-marvis-cv'; // 自制画布标记（材料/子题） var CV_VER = '1'; var HIDE_ATTR = 'data-marvis-hidden'; // 被本脚本压制（组级原生草稿） var FPGRP_ATTR = 'data-marvis-fpgroup'; // 一拖五组（整页草稿会话的作用域标记） /* ---------- 样式 ---------- */ var STYLE_ID = 'marvis-fenbi-enhance-style'; // 版本戳：脚本升级（无刷新重注入 / 旧版残留）时样式也要跟着换， // 否则新 CSS 被 ID 守卫跳过——曾因此丢掉 .marvis-pen 的 position:absolute， // 画布退化成 flex 项把宿主撑爆、高度滚雪球（E2E 实测复现）。 var STYLE_VER_ATTR = 'data-marvis-style-ver'; var oldStyle = document.getElementById(STYLE_ID); if (oldStyle && oldStyle.getAttribute(STYLE_VER_ATTR) === SCRIPT_VER) { // 同版本已注入，跳过 } else { if (oldStyle) oldStyle.remove(); // 旧版残留：整块换掉 var st = document.createElement('style'); st.id = STYLE_ID; st.setAttribute(STYLE_VER_ATTR, SCRIPT_VER); st.textContent = [ /* v2.9.36 题目字号：zoom 只作用在题目内容容器上（普通题与资料分析子题的题干+选项都是 app-question-choice）——文字/图片一起放大、排版不破；草稿纸（原生草稿锁定高/分栏画布）是实时测量的，字号变化触发重测后自动变大。材料区不用它：那里有「适应」一整套缩放补偿，两层 zoom 会打架。 */ 'app-question-choice{zoom:var(--marvis-font-zoom,1);}', '.marvis-lbox{display:flex;align-items:center;gap:15px;margin-left:10px;position:relative;z-index:260;}', '.marvis-lbox .marvis-lbtn{box-sizing:border-box;width:22px;height:22px;padding:0;border-radius:4px;', 'border:1px solid #3b6ef0;background:#fff;color:#3b6ef0;font-size:12px;line-height:20px;text-align:center;cursor:pointer;}', '.marvis-lbox .marvis-lbtn:hover{background:#3b6ef0;color:#fff;}', '.marvis-lbox .marvis-lbtn:active{background:#2b55c8;color:#fff;}', '.marvis-lbox .marvis-next{box-sizing:border-box;height:22px;margin-left:0;padding:0 8px;border-radius:4px;', 'border:1px solid #3b6ef0;background:#fff;color:#3b6ef0;font-size:12px;line-height:20px;text-align:center;cursor:pointer;white-space:nowrap;}', '.marvis-lbox .marvis-next:hover{background:#3b6ef0;color:#fff;}', '.marvis-lbox .marvis-next:active{background:#2b55c8;color:#fff;}', /* v2.9.27：窄屏下字母盒别把题干挤走 —— 间距收紧、按钮反倒放大到 24px （触屏上 22px 的方块点起来容易串行，放大两像素刚好）。 */ '@media (max-width:599px){.marvis-lbox{gap:8px;margin-left:6px;}', '.marvis-lbox .marvis-lbtn{width:24px;height:24px;line-height:22px;}', '.marvis-lbox .marvis-next{height:24px;line-height:22px;}}', '.draft-container{background:transparent!important;}', '.draft-container{outline:1px solid rgba(0,0,0,0.12);outline-offset:-1px;}', '.ti, .draft-container{--color-bg-draft:transparent!important;}', /* 修复：草稿画布 .draft-container(z-index:130) 绝对定位会盖住右上角工具条，导致「标记 / 收藏 / 草稿」按钮不可点击；把 ul.title-right 层级提到画布之上(140) */ 'ul.title-right{position:relative;z-index:140;}', '.draft-tool .draft-tool-mark{display:none!important;}', /* ⑤ 笔刷设置面板 */ '.marvis-brush-panel{position:fixed;left:20px;bottom:20px;z-index:400;display:flex;align-items:center;gap:5px;', 'box-sizing:border-box;padding:2px 5px;border-radius:8px;background:rgba(255,255,255,.96);', 'border:1px solid rgba(0,0,0,.12);box-shadow:0 2px 10px rgba(0,0,0,.15);', 'font-size:12px;line-height:1;color:#333;font-family:inherit;user-select:none;}', /* inline 模式：插在顶部 app-setting 之前（header-right 行容器），覆盖 fixed 定位 */ '.marvis-brush-panel.mbp-inline{position:static;display:flex;align-items:center;gap:5px;flex:0 0 auto;align-self:center;height:30px;margin-right:8px;white-space:nowrap;box-shadow:none;border:1px solid rgba(0,0,0,.1);padding:2px 5px;}', '.marvis-brush-panel .mbp-dot{box-sizing:border-box;width:15px;height:15px;padding:0;border-radius:50%;', 'border:2px solid transparent;box-shadow:inset 0 0 0 1px rgba(0,0,0,.18);cursor:pointer;}', '.marvis-brush-panel .mbp-dot-on{border-color:#3b6ef0;box-shadow:0 0 0 2px rgba(59,110,240,.25);}', '.marvis-brush-panel .mbp-range{width:70px;margin:0;cursor:pointer;}', '.marvis-brush-panel .mbp-val{min-width:30px;text-align:right;color:#666;}', /* ⑥ ABCD 点击反馈按钮本身变色 */ 'button.marvis-feedback-correct{background:#00a05a!important;color:#fff!important;border-color:#00a05a!important;}', 'button.marvis-feedback-wrong{background:#e02020!important;color:#fff!important;border-color:#e02020!important;}', 'button.marvis-feedback-selected{background:#1a3f8f!important;color:#fff!important;border-color:#1a3f8f!important;}', /* ⑧ 自制画布（材料草稿 / 子题草稿）：z-index 130 与原生草稿同级，字母盒 260、题目工具条 140 仍在其上；touch-action 避免触摸绘制时滚动页面 */ '.marvis-pen{position:absolute;left:0;top:0;z-index:130;touch-action:none;', /* v2.9.27：Android WebView 上长按 500ms 会弹文字选择手柄 / 「复制-分享」菜单，而且它是**系统级**的，preventDefault 在部分内核上拦不住 —— 只能从 CSS 源头关掉长按选中与 callout。iOS 上同样有效（原来只有工具条按钮加了）。 */ 'user-select:none;-webkit-user-select:none;-webkit-touch-callout:none;}', '.marvis-cv-tools{position:absolute;right:8px;z-index:260;display:flex;gap:6px;user-select:none;}', /* 材料工具条：通栏 band 钉在材料顶部（不再悬浮压住材料文字），材料内容用 .marvis-mat-host .material-body 的 padding-top 让位 */ '.marvis-cv-tools-top{top:0;left:0;right:0;height:auto;justify-content:flex-end;', 'background:#fff;border-bottom:1px solid #e8e8e8;padding:4px 8px;box-sizing:border-box;}', '.marvis-mat-host .material-body{padding-top:34px !important;}', /* v2.7.2：材料内超宽素材(图片/表格/SVG)收缩到栏宽——栏宽由分隔条拖动或「适应」收窄决定，素材不收缩就会被左栏 overflow-x:hidden 裁掉右半（实测：表格/图片/文字全部显示不全的根因之一）。用规则而非行内样式， Angular 动态渲染出来的新素材同样生效 */ '.materials-container img,.materials-container table,.materials-container svg{max-width:100%!important;}', '.materials-container img{height:auto!important;}', /* v2.7.4：左下角「答题卡」折叠把手全透明（用户反馈小白卡挡题面文字）。白卡不是背景色，是 .answer-card-tag 内 SVG path 用 fill/stroke 画的，另有一条 ::after 白条——三处都要褪。只褪折叠态（JS 按容器位置打 .marvis-ac-clear 类）：展开态这个 tag 就是答题卡面板的头部，必须保持原样。该把手是全页唯一答题卡入口，只褪色、不隐藏、不拦点击 */ '.marvis-ac-clear .answer-card-tag .answer-card-tag-icon path{fill:transparent!important;stroke:transparent!important;}', '.marvis-ac-clear .answer-card-tag .answer-card-tag-icon{filter:none!important;}', '.marvis-ac-clear .answer-card-tag::after{background:transparent!important;}', '.marvis-cv-tools-bottom{bottom:6px;}', '.marvis-cv-tools .marvis-cvbtn{box-sizing:border-box;width:auto;min-height:22px;margin:0;padding:3px 8px;', 'border-radius:4px;border:1px solid #3b6ef0;background:#fff;color:#3b6ef0;', 'font-size:12px;line-height:1.35;text-align:center;cursor:pointer;white-space:normal;max-width:300px;', /* v2.7.9：切换按钮要长按退出，禁掉长按选中/系统菜单（iPad 上长按文字会弹菜单） */ 'user-select:none;-webkit-user-select:none;-webkit-touch-callout:none;}', '.marvis-cv-tools .marvis-cvbtn:hover{background:#3b6ef0;color:#fff;}', '.marvis-cv-tools .marvis-cvbtn-on{background:#3b6ef0;color:#fff;}', '.marvis-cv-tools .marvis-cvbtn-warn{background:#e02020;border-color:#e02020;color:#fff;}', /* v2.7.7 整页草稿层（仅资料分析子题）：透明全屏层对 HitTesting 隐身，只靠 window 捕获层 + setPointerCapture 收笔/鼠标。 v2.7.9：右上角胶囊(pill)整体删除——工具条留在题目原地不再飞走。 */ '#marvis-fp-layer{position:fixed;inset:0;z-index:2147481000;pointer-events:none;}', '#marvis-fp-layer canvas{position:absolute;left:0;top:0;width:100%;height:100%;touch-action:none;', 'user-select:none;-webkit-user-select:none;-webkit-touch-callout:none;}', /* v2.9.31 可书写态（fpLockScroll 挂 html[data-marvis-fp-draw]）： touchstart 不再 preventDefault 后，由 CSS 兜住三件事—— 双击放大压住（touch-action:manipulation 保留双指捏合缩放）、文字选中/长按菜单压住；笔的书写照常走 pointer 路径不受影响。 */ 'html[data-marvis-fp-draw] body{touch-action:manipulation;}', 'html[data-marvis-fp-draw] *{user-select:none!important;-webkit-user-select:none!important;' + '-webkit-touch-callout:none!important;}', /* v2.8.0 整页草稿「草稿竖条」：仿粉笔原生草稿工具条（撤销/橡皮/清空/退出那条）的深色竖排样式，贴屏幕右边居中常驻。用户要求把「当前可触摸 / 当前可书写」和「清空」都收进草稿按钮区，不要另外两个悬浮小白按钮。 */ '#marvis-fp-dock{position:fixed;right:0;top:50%;transform:translateY(-50%);z-index:2147482000;', 'display:none;flex-direction:column;width:64px;box-sizing:border-box;padding:6px 0;', 'border-radius:12px 0 0 12px;background:#3c464f;box-shadow:0 2px 12px rgba(0,0,0,.3);', 'touch-action:manipulation;', /* v2.9.31：禁双击放大（连续点「切换/退出」曾把页面放大且缩不回） */ 'user-select:none;-webkit-user-select:none;-webkit-touch-callout:none;}', '#marvis-fp-dock.on{display:flex;}', '#marvis-fp-dock .marvis-fpd-item{display:flex;flex-direction:column;align-items:center;gap:2px;', 'width:100%;margin:0;padding:7px 2px;border:0;background:transparent;cursor:pointer;', 'color:rgba(255,255,255,.62);font-family:-apple-system,"PingFang SC",sans-serif;', 'user-select:none;-webkit-user-select:none;-webkit-touch-callout:none;}', '#marvis-fp-dock .marvis-fpd-item+.marvis-fpd-item{border-top:1px solid rgba(255,255,255,.08);}', '#marvis-fp-dock .marvis-fpd-item:active{background:rgba(255,255,255,.1);}', '#marvis-fp-dock .marvis-fpd-item.on{color:#fff;}', '#marvis-fp-dock .marvis-fpd-item.warn{color:#ff8b7d;}', '#marvis-fp-dock .fpd-ico{display:block;width:20px;height:20px;}', '#marvis-fp-dock .fpd-name{display:block;font-size:11px;line-height:13px;letter-spacing:0;', 'white-space:nowrap;text-align:center;}', /* v2.9.27：窄屏（手机 / Via 竖屏）把草稿竖条收窄 —— 64px 在 412px 的屏上要吃掉 1/6 宽度，右侧题目文字被压得没地方看。按钮同步缩小一圈，但保持 44px 以上的可点高度（触屏最小可点尺寸）。 */ '@media (max-width:599px){#marvis-fp-dock{width:52px;padding:4px 0;}', '#marvis-fp-dock .marvis-fpd-item{padding:6px 1px;}', '#marvis-fp-dock .fpd-name{font-size:10px;line-height:12px;}}', /* 会话归属提示：当前这道题的草稿笔图标高亮（再点一次即退出整页草稿） */ 'li.draft.tool.marvis-fp-pen-on{color:#3b6ef0!important;}', 'li.draft.tool.marvis-fp-pen-on svg{fill:#3b6ef0!important;}' ].join(''); (document.head || document.documentElement).appendChild(st); } /* 页面整体左右各缩 20px */ if (!document.getElementById('marvis-page-pad')) { var pp = document.createElement('style'); pp.id = 'marvis-page-pad'; pp.textContent = '.ti{margin:0 40px!important}'; document.head.appendChild(pp); } /* ---------- ⑤ 笔刷设置：笔色 + 粗细 ---------- */ /* 原理：粉笔在每一笔绘制前都会实时写入 ctx.strokeStyle / fillStyle / lineWidth，主路径的粗细由 arc() 半径决定；因此 hook 这些 setter / arc 即可在不改页面状态、不碰 strokeStack 与 sessionStorage 的前提下控制笔色与粗细。风险：颜色不落库，切换笔色后旧笔迹会在下次重绘时同步变色（无法逐笔分色）。 */ var BRUSH_LS_KEY = 'marvis-fenbi-brush'; var brushColor = '#000000'; // 默认黑色（页面自带浅色主题默认笔色为红） var brushWidth = 1; // 粗细倍率：lineWidth 与 arc 半径共用 var savedBrush = lsJSON(BRUSH_LS_KEY); if (savedBrush) { if (typeof savedBrush.color === 'string' && /^#[0-9a-f]{6}$/i.test(savedBrush.color)) brushColor = savedBrush.color; if (typeof savedBrush.width === 'number' && isFinite(savedBrush.width)) { brushWidth = Math.min(4, Math.max(0.4, savedBrush.width)); } } function saveBrush() { lsSet(BRUSH_LS_KEY, JSON.stringify({ color: brushColor, width: brushWidth })); } // 仅作用于草稿画布：id 为 draft 或带 pen 类（廉价判断，避免拖慢书写） function isDraftCtx(ctx) { var c = ctx && ctx.canvas; if (!c) return false; return c.id === 'draft' || (c.classList && c.classList.contains('pen')); } function hexToRgb(hex) { var h = String(hex).replace('#', ''); if (h.length === 3) h = h.charAt(0) + h.charAt(0) + h.charAt(1) + h.charAt(1) + h.charAt(2) + h.charAt(2); var n = parseInt(h, 16); if (isNaN(n)) return [0, 0, 0]; return [(n >> 16) & 255, (n >> 8) & 255, n & 255]; } // 只替换 RGB，保留原值的 alpha（预览 0.1 / 终稿 1）；无法识别的值（如渐变对象）原样放行 function brushPaint(v) { if (typeof v !== 'string') return v; var alpha = 1; var m = /^rgba?$([^)]+)$/i.exec(v.trim()); if (m) { var parts = m[1].split(','); if (parts.length >= 4) { var a = parseFloat(parts[3]); if (!isNaN(a)) alpha = a; } } else if (!/^#[0-9a-f]{3}([0-9a-f]{3})?$/i.test(v.trim())) { return v; } var rgb = hexToRgb(brushColor); return 'rgba(' + rgb[0] + ',' + rgb[1] + ',' + rgb[2] + ',' + alpha + ')'; } function installBrushHook() { var P = window.CanvasRenderingContext2D && window.CanvasRenderingContext2D.prototype; if (!P || P.__marvisBrushHooked) return; try { P.__marvisBrushHooked = true; // 颜色：strokeStyle / fillStyle 必须成对 hook，否则预览段（fillStyle）会花斑 ['strokeStyle', 'fillStyle'].forEach(function (name) { var d = Object.getOwnPropertyDescriptor(P, name); if (!d || !d.get || !d.set) return; Object.defineProperty(P, name, { configurable: true, enumerable: d.enumerable, get: function () { return d.get.call(this); }, set: function (v) { d.set.call(this, isDraftCtx(this) ? brushPaint(v) : v); } }); }); // 粗细（短笔画路径）：只对画笔量级的线宽（页面硬编码 0.4）缩放，避开橡皮等其它用途 var dLW = Object.getOwnPropertyDescriptor(P, 'lineWidth'); if (dLW && dLW.get && dLW.set) { Object.defineProperty(P, 'lineWidth', { configurable: true, enumerable: dLW.enumerable, get: function () { return dLW.get.call(this); }, set: function (v) { var out = v; if (isDraftCtx(this) && brushWidth !== 1 && typeof v === 'number' && v > 0 && v <= 1.5) { out = v * brushWidth; } dLW.set.call(this, out); } }); } // 粗细（主路径）：粉笔用 arc() 逐点画圆，半径 = clamp(pressure*ratio, 2, 4)/2，即 1~2px； // 只缩放这一量级的半径，避免误伤橡皮/清空等大半径 arc 调用 var oArc = P.arc; P.arc = function (x, y, r) { if (brushWidth !== 1 && isDraftCtx(this) && typeof r === 'number' && r > 0 && r <= 3) { var args = Array.prototype.slice.call(arguments); args[2] = r * brushWidth; return oArc.apply(this, args); } return oArc.apply(this, arguments); }; } catch (e) { /* hook 失败不影响原有功能 */ } } installBrushHook(); /* ---------- v2.8.16 笔迹快照：撤销/反撤/清空后还原每笔颜色 ---------- 根因（research/fenbi-draft-class.pretty.js 逆向确认）：粉笔的笔画对象只有 {points, lineWidth, strokeType, lineWidthRatio}——【没有颜色字段】；绘制时的颜色由主题写死（浅色 rgba(255,0,0,·)）。笔刷面板的多色全靠我们的 ctx hook 在「画的时候」改写，所以像素一旦落盘就是对的；但撤销/反撤/清空后撤销会让粉笔把 strokeStack 里的笔迹【全部按当前笔色重画一遍】→ 多色笔迹塌成一种颜色。拿不到草稿组件实例（生产构建 __ngContext__ 只是模块私有 Map 的 LView id， webpack require 也不暴露），所以不碰粉笔内部，改用位图快照： · 每笔画完（含橡皮）拍一张 PNG 快照按顺序存 hist；首个 pointerdown 再拍 base · 撤销 → cursor--；反撤 → cursor++；清空 → 截断后 push 空白（对齐粉笔栈语义） · 粉笔重绘完成后（下下帧）把 hist[cursor]（或 base）贴回画布——粉笔的 strokeStack/stackPointer 完全不动，对它来说什么都没发生；每笔颜色回来了安全阀： · 只有「粉笔真的重绘了画布」（轮询对比快照内容）才贴；没动静就什么都不动 · 书写中、画布尺寸变了、快照缺失（刷新前的旧笔迹）→ 不贴，保持粉笔的结果 · 只管 app-draft 里的原生 canvas#draft；整页草稿层/材料画布不参与 */ var SNAP_RING_MAX = 12; var SNAP_PUSH_DELAY = 300; // 收笔后延迟拍快照：toDataURL 有 10~30ms 开销，不占书写路径 var snapMap = (typeof WeakMap === 'function') ? new WeakMap() : null; function snapIsNative(cv) { return !!(cv && cv.id === 'draft' && cv.closest && cv.closest('app-draft')); } function snapRec(cv, create) { if (!snapMap) return null; var r = snapMap.get(cv); if (!r && create) { r = { hist: [], cursor: -1, base: null, live: false, moved: false, armed: null, armSeq: 0, veil: null }; snapMap.set(cv, r); } return r || null; } function snapShoot(cv) { try { return cv.toDataURL('image/png'); } catch (e) { return null; } } /* v2.9.26：变化探测指纹——16×16 降采样哈希 + 尺寸。只用来比「粉笔动没动画布」，不入档；比 toDataURL（整幅 PNG 编码，单次 10~30ms）便宜一个量级，撤销/反撤的 20 轮轮询不再把主线程卡出顿挫感。 */ function snapFingerprint(cv) { try { if (!snapFingerprint._c) snapFingerprint._c = document.createElement('canvas'); var tmp = snapFingerprint._c; tmp.width = 16; tmp.height = 16; /* v2.9.39：willReadFrequently —— 这个上下文每 100ms 就被 getImageData 回读一次（撤销/反撤后最多 20 轮），不开的话每次都是 GPU→CPU 同步回读，主线程卡顿。 */ var tc = tmp.getContext('2d', { willReadFrequently: true }); if (!tc) return snapShoot(cv); tc.clearRect(0, 0, 16, 16); tc.drawImage(cv, 0, 0, 16, 16); var d = tc.getImageData(0, 0, 16, 16).data; var h = 0; for (var i = 0; i < d.length; i += 4) { h = (h * 31 + d[i] + d[i + 1] * 3 + d[i + 2] * 7 + d[i + 3] * 11) | 0; } return h + ':' + cv.width + 'x' + cv.height; } catch (e) { return snapShoot(cv); } } function snapPush(cv, rec) { var url = snapShoot(cv); if (!url) return; if (rec.cursor >= 0 && rec.hist[rec.cursor] === url) return; // 内容没变（点按等）不入档 rec.hist = rec.hist.slice(0, rec.cursor + 1); // 撤销后写新笔 = 粉笔截断栈，语义对齐 rec.hist.push(url); if (rec.hist.length > SNAP_RING_MAX) rec.hist.shift(); rec.cursor = rec.hist.length - 1; } function snapApply(cv, rec) { if (!cv.isConnected || rec.live) return; if (rec.cursor < -1 || rec.cursor >= rec.hist.length) return; var url = rec.cursor >= 0 ? rec.hist[rec.cursor] : rec.base; if (!url) return; var ctx = cv.getContext && cv.getContext('2d'); if (!ctx) return; var img = new Image(); img.onload = function () { snapVeilHide(rec); // 结果已落定（贴或放弃）→ 摘遮罩 if (!cv.isConnected || rec.live) return; // 用户已开始写新一笔 → 不贴 if (img.width !== cv.width || img.height !== cv.height) return; // 画布变尺寸 → 不贴 try { ctx.clearRect(0, 0, cv.width, cv.height); ctx.drawImage(img, 0, 0); } catch (e) { /* 贴失败就保持粉笔的结果 */ } }; img.src = url; } /* v2.8.17 防闪遮罩（veil）：粉笔的撤销/反撤重绘晚到约 0.5s，期间画布先是单色的，等我们贴回彩色快照才恢复 → 用户看到「闪一下别的颜色」。现在点击的瞬间就把目标状态的截图盖在画布正上方（pointer-events:none，不挡任何操作），粉笔的单色重绘被完全遮住；等我们的快照贴好再摘掉。 */ function snapVeilShow(cv, rec, url) { if (!url) return; try { var host = cv.parentElement; if (!host) return; var img = document.createElement('img'); img.setAttribute('data-marvis-snap-veil', '1'); img.style.cssText = 'position:absolute;pointer-events:none;border:0;margin:0;padding:0;'; host.appendChild(img); var cz = parseInt((cv.style && cv.style.zIndex) || getComputedStyle(cv).zIndex, 10); img.style.zIndex = (isNaN(cz) ? 0 : cz) + 1; var op = img.offsetParent || host; // absolute 的包含块 var orp = op.getBoundingClientRect(); var r = cv.getBoundingClientRect(); img.style.left = (r.left - orp.left) + 'px'; img.style.top = (r.top - orp.top) + 'px'; img.style.width = r.width + 'px'; img.style.height = r.height + 'px'; img.src = url; if (rec.veil && rec.veil.parentNode) rec.veil.parentNode.removeChild(rec.veil); rec.veil = img; } catch (e) { /* 盖不上就退回老路：闪一下但结果正确 */ } } function snapVeilHide(rec) { var v = rec.veil; if (v && v.parentNode) { try { v.parentNode.removeChild(v); } catch (e) {} } rec.veil = null; } function snapOnTool(it) { var host = it.closest('app-draft'); var cv = host && host.querySelector('canvas#draft'); if (!cv) return; var kind = it.classList.contains('undo') ? 'undo' : it.classList.contains('redo') ? 'redo' : it.classList.contains('empty') ? 'clear' : null; if (!kind) return; if (kind === 'undo' && it.classList.contains('cant-undo')) return; if (kind === 'redo' && it.classList.contains('cant-redo')) return; var rec = snapRec(cv, false); if (!rec) return; // 会话里没写过字 → 无档可还，维持现状 /* v2.8.17：点击瞬间把目标状态预览成 veil 盖在画布上——只取画面，【不动游标】。游标仍按 v2.8.16 的语义在「确认粉笔动手了」之后移动：粉笔的重绘晚到约 0.5s，若点击时就移游标、而粉笔把动作排到了下一次点击之后，游标会漂移（E2E 实测踩过）。 */ var target = null; if (kind === 'undo') { if (rec.cursor >= 1) target = rec.hist[rec.cursor - 1]; else if (rec.cursor === 0 && rec.base) target = rec.base; // 深过快照档（cursor<0）：没有可预告的画面 → 不盖，走老路收编粉笔的单色结果 } else if (kind === 'redo') { if (rec.cursor + 1 < rec.hist.length) target = rec.hist[rec.cursor + 1]; } if (target) snapVeilShow(cv, rec, target); rec.armed = kind; var mySeq = ++rec.armSeq; /* 实测（ego-browser 真机 E2E）：粉笔的撤销重绘【不是同步的】——点击后 200ms 画布还是原样，400~600ms 才把 strokeStack 按单色重画完。所以不能「等一拍」就下结论，改成轮询对比画布内容：变了 = 粉笔动手了，2 秒还没变 = 它没理这次点击。 */ var preUrl = snapFingerprint(cv); var tries = 0; var poll = function () { if (rec.armSeq !== mySeq) return; // 更新的点击已接管 if (rec.live) { rec.armed = null; snapVeilHide(rec); return; } // 用户落笔了 → 放弃本次 var nowUrl = snapFingerprint(cv); if (tries++ < 20 && nowUrl === preUrl) { setTimeout(poll, 100); return; } rec.armed = null; if (nowUrl === preUrl) { snapVeilHide(rec); return; } // 粉笔没动手 → 只摘遮罩 if (kind === 'clear') { snapPush(cv, rec); snapApply(cv, rec); return; } if (kind === 'undo') rec.cursor--; else if (kind === 'redo') rec.cursor++; if (rec.cursor < -1) { // 撤销已深过快照档（动到会话开始前的旧笔迹）：粉笔刚画好的结果几何是对的， // 把它收编为新 base（旧笔迹变单色无解），cursor 归位，之后继续一致 var now = snapShoot(cv); if (now) rec.base = now; rec.cursor = -1; return; } snapApply(cv, rec); // 贴完（或放弃）时在 onload 里摘 veil }; setTimeout(poll, 120); } function snapBind() { if (!snapMap) return; // 工具条按钮（撤销/反撤/清空）：捕获阶段先记账，粉笔的处理器随后自己跑 document.addEventListener('click', function (ev) { var t = ev.target; var it = t && t.closest ? t.closest('app-draft .tool-item') : null; if (it) { try { snapOnTool(it); } catch (e) { /* 不惊动页面 */ } } }, true); // 落笔：建档 + 标记书写中（首笔前顺带拍 base，只发生一次） window.addEventListener('pointerdown', function (e) { var c = e.target; if (!c || c.tagName !== 'CANVAS' || !snapIsNative(c)) return; var rec = snapRec(c, true); if (!rec) return; if (rec.veil) snapVeilHide(rec); // 用户接着写 → 立刻摘掉预览遮罩 if (rec.live) return; rec.live = true; rec.moved = false; if (!rec.hist.length && rec.cursor === -1 && !rec.base) rec.base = snapShoot(c); }, true); // 移动：有位移才算真笔画（点按会被粉笔丢弃，不入档，否则游标错位） window.addEventListener('pointermove', function (e) { var c = e.target; if (!c || c.tagName !== 'CANVAS') return; var rec = snapMap.get(c); if (rec && rec.live) rec.moved = true; }, true); // 收笔：粉笔在 pointerup 处理器里同步画完最后一小段 → 稍后拍快照入档 function up(e) { var c = e.target; if (!c || c.tagName !== 'CANVAS') return; var rec = snapMap.get(c); if (!rec || !rec.live) return; rec.live = false; var hadMoved = rec.moved; setTimeout(function () { if (rec.live || rec.armed || !hadMoved) return; // 撤销在途/点按 → 不入档 snapPush(c, rec); }, SNAP_PUSH_DELAY); } window.addEventListener('pointerup', up, true); window.addEventListener('pointercancel', up, true); } snapBind(); /* ---------- v2.8.9 平板笔迹「合并还原 + 补密 + 防切笔」（治「平板用笔只能画折线」） ---------- 背景（全部逆向自粉笔前端 chunk-Q3SELT5A.js 的 Draft 组件源码，逐字核对，非猜测）： ① 粉笔画笔迹 = 一串采样点，每个采样点画一个半径 1px 的圆（arc），点数 ≥4 时每 4 点一组做基数样条（cardinal spline）细分后连成曲线；点数 <4 时走 drawLine()（moveTo + 逐点 lineTo）= **纯直线**。 ② 全站 chunk 搜不到 pointerType：粉笔完全不区分笔 / 手，二者唯一差别是【采样密度】+【有没有隐式指针捕获】。 ③ 触摸指针有隐式捕获（Pointer Events 规范）→ 全程不触发 pointerout → 笔画不会被切；笔没有隐式捕获 → 一旦掠过画布上的覆盖元素（脚本注入的 ABCD 盒、粉笔工具条）， pointerout 会冒泡到 app-draft → finishCurStroke() → 这一笔被【切成短段】，每段点数 <4 → 整段只剩直线（这才是「只会画直线」）。修法（全部在 window 捕获阶段做，不改粉笔的画法；笔迹仍由粉笔自己画，橡皮 / 撤销 / 笔色 / 落笔缓存全部照旧）： A. 合并还原：pointermove 里取 e.getCoalescedEvents()——浏览器因主线程繁忙而「合并」掉的中间采样全在里面。页面越重（一页成卷把版面撑大）合并越多，这一步直接把采样还原回手指级别，不用猜。 B. 切线补密：没有合并事件（或合并后仍稀疏）时，沿行笔切线用二次贝塞尔补中间点，间距 ≈3 缓冲像素（粉笔圆点半径 1px），把「折线段」还原成「曲线」。 C. 防切笔：笔在草稿范围内的 pointerout 一律拦下，笔画不再被切成短段；笔在草稿外抬笔时补发一个合成 pointerup，避免粉笔 pointerEventId 卡死。只处理 pen（鼠标采样本来就密；手指有隐式捕获，本来就不受影响）。 */ var PEN_SYNTH = '__marvisSynth'; var penTrack = null; // {id, x, y, px, py, hasP, cv, n}：上一笔采样位置与方向 var penStrokeCv = null; // 当前笔画所在的原生草稿画布（防切笔 / 收笔兜底用） var penSynthN = 0; // 本笔已补点数（总量护栏） var PEN_SYNTH_MAX = 40; // 单个事件最多补多少点 var PEN_STROKE_MAX = 800; // 单笔最多补多少点（极端快速书写时防爆量） /* ---------- v2.9.30：笔迹诊断子系统已整体删除 ---------- 旧版这里有一整套「笔迹事实采集」（v2.8.12~v2.8.14）：每路指针流计数、生命周期台账、原始时间线、合并采样密度、丢弃计数、原生画布像素指纹（双画者检测），以及胶囊面板「笔迹自检」行 / 诊断浮层 / __MARVIS_FENBI_PEN__() 出口。用户定稿彻底移除（面板不再有该行，也不再采集任何诊断数据）。唯一保留的是落笔归属判定需要的最小记账：penDownIds —— 「哪些 pointerId 自己 down 过」用于分辨真·第二指针（手掌 / 另一支笔）与浏览器中途换 id（见 fpStrokeOwns），它是书写功能的一部分，不是诊断。 */ var penDownIds = {}; // pointerId -> true（pointerdown 时登记） var penSeen = false; // 本会话是否见过 pointerType=pen（手掌误触判定仍需要，见 fpOnDown） // 只认粉笔自己的原生草稿画布；我们自建的 canvas.marvis-pen 不在其列（它自己走贝塞尔平滑） function isNativeDraftCanvas(el) { if (!el || el.tagName !== 'CANVAS') return false; if (el.classList && el.classList.contains('marvis-pen')) return false; if (el.id === 'draft') return true; try { return !!(el.closest && (el.closest('app-draft') || el.closest('.draft-container'))); } catch (e) { return false; } } // 组级原生草稿（一拖五）被脚本隐藏 → 那块由我们自建画布接管，不参与原生补密 function draftCanvasUsable(cv) { if (!cv || cv.tagName !== 'CANVAS') return false; if (cv.classList && cv.classList.contains('marvis-pen')) return false; try { var dc = cv.closest ? cv.closest('.draft-container') : null; if (dc && dc.getAttribute(HIDE_ATTR) === '1') return false; } catch (e) {} return true; } // 事件目标 → 粉笔原生草稿画布。 // 目标可能是画布本身，也可能是压在画布上的覆盖元素（我们注入的 ABCD 盒、粉笔工具条）： // 那种情况下 pointermove 仍然冒泡到 app-draft，粉笔照常画线（坐标按 canvas 换算）， // 所以补密也必须继续做，否则一跨过覆盖元素就又变回采样稀疏的折线。 function resolveDraftCanvas(el) { if (!el || el.nodeType !== 1) return null; var cv = null; if (isNativeDraftCanvas(el)) { cv = el; } else { var host = null; try { host = el.closest ? el.closest('app-draft') : null; } catch (e) {} if (!host) return null; try { cv = host.querySelector('canvas#draft') || host.querySelector('canvas'); } catch (e2) {} } return draftCanvasUsable(cv) ? cv : null; } // 指针是否还落在画布范围内（用来判断「只是掠过覆盖元素」还是「真的离开草稿区」） function pointerInCanvas(cv, e) { try { var r = cv.getBoundingClientRect(); if (!r || !r.width || !r.height) return false; return e.clientX >= r.left - 1 && e.clientX <= r.right + 1 && e.clientY >= r.top - 1 && e.clientY <= r.bottom + 1; } catch (err) { return false; } } // 合成一个指针事件（优先用原生 PointerEvent；无则退回普通 Event 补属性） function mkSynthPointer(type, opts) { var ev = null; try { if (typeof window.PointerEvent === 'function') { ev = new window.PointerEvent(type, { bubbles: true, cancelable: true, composed: true, pointerId: opts.pointerId, pointerType: opts.pointerType, clientX: opts.clientX, clientY: opts.clientY, screenX: opts.screenX, screenY: opts.screenY, pressure: opts.pressure, tiltX: opts.tiltX, tiltY: opts.tiltY, isPrimary: opts.isPrimary }); } } catch (e) { ev = null; } if (!ev) { try { ev = document.createEvent('Event'); ev.initEvent(type, true, true); } catch (e2) { return null; } for (var k in opts) { try { ev[k] = opts[k]; } catch (e3) {} } } try { ev[PEN_SYNTH] = true; } catch (e4) {} return ev; } // 把合成事件派发回原生草稿画布（冒泡到 app-draft → 粉笔的 onPointerMove 收到） function sendSynth(cv, type, e, x, y, pressure) { var ev = mkSynthPointer(type, { pointerId: e.pointerId, pointerType: 'pen', clientX: x, clientY: y, screenX: e.screenX, screenY: e.screenY, pressure: pressure, tiltX: e.tiltX, tiltY: e.tiltY, isPrimary: e.isPrimary === undefined ? true : e.isPrimary }); if (!ev) return false; try { cv.dispatchEvent(ev); } catch (e2) { return false; } return true; } function penOnDown(e) { if (!e || e.pointerType !== 'pen') return; if (e[PEN_SYNTH]) return; var cv = resolveDraftCanvas(e.target); if (!cv) return; penTrack = { id: e.pointerId, x: e.clientX, y: e.clientY, px: 0, py: 0, hasP: false, cv: cv, n: 0, sent: [], // v2.8.13：这一笔里「原生画布已经收到过的坐标」——补密幂等的依据 t: (typeof Date !== 'undefined' && Date.now) ? Date.now() : 0 // v2.8.14：逐点投递判据 }; penSentAdd(penTrack, e.clientX, e.clientY); // 起笔点原生会自己收到 penSynthN = 0; penStrokeCv = cv; } /* ---------- v2.8.13 原生补密幂等化 ---------- 旧写法（v2.8.7 起）假定「getCoalescedEvents() 返回的最后一个元素就是当前事件本身」，于是只补投 co[0..len-2]。这条假定只对 Safari / Chrome 成立。第三方 WebView 壳（Via = iOS 上的 WKWebView 壳）返回的列表可能是 · 包含**已经作为独立事件投递过**的样本（旧版 WebKit 的已知行为），或 · 顺序与 Safari 不同（当前事件不在末尾） → 我们把同一批物理采样**再投一遍**给原生画布 → 粉笔的 stroke.points 变成 A,A,B,B,C,C → paint() 的 4 点滑动窗口沿原路折返 → 屏幕上就是「一条笔画画成两条几乎平行、局部交叉的线」。修法：**不再依赖任何浏览器语义**。只补「还没投过、且确实落在上一次事件与本次事件之间」的样本： ① 当前事件的位置先登记为「已投递」（原生会自己收到它）； ② 候选样本若与已投递坐标过近 → 跳过（已经投过了）； ③ 候选样本若不落在「上次位置→本次位置」的区间内 → 跳过（陈旧或超前，绝不乱序）。这样无论浏览器怎么返回合并列表，原生画布都只会收到每个物理采样**一次**。 */ var PEN_SENT_MAX = 800; // 一笔内保留多少个「已投递坐标」：必须覆盖整笔（一笔可到 400+ 点） var PEN_SENT_SCAN = 240; // 去重只回看最近这么多条：重复必然发生在最近，避免每帧 O(n) 全扫 var PEN_TICK_GAP = 5; // v2.8.14：相邻两个原始事件间隔小于 5ms = 浏览器正在把这一帧的 // 采样**逐个**投递（Via 实测：14 个采样挤在 1ms 内）→ 这些点 // 原生马上会自己收到，此时绝不能再补投，否则就是「投两遍」。 function penSentAdd(tr, x, y) { if (!tr) return; if (!tr.sent) tr.sent = []; tr.sent.push({ x: x, y: y }); if (tr.sent.length > PEN_SENT_MAX) tr.sent.shift(); } function penSentHas(tr, x, y, r) { if (!tr || !tr.sent) return false; var rr = (r || 1) * (r || 1); var n = tr.sent.length; var from = n > PEN_SENT_SCAN ? n - PEN_SENT_SCAN : 0; for (var i = n - 1; i >= from; i--) { // 从最近的开始回看 var q = tr.sent[i]; var dx = x - q.x, dy = y - q.y; if (dx * dx + dy * dy < rr) return true; } return false; } /* v2.8.14 再收紧：判定三道闸（与浏览器怎么返回列表无关）： ① 已经投递过的坐标 → 跳过（否则原生会把同一条轨迹画两遍） ② 不落在「上次位置→本次位置」区间内 → 跳过（陈旧/超前，绝不乱序） ③ pointerId 不符 → 跳过（别的指针的采样） ④ 列表末尾必须就是当前事件本身 → 否则整批不补（见下）返回 { list: 可补投的样本, skip: 被跳过的个数, tail: 是否因 ④ 整批放弃 } ④ 的来历（Via 真机自检）：Via 会把同一帧的 14 个采样**逐个作为独立 pointermove 投递**，而每个事件的 getCoalescedEvents() 又把这一帧 14 个**原样返回**。于是帧内第一个事件（P1）的列表末尾是 P14 而不是 P1 —— 列表里全是「浏览器随后会自己送到」的未来采样；照补就是把这一帧画两遍。Safari/Chrome 的正常形态则是「列表末尾 = 当前事件」（中间点在前、当前点在末），此时补前面的点才安全。宁可少补（采样稀一点，cardinal 样条照样平滑），绝不能补出重复（那是两条交错的线）。 */ function penPickCoalesced(tr, co, ax, ay, bx, by, pid) { var list = [], skip = 0; if (!co || !co.length) return { list: list, skip: skip }; var tail = co[co.length - 1]; if (tail && isFinite(tail.clientX) && isFinite(tail.clientY)) { var ddx = tail.clientX - bx, ddy = tail.clientY - by; if (ddx * ddx + ddy * ddy > 1) return { list: list, skip: co.length, tail: true }; // ④ } var pdx = bx - ax, pdy = by - ay; var plen2 = pdx * pdx + pdy * pdy; for (var i = 0; i < co.length; i++) { var ce = co[i]; if (!ce) { skip++; continue; } if (ce.pointerId !== undefined && pid !== undefined && ce.pointerId !== pid) { skip++; continue; } var gx = ce.clientX, gy = ce.clientY; if (!isFinite(gx) || !isFinite(gy)) { skip++; continue; } if (penSentHas(tr, gx, gy, 1)) { skip++; continue; } // ① 已投递过 if (plen2 > 0.01) { // ② 必须落在区间内 var tt = ((gx - ax) * pdx + (gy - ay) * pdy) / plen2; if (tt < 0.02 || tt > 1.05) { skip++; continue; } } list.push({ x: gx, y: gy, pressure: ce.pressure }); } return { list: list, skip: skip }; } // 收笔：这一笔结束，清空跟踪状态（pointerout 不在此列——它可能只是掠过覆盖元素） function penOnEnd(e) { if (!e) return; if (penTrack && penTrack.id === e.pointerId) penTrack = null; } /* 粉笔把 pointerout 也绑到了 finishCurStroke：笔只要掠过画布上的任何覆盖元素（我们注入的 ABCD 字母盒 / 粉笔工具条…）就会把这一笔【切成两段】，每段累计点数不足 4 → paint() 走 drawLine() → 只画直线（就是「画不了弧线」）。手指没这问题：触摸指针有隐式捕获，全程不触发 pointerout。修法：笔还在草稿范围内时的 pointerout 一律拦下（不传给粉笔），笔画保持为一整笔。兜底：笔在画布外抬笔时（真实 pointerup 落不到 app-draft 上），补发一个合成 pointerup 给画布，否则粉笔的 pointerEventId 会一直占着、下笔直接被忽略（画布卡死）。 */ function penOnOut(e) { if (!e || e.pointerType !== 'pen') return; if (e[PEN_SYNTH]) return; var cv = resolveDraftCanvas(e.target); if (!cv) { // 目标已经是覆盖元素了（上一跳就被我们放行过一次）→ 仍按当前笔画的画布判断 cv = (penTrack && penTrack.cv) || penStrokeCv; if (!cv) return; } penStrokeCv = cv; if (pointerInCanvas(cv, e)) { try { e.stopPropagation(); } catch (err) {} // 只掠过覆盖元素 → 不切笔 } else { penTrack = null; // 真的离开草稿区 → 这一笔到此为止 } } function penOnUp(e) { if (!e || e.pointerType !== 'pen') return; if (e[PEN_SYNTH]) return; var cv = penStrokeCv; penStrokeCv = null; if (!cv) return; if (e.target === cv) return; // 抬笔就在画布上 → 粉笔自己会收到 var host = null; try { host = cv.closest ? cv.closest('app-draft') : null; } catch (e1) {} if (host && e.target && e.target.nodeType === 1) { try { if (host.contains(e.target)) return; } catch (e2) {} // 仍在草稿内 → 粉笔自己会收到 } // 抬笔在草稿之外 → 补发合成 pointerup，防止粉笔 pointerEventId 卡住 if (!sendSynth(cv, 'pointerup', e, e.clientX, e.clientY, 0)) return; } function penDensify(e) { if (!e || e.pointerType !== 'pen') return; if (e[PEN_SYNTH]) return; /* v2.9.32：笔尖没接触就不补密——悬停 move（buttons=0，笔尖离屏 1cm 内持续派发）和手势按键位的悬停 move（buttons=2，无笔尖接触）都跳过：旧版会拿这些 move 走补密路径，白耗还可能给原生画布补投无墨 move。 */ if (!e.buttons || e.buttons === 2) return; var cv = null; // 指针可能压在覆盖元素上（此时 target 不是画布），但只要还在画布范围内就继续补密 if (penTrack && penTrack.id === e.pointerId && penTrack.cv && pointerInCanvas(penTrack.cv, e)) { cv = penTrack.cv; } if (!cv) cv = resolveDraftCanvas(e.target); if (!cv) return; var last = penTrack; var now = (typeof Date !== 'undefined' && Date.now) ? Date.now() : 0; if (!last || last.id !== e.pointerId || last.cv !== cv) { penTrack = { id: e.pointerId, x: e.clientX, y: e.clientY, px: 0, py: 0, hasP: false, cv: cv, n: 0, sent: [], t: now }; penSentAdd(penTrack, e.clientX, e.clientY); // 新的一笔：当前点原生会自己收到 penSynthN = 0; return; } var ax = last.x, ay = last.y; var bx = e.clientX, by = e.clientY; /* v2.8.14 第二道闸 —— 「逐点投递」识别： Via 真机自检的时间线显示，同一帧的 14 个真实采样会被浏览器**逐个作为独立 pointermove 投递**（14 条挤在同一个毫秒里），而每个事件的 getCoalescedEvents() 又把这 14 个**原样返回**。于是第一个事件刚把 P2..P14 补投出去，浏览器紧接着就把 P2..P14 自己投递一遍 → 原生画布每个点收到两次 → 两条交错的线。判据与浏览器语义无关：相邻两个原始事件间隔 < 5ms = 同一帧内的连续投递 → 这些点原生马上会自己收到，一律不补。Safari/Chrome 的正常形态是「每帧一个事件」（间隔 16~60ms），不受影响。 */ // hasP=false 表示上一个是 pointerdown（落笔瞬间与第一个 move 可能同一毫秒）， // 那种情况下不做「逐点投递」判定，否则会把落笔后的第一次补密也误杀。 var gap = (last.hasP && last.t && now) ? (now - last.t) : 999; var ticking = gap < PEN_TICK_GAP; // 浏览器正在逐点投递 /* ① 合并还原（v2.8.13 幂等版）：浏览器因主线程繁忙，把中间的采样合并进这一个 pointermove，getCoalescedEvents() 能把它们全部拿回来。【v2.8.13 的关键修正】旧写法假定「列表最后一个 = 当前事件本身」，只补 co[0..len-2]——这条假定只对 Safari/Chrome 成立。第三方 WebView 壳（Via）返回的列表可能把**已经投递过的样本**也包含进来（或顺序不同）→ 我们再投一遍 → 粉笔的 stroke.points 变成 A,A,B,B,C,C → paint() 的 4 点窗口沿原路折返 → 屏幕上就是「一条笔画画成两条几乎平行、局部交叉的线」。现在只补「还没投过、且确实落在上次位置与本次位置之间」的样本： ① 当前事件的位置先登记为「已投递」（原生会自己收到它）； ② 与已投递坐标过近 → 跳过； ③ 不落在区间内 → 跳过（陈旧/超前，绝不乱序投递）。 */ var co = null; try { co = (typeof e.getCoalescedEvents === 'function') ? e.getCoalescedEvents() : null; } catch (err) {} // v2.8.14：原生路径也要记合并密度。以前只在整页草稿路径（fpOnMove）记，于是 // Via 的诊断里 coalesced 恒为 {max:0,avg:0,events:0} —— 差点据此误判「Via 没有合并采样」。 penSentAdd(last, bx, by); // 当前事件原生会自己收到 → 先登记 var pick = { list: [], skip: 0 }; if (ticking) { // 浏览器正在逐点投递 → 一个都不补（补了就是投两遍） } else { pick = penPickCoalesced(last, co, ax, ay, bx, by, e.pointerId); for (var pi = 0; pi < pick.list.length; pi++) { if (penSynthN >= PEN_STROKE_MAX) break; var ps = pick.list[pi]; if (!sendSynth(cv, 'pointermove', e, ps.x, ps.y, ps.pressure)) break; penSynthN++; penSentAdd(last, ps.x, ps.y); ax = ps.x; ay = ps.y; } } /* ② 粉笔自己的画法（cardinal spline，4 点窗口）本身就是平滑曲线：采样再稀也只是「形状粗一点」，不会变成折线——所以这里【不再做插值重建】（切线重建反而会在采样点处留下折角，见 tests/fenbi-kink-sim.js 的量化对比）。只有浏览器给出的真实合并采样（①）才值得补回去：那是笔的真实轨迹。 */ /* v2.8.14 关键修复 —— 这一行漏掉 sent 就是 Via「两条交错线」的直接成因： v2.8.13 在这里重建 penTrack 时**没有把 last.sent 带过来**，于是「已投递坐标」每个事件都从空数组重新开始 —— 幂等防线只在「单个事件内部」生效，跨事件/跨帧完全失效。Via 实测（v2.8.13 自检 JSON）的铁证： · timeline 里同一批 14 个采样在相隔 1ms 的两个时间戳里各出现一次（t=...611025 与 t=...611026 的坐标序列完全相同）→ 真实采样被投了两遍； · synth = {sent:441, skip:57} → 补投了 441 个、幂等只挡下 57 个。浏览器（Via）既把这一帧的采样**作为独立 pointermove 投递**、又在 getCoalescedEvents() 里**原样返回同一批**，于是我们把已经画过的点又补投一遍 → 粉笔 stroke.points 变成 A,A,B,B,C,C → paint() 的 4 点窗口沿原路折返 → 屏幕上两条交错的线。 sent 继承后：浏览器独立投递过的坐标已登记在案 → coalesced 里再出现就被 ① 挡掉 → 「已经独立投递过就不补」与「跨帧不重复补」两个问题一并解决。 */ penTrack = { id: e.pointerId, x: bx, y: by, px: ax, py: ay, hasP: true, cv: cv, n: last.n + 1, sent: last.sent, t: now }; } function installPenDensifier() { if (typeof window.addEventListener !== 'function') return; try { window.addEventListener('pointerdown', penOnDown, true); window.addEventListener('pointermove', penDensify, true); window.addEventListener('pointerout', penOnOut, true); window.addEventListener('pointerup', penOnUp, true); window.addEventListener('pointerup', penOnEnd, true); window.addEventListener('pointercancel', penOnEnd, true); // v2.9.30：最小记账（downIds + penSeen，零分配）；不再有诊断旁观 window.addEventListener('pointerdown', penPtrWatch, true); window.addEventListener('pointermove', penPtrWatch, true); } catch (e) { /* 装不上不影响原有功能 */ } } /* v2.9.30：旧版「全局指针旁观器」penStatWatch 已随诊断子系统整体删除。只保留两项书写功能依赖的最小记账（纯布尔/查表，零分配）： · penDownIds —— pointerdown 登记，fpStrokeOwns 靠它分辨「真·第二指针」（手掌 / 另一支笔）与「浏览器中途换 id」； · penSeen —— 见过 pointerType=pen 就置位，fpOnDown 的 touch-as-pen 自适应（会报 pen 的设备上，touch 一律当手指/手掌挡掉）仍需要它。 */ function penPtrWatch(e) { if (!e) return; if (e.pointerType === 'pen') penSeen = true; if (e.type === 'pointerdown') { try { penDownIds[e.pointerId] = true; } catch (e2) {} } } installPenDensifier(); /* ---------- ⑤ 笔刷设置面板（ensure 建 DOM / place 定位，每轮扫描均可调用） ---------- */ var brushPanelEl = null; // 模块级面板引用：place 逻辑不依赖 getElementById // ensureBrushPanel：创建面板 DOM、绑定事件并接入文档树（已存在则直接返回，可重复调用） function ensureBrushPanel() { try { if (!document.body) return; if (brushPanelEl && brushPanelEl.isConnected) return; // 已创建且仍在文档树中 var existed = document.getElementById('marvis-brush-panel'); // 兜底：DOM 中已有同 id 节点 if (existed) { brushPanelEl = existed; return; } var panel = document.createElement('div'); panel.id = 'marvis-brush-panel'; panel.className = 'marvis-brush-panel'; panel.title = '笔刷设置'; [['#000000', '黑'], ['#1e5eff', '蓝'], ['#e02020', '红']].forEach(function (pair) { var dot = document.createElement('button'); dot.type = 'button'; dot.className = 'mbp-dot'; dot.setAttribute('data-color', pair[0]); dot.title = pair[1] + '色'; dot.style.background = pair[0]; dot.addEventListener('click', function (ev) { ev.preventDefault(); ev.stopPropagation(); brushColor = pair[0]; saveBrush(); syncBrushPanel(); }); panel.appendChild(dot); }); var range = document.createElement('input'); range.type = 'range'; range.className = 'mbp-range'; range.min = '0.4'; range.max = '4'; range.step = '0.1'; range.value = String(brushWidth); range.title = '笔画粗细（0.4×~4×）'; range.addEventListener('input', function (ev) { ev.stopPropagation(); var v = parseFloat(range.value); if (!isNaN(v)) { brushWidth = v; saveBrush(); syncBrushPanel(); } }); panel.appendChild(range); var val = document.createElement('span'); val.className = 'mbp-val'; panel.appendChild(val); // 事件在创建时统一绑定一次（inline / fixed 两种模式共用），避免冒泡干扰页面与草稿画布的 pointer 事件 ['pointerdown', 'mousedown', 'click', 'dblclick', 'touchstart', 'keydown', 'wheel'].forEach(function (t) { panel.addEventListener(t, function (ev) { ev.stopPropagation(); }); }); // 关键：先接入文档树，placeBrushPanel 才能取到并把面板搬到目标位置 brushPanelEl = panel; document.body.appendChild(panel); syncBrushPanel(); } catch (e) { /* 面板构建失败不影响 scan() 中后续题目处理 */ } } // placeBrushPanel：把已存在的面板放到正确位置，每次扫描都执行 var appSettingEl = null; // v2.9.34：锚点缓存——省掉每轮扫描一次全文档 querySelector function placeBrushPanel() { try { var panel = brushPanelEl || document.getElementById('marvis-brush-panel'); if (!panel || !document.body) return; /* 锚点：app-setting（父级为顶部 header-right flex 行容器），插到它的前一个兄弟位置 */ var appSetting = (appSettingEl && appSettingEl.isConnected) ? appSettingEl : (appSettingEl = document.querySelector('app-setting')); if (appSetting && appSetting.parentElement) { if (panel.parentElement !== appSetting.parentElement || panel.nextElementSibling !== appSetting) { appSetting.parentElement.insertBefore(panel, appSetting); // insertBefore 会自动搬移已存在节点 } panel.classList.add('mbp-inline'); return; } /* 兜底：锚点始终缺失时才回到左下角 fixed 模式；后续扫描一旦锚点出现仍会挪过去 */ panel.classList.remove('mbp-inline'); if (panel.parentElement !== document.body) document.body.appendChild(panel); } catch (e) { /* 定位失败不影响 scan() 中后续题目处理 */ } } function syncBrushPanel() { var panel = brushPanelEl || document.getElementById('marvis-brush-panel'); if (!panel) return; var dots = panel.querySelectorAll('.mbp-dot'); for (var i = 0; i < dots.length; i++) { var on = String(dots[i].getAttribute('data-color')).toLowerCase() === String(brushColor).toLowerCase(); dots[i].className = 'mbp-dot' + (on ? ' mbp-dot-on' : ''); } var r = panel.querySelector('.mbp-range'); if (r) r.value = String(brushWidth); var v = panel.querySelector('.mbp-val'); if (v) v.textContent = brushWidth.toFixed(1) + '×'; } /* ---------- 工具 ---------- */ function tis() { return [].slice.call(document.querySelectorAll('.ti')); } // 题目作用域 key：题号（SPA 复用同一 .ti 元素渲染新题时 key 会变化）； // 无题号时退化为 data-question-key（子题兜底） function tiKey(ti) { var i = ti.querySelector('.title-index'); var t = i ? (i.textContent || '').trim() : ''; return t || (ti.getAttribute && ti.getAttribute('data-question-key')) || ''; } // 「题干+选项」区域相对 .ti 顶部的高度 function measureTi(ti) { var qc = ti.querySelector('app-question-choice'); if (!qc) return null; var tiR = ti.getBoundingClientRect(); var r = qc.getBoundingClientRect(); var h = Math.round(r.bottom - tiR.top); return h > 0 ? h : null; } // 锁定目标高度 = 题干+选项区底边相对 .ti 顶部 + DRAFT_BOTTOM_PAD（与 lockDraft 同一口径） function draftTargetHeight(ti) { var h = measureTi(ti); return h ? h + DRAFT_BOTTOM_PAD : null; } /* ---------- ⑧ 资料分析「一拖五」组识别（2026-10-23 实测） ---------- */ // 组 = 含 .materials-container / .questions-anchors 的 .ti；其子题为 // app-ti.question-multiple（无 ti class，旧版完全没覆盖到）。 // v2.9.34：判定按「结构代际」记忆化——110 题里组是极少数，旧版每轮扫描对每个 // .ti 都做两次全子树 querySelector（processTi 一次 + syncFeedback 一次）≈ // 200+ 次/轮的空查；现在同一代际内每题只查一次，结构变化（childList）换代重查。 var structEpoch = 1; function isGroupTi(ti) { if (ti.__mvGEpoch === structEpoch) return ti.__mvGVal === 1; var g = !!(ti.querySelector('.materials-container') || ti.querySelector('.questions-anchors')); ti.__mvGEpoch = structEpoch; ti.__mvGVal = g ? 1 : 0; return g; } function subsOf(group) { return [].slice.call(group.querySelectorAll('app-ti.question-multiple')).filter(function (st) { return typeof st.closest === 'function' && st.closest('.ti') === group; }); } // 元素所属的「题目作用域」：子题优先，否则所在的 .ti（组本身不是作用域） function questionScopeOf(el) { if (!el || typeof el.closest !== 'function') return null; var sub = el.closest('app-ti.question-multiple'); if (sub) return sub; var ti = el.closest('.ti'); return ti && !isGroupTi(ti) ? ti : null; } // 全量作用域列表：组展开为各个子题，普通题即自身 function allScopes() { var out = []; tis().forEach(function (ti) { if (isGroupTi(ti)) subsOf(ti).forEach(function (s) { out.push(s); }); else out.push(ti); }); return out; } // 组的稳定 key：优先子题 data-question-key 的公共前缀（3_1_ijsk5..9 → 3_1_ijsk）， // 退化用材料文本哈希（同一份材料重进后一致）。 // 撞名保护（v2.7.0 修复存量 bug）：题号是三十六进制计数器，相邻两组的公共前缀 // 可能相同（3_1_ijsi4~8 与 3_1_ijsi9~ijsid 前缀都是 3_1_ijsi）——旧版因此让相邻组 // 的材料画布共享同一份 localStorage（笔迹/缩放串组，真机实测复现）。 // 现按文档序先到先得（旧 key 不变、老笔迹不丢），撞名的组追加首道子题完整 key。 function hashText(s) { var h = 2166136261; for (var i = 0; i < s.length; i++) { h ^= s.charCodeAt(i); h = Math.imul(h, 16777619); } return (h >>> 0).toString(36); } var groupKeyClaims = {}; // base → 首道子题 data-question-key（稳定身份） function groupKeyOf(group) { var subs = subsOf(group); var keys = subs.map(function (s) { return s.getAttribute('data-question-key') || ''; }).filter(Boolean); var base = ''; if (keys.length) { var prefix = keys[0].replace(/\d+$/, ''); base = (prefix && keys.every(function (k) { return k.indexOf(prefix) === 0; })) ? prefix : keys[0]; } else { var mc = group.querySelector('.material-content') || group.querySelector('.materials-container'); base = 'h' + hashText((mc && mc.textContent || '').replace(/\s+/g, ' ').slice(0, 400)); var t0 = subs[0] ? (subs[0].querySelector('.title-index') || { textContent: '' }).textContent : ''; var idx = (t0 || '').replace(/[^\w.]/g, ''); if (idx) base += '-' + idx; // 文本哈希也可能撞（空材料）：追加入组内首道子题题号 } var ident = keys[0] || ''; // 组的稳定身份（Angular 重建元素后仍一致） if (ident) { var owner = groupKeyClaims[base]; if (owner && owner !== ident) { base = base + '-' + ident; if (groupKeyClaims[base] && groupKeyClaims[base] !== ident) base += '-' + hashText(ident); } groupKeyClaims[base] = ident; } return base; } /* ---------- ⑨ 性能护栏：视口附近才自动开草稿/建画布 ---------- */ // 110 题全开画布在低配/软件渲染环境 tile 内存超限（实测卡死渲染进程）。 // 只有接近视口的题才做「重活」（开原生草稿 / 建画布）；字母盒与回填保持全量。 function nearViewport(ti) { try { var r = ti.getBoundingClientRect(); var y = window.pageYOffset || document.documentElement.scrollTop || 0; var vh = window.innerHeight || document.documentElement.clientHeight || 0; var top = r.top + y, bottom = r.bottom + y; return bottom > y - vh * NEAR_MARGIN_BELOW && top < y + vh * NEAR_MARGIN_ABOVE; } catch (e) { return true; } } // 修复「退出草稿重开后笔迹被压缩到最上」的根因： // 页面重开草稿时会重建 canvas#draft，并按整个 .ti（含已展开的解析区）高度设置 // 绘图缓冲区（height attribute），而容器 CSS 高度被本脚本锁定为「题干+选项」高度， // 缓冲区高度远大于显示高度 → 笔迹被垂直压缩（实测约 26%）。 // 这里在粉笔设置 canvas.height/width 的瞬间把缓冲区尺寸改写为容器显示尺寸： // 此刻画布刚创建、内容为空，改写不会丢笔迹；之后粉笔重放/书写都落在正确尺寸上， // 显示即 1:1。宽度仅在确实失配时改写（避免无谓触发 canvas 清空）。 function installDraftSizeHook() { var P = window.HTMLCanvasElement && window.HTMLCanvasElement.prototype; if (!P || P.__marvisDraftSizeHooked) return; try { P.__marvisDraftSizeHooked = true; var dW = Object.getOwnPropertyDescriptor(P, 'width'); var dH = Object.getOwnPropertyDescriptor(P, 'height'); function syncSetter(kind) { var d = kind === 'height' ? dH : dW; if (!d || !d.get || !d.set) return null; return function (v) { var target = null; if (this && this.id === 'draft' && typeof this.closest === 'function') { var dc = this.closest('.draft-container'); if (kind === 'height') { var ti = dc && typeof dc.closest === 'function' ? dc.closest('.ti') : null; // 一拖五组的原生草稿会被整体隐藏（见 neutralizeGroupDraft），不锁定其尺寸 target = ti && !isGroupTi(ti) ? draftTargetHeight(ti) : null; } else if (dc) { target = dc.clientWidth || null; } } if (target && Math.abs(target - v) > 1) { d.set.call(this, target); return; } d.set.call(this, v); }; } var setW = syncSetter('width'); var setH = syncSetter('height'); if (setW) { Object.defineProperty(P, 'width', { configurable: true, enumerable: dW.enumerable, get: function () { return dW.get.call(this); }, set: setW }); } if (setH) { Object.defineProperty(P, 'height', { configurable: true, enumerable: dH.enumerable, get: function () { return dH.get.call(this); }, set: setH }); } } catch (e) { /* 拦截失败不影响原有功能 */ } } installDraftSizeHook(); /* ---------- ③ 草稿尺寸锁定 ---------- */ function lockDraft(ti) { var dc = ti.querySelector('.draft-container'); if (!dc) return; var h = measureTi(ti); if (!h) return; var target = (h + DRAFT_BOTTOM_PAD) + 'px'; if (dc.style.getPropertyValue('height') !== target) { dc.style.setProperty('height', target, 'important'); dc.style.setProperty('top', '0px', 'important'); } dc.setAttribute(DLOCK_ATTR, '1'); } /* ---------- ④ 自动打开草稿 ---------- */ function clickDraftTool(ti) { if (ti.querySelector('.draft-container')) return; // 已开 var tool = ti.querySelector('li.draft.tool'); if (tool) tool.click(); } // 自动打开：每题只尝试一次（key = 题号），避免重扫时把用户手动关掉的草稿又打开 function autoOpenDraft(ti) { var key = tiKey(ti); if (ti.getAttribute(AUTO_ATTR) === key) return; ti.setAttribute(AUTO_ATTR, key); clickDraftTool(ti); } // 把目标题目滚动到视口垂直居中位置。 // 题目高度不超过一屏时整题居中；题目高于一屏时改为「顶部保留可见余量」， // 保证题干头部与首行选项不会被顶出屏幕外。 function centerTi(ti) { if (!ti) return; var r = ti.getBoundingClientRect(); var vh = window.innerHeight || document.documentElement.clientHeight; var y = window.pageYOffset || document.documentElement.scrollTop || 0; var target; if (r.height <= vh) { target = y + r.top + r.height / 2 - vh / 2; // 常规题：整题中心对齐视口中心 } else { var pad = Math.min(Math.round(vh / 6), 120); // 超高题：顶部留出约 1/6 屏空白（上限 120px） target = y + r.top - pad; } var maxTop = Math.max(0, (document.documentElement.scrollHeight || 0) - vh); if (target < 0) target = 0; if (target > maxTop) target = maxTop; // 末尾题目滚不到目标位时贴底，避免超界空白 window.scrollTo({ top: Math.round(target), behavior: 'smooth' }); } /* ---------- ①② ABCD 字母盒 + 下一题 ---------- */ /* ⑥ ABCD 点击反馈按钮本身变色 */ function clearFeedback(ti) { var btns = ti.querySelectorAll('.marvis-lbtn'); [].slice.call(btns).forEach(function (b) { b.classList.remove('marvis-feedback-correct', 'marvis-feedback-wrong', 'marvis-feedback-selected'); }); } function applyFeedback(ti, cr) { // 动态索引映射：ti 内 li.choice-radio 顺序 = .marvis-lbox 内 .marvis-lbtn 顺序。 // Angular 判分会重建 li 节点，按钮不随重建丢失，按顺序动态查找即可上色。 var lbox = ti.querySelector('.marvis-lbox'); var radios = [].slice.call(ti.querySelectorAll('li.choice-radio')); var btns = lbox ? [].slice.call(lbox.querySelectorAll('.marvis-lbtn')) : []; function btnOf(li) { var idx = radios.indexOf(li); return idx > -1 ? btns[idx] : null; } var correctEls = ti.querySelectorAll('li.choice-radio div.input-radio.correct, li.choice-radio div.input-radio.correctLost'); var wrongEls = ti.querySelectorAll('li.choice-radio div.input-radio.wrong'); if (correctEls.length > 0 || wrongEls.length > 0) { [].slice.call(correctEls).forEach(function (el) { var btn = btnOf(el.closest('li.choice-radio')); if (btn) btn.classList.add('marvis-feedback-correct'); }); [].slice.call(wrongEls).forEach(function (el) { var btn = btnOf(el.closest('li.choice-radio')); if (btn) btn.classList.add('marvis-feedback-wrong'); }); } else if (cr) { var b = btnOf(cr); if (b) b.classList.add('marvis-feedback-selected'); } } // 单选选中态识别（做题模式）。粉笔选中样式是 input[type=radio]:checked + .input-radio // 的兄弟选择器，选中时 div.input-radio 本身不加 class（页面 CSS 里只有 correct/wrong）， // 理论上 input.checked 是唯一标识；但不同入口（重进恢复）可能走 setAttribute / aria / // class 等路径，这里多信号并取，任一命中即视为已选，避免漏判导致按钮空白。 function isRadioSelected(li) { var inp = li.querySelector('input.option-radio') || li.querySelector('input[type="radio"]'); if (inp) { if (inp.checked) return true; // property（主路径） if (inp.hasAttribute && inp.hasAttribute('checked')) return true; // setAttribute 恢复 if (inp.getAttribute && inp.getAttribute('aria-checked') === 'true') return true; } // class 兜底：只信 div.input-radio / label（页面自身 CSS 从不给这两个加 selected 类， // 一旦出现基本就是状态标记）；li 不查，避免容器级 class 误伤。 var marks = [li.querySelector('div.input-radio'), li.querySelector('label')]; for (var i = 0; i < marks.length; i++) { var el = marks[i]; if (!el || !el.classList) continue; if (el.classList.contains('checked') || el.classList.contains('selected') || el.classList.contains('chosen') || el.classList.contains('active')) return true; if (el.getAttribute && el.getAttribute('aria-checked') === 'true') return true; } return false; } /* ⑦ 按页面既有作答状态回填按钮颜色（重进页面 / 答案异步回填 / Angular 重建选项节点均适用） */ function syncFeedback(ti) { if (!ti || !ti.isConnected) return; if (isGroupTi(ti)) return; // 组不是题目作用域：其子题各自同步（见 allScopes） // 刚点过按钮的题在短时间内交给点击回调着色，避免判分 class 尚未落地时被清空造成闪烁 if (ti.__marvisClickTs && Date.now() - ti.__marvisClickTs < 1200) return; var lbox = ti.querySelector('.marvis-lbox'); if (!lbox) return; var radios = [].slice.call(ti.querySelectorAll('li.choice-radio')); var btns = [].slice.call(lbox.querySelectorAll('.marvis-lbtn')); if (!radios.length || !btns.length) return; var target = {}; var judged = false; // ① 已判分（背题 / 交卷后）：correct、correctLost 上绿，wrong 上红 radios.forEach(function (li, i) { var ir = li.querySelector('div.input-radio'); if (!ir) return; if (ir.classList.contains('correct') || ir.classList.contains('correctLost')) { target[i] = 'marvis-feedback-correct'; judged = true; } else if (ir.classList.contains('wrong')) { target[i] = 'marvis-feedback-wrong'; judged = true; } }); // ② 未判分（做题模式）：选中态走 isRadioSelected 多信号识别 if (!judged) { radios.forEach(function (li, i) { if (isRadioSelected(li)) target[i] = 'marvis-feedback-selected'; }); } // 幂等写入：仅在 class 与目标不一致时改动，避免每次扫描都触发重绘； // v2.9.29：返回是否真的写过 DOM（供启动补偿「无写入即收摊」判定） var wrote = false; btns.forEach(function (b, i) { var want = target[i] || ''; var has = b.classList.contains('marvis-feedback-correct') ? 'marvis-feedback-correct' : b.classList.contains('marvis-feedback-wrong') ? 'marvis-feedback-wrong' : b.classList.contains('marvis-feedback-selected') ? 'marvis-feedback-selected' : ''; if (has === want) return; b.classList.remove('marvis-feedback-correct', 'marvis-feedback-wrong', 'marvis-feedback-selected'); if (want) b.classList.add(want); wrote = true; }); return wrote; } // 同一帧内合并多次同步请求（key 按元素唯一分配，避免子题与普通题题号相撞时互相吞掉） var syncKeySeq = 0; var syncPendingKey = {}; function syncKeyOf(ti) { if (!ti.__marvisSyncKey) ti.__marvisSyncKey = 's' + (++syncKeySeq); return ti.__marvisSyncKey; } function scheduleSync(ti) { if (!ti) return; var key = syncKeyOf(ti); if (syncPendingKey[key]) return; syncPendingKey[key] = true; requestAnimationFrame(function () { syncPendingKey[key] = false; syncFeedback(ti); }); } // 重进页面后作答数据异步回填时，Angular 只对 input.checked 做 property 赋值： // 不新增节点（MutationObserver 观察不到）、也不挂 class，因此 hook setter 精准触发回填。 function installCheckedHook() { var P = window.HTMLInputElement && window.HTMLInputElement.prototype; if (!P || P.__marvisCheckedHooked) return; try { var d = Object.getOwnPropertyDescriptor(P, 'checked'); if (!d || !d.get || !d.set) return; P.__marvisCheckedHooked = true; Object.defineProperty(P, 'checked', { configurable: true, enumerable: d.enumerable, get: function () { return d.get.call(this); }, set: function (v) { d.set.call(this, v); try { if (this.classList && this.classList.contains('option-radio')) { // 子题内的 radio：作用域是子题本身（不是外层组 .ti） var scope = questionScopeOf(this); if (scope) scheduleSync(scope); } } catch (e) {} } }); } catch (e) { /* hook 失败时仍有 change 事件与定时补偿兜底 */ } } installCheckedHook(); // 兜底：用户点选后浏览器会改 checked 且派发 change，捕获阶段统一同步 document.addEventListener('change', function (ev) { var t = ev.target; if (!t || !t.classList || !t.classList.contains('option-radio')) return; var scope = questionScopeOf(t); if (scope) scheduleSync(scope); }, true); // 兜底：页面加载初期 / 重进恢复时作答数据可能晚于按钮注入才落地。 // 早期只一次性补偿到 6s，且恢复若走属性级路径（setAttribute/class/aria）不会被触发，会漏； // 改为前 30s 每秒一次的全量补偿（syncFeedback 幂等，无变化不写 DOM，空转开销可忽略）， // 之后交给 MO 属性监听 / setter hook / change 捕获持续兜底。 // 组要展开成子题同步（组本身不是作用域）。 function syncAllFeedback() { /* v2.9.29：返回是否有任何实际写入（for 而非 forEach：中途短路省不了几次，但布尔聚合要全量走完才算诚实——某些题刚点过被 1200ms 锁定跳过时不算安静） */ var wrote = false; var scopes = allScopes(); for (var i = 0; i < scopes.length; i++) { if (syncFeedback(scopes[i])) wrote = true; } return wrote; } window.__MARVIS_FENBI_SYNC__ = syncAllFeedback; // 控制台手动补偿：__MARVIS_FENBI_SYNC__() setTimeout(syncAllFeedback, 0); var sweepLeft = 30; var sweepQuiet = 0; // 连续无写入的轮数 var sweepTimer = setInterval(function () { /* v2.9.29：连续 5 轮（约 5s）没有任何实际写入就提前收摊——启动期 110 题逐题 querySelector 的空转（~1600 次/秒）正好撞上 Angular 渲染高峰，白烧。恢复动作一旦发生（任一题 class 落地）立即清零计数、补偿继续跑满 30s； setter hook / change 捕获 / MO 属性监听 / pageshow / focus 兜底都在，晚到不漏。 */ if (syncAllFeedback()) sweepQuiet = 0; else if (++sweepQuiet >= 5) { clearInterval(sweepTimer); return; } if (--sweepLeft <= 0) clearInterval(sweepTimer); }, 1000); // 生命周期兜底：bfcache 恢复 / 切回标签页 / 窗口聚焦时立即补偿一次 window.addEventListener('pageshow', syncAllFeedback); document.addEventListener('visibilitychange', function () { if (document.hidden) cvFlushAll(); // ⑧ 离页前把自制画布笔迹落盘 else syncAllFeedback(); }); window.addEventListener('focus', syncAllFeedback); window.addEventListener('pagehide', cvFlushAll); function buildBox(ti) { /* v2.9.35：快路径——缓存的盒子还挂在 .title-left 上、同题同版本就跳过 3 次子树查询中的 2 次；页面摘走/搬走盒子（isConnected/父子校验失效）或换题（key 变）时自动落回慢路径重建。 */ var cached = ti.__mvBoxEl; if (cached && cached.isConnected && cached.parentElement && cached.parentElement.classList.contains('title-left')) { var ck = tiKey(ti); if (ck && cached.getAttribute(BOX_ATTR) === ck && cached.getAttribute(BOXVER_ATTR) === BOX_VER) return; } var tl = ti.querySelector('.title-left'); if (!tl) return; var key = tiKey(ti); var old = tl.querySelector('.marvis-lbox'); if (old) { // 同一题且结构版本一致才跳过；版本戳变化（脚本升级）时强制重建， // 例如 v2.3.0 起「下一题」要支持组内子题推进，旧盒子的闭包 handler 必须换掉。 if (old.getAttribute(BOX_ATTR) === key && old.getAttribute(BOXVER_ATTR) === BOX_VER) { ti.__mvBoxEl = old; return; } clearFeedback(ti); // 旧反馈 class 不残留到新题 old.remove(); // 元素复用渲染新题，重建 } var box = document.createElement('div'); ti.__mvBoxEl = box; // v2.9.35：快路径登记（换代/被摘自动失效） box.className = 'marvis-lbox'; box.setAttribute(BOX_ATTR, key); box.setAttribute(BOXVER_ATTR, BOX_VER); var radios = [].slice.call(ti.querySelectorAll('li.choice-radio')); var letters = ['A', 'B', 'C', 'D']; radios.forEach(function (cr, i) { var letter = letters[i]; if (!letter) return; var b = document.createElement('button'); b.type = 'button'; b.className = 'marvis-lbtn'; b.setAttribute('data-letter', letter); b.textContent = letter; cr.__marvisBtn = b; // 兼容旧引用；判分重建后新 li 无此属性，上色以 applyFeedback 动态索引为准 b.addEventListener('click', function (ev) { ev.preventDefault(); ev.stopPropagation(); ti.__marvisClickTs = Date.now(); // 短暂锁定：此期间同步逻辑不覆盖点击着色 clearFeedback(ti); // 先清旧反馈 // Angular 判分会重建 li.choice-radio，闭包旧 cr 会失效； // 点击时按 ti 内 li 顺序动态取与按钮同序的当前 li，再取 label 触发原生判分 var liNow = [].slice.call(ti.querySelectorAll('li.choice-radio'))[i] || cr; var lab = liNow.querySelector('label.choice-radio-label') || liNow.querySelector('label'); // v2.7.9：锁定态（可触摸）下合成 click 走放行计数，否则会被自己的点击过滤器吃掉 // v2.9.12：分栏模式下还要过 appShieldClick 那关 → 两层放行一起开 if (lab) appAllowOnce(function () { fpAllowOnce(function () { lab.click(); }); }); // 触发原生选项选择 setTimeout(function () { applyFeedback(ti, liNow); }, 250); // 等原生对错 class 落地后着色 }); box.appendChild(b); }); /* v2.9.11：资料分析组内的子题不再要「下一题」—— 五题本来就堆在同一栏里靠滚动翻，这个按钮只是噪音（用户明确要求去掉）。普通单选题照旧保留（跳下一题是常用操作）。 */ var gti = (typeof ti.closest === 'function') ? ti.closest('.ti') : null; if (gti && isGroupTi(gti)) { tl.appendChild(box); return; } var nb = document.createElement('button'); nb.type = 'button'; nb.className = 'marvis-next'; nb.textContent = '下一题'; nb.addEventListener('click', function (ev) { ev.preventDefault(); ev.stopPropagation(); fpExit(); // v2.7.9：换题即退出整页草稿（新题自己再决定要不要写） // 组内推进要合成点 tab，同样走放行计数（否则被锁定态的点击过滤器吃掉） fpAllowOnce(function () { goNextFrom(ti); }); }); box.appendChild(nb); tl.appendChild(box); // 追加到 .title-left 末尾，避免负 left 被父级 overflow 裁切 } /* ---------- ⑧ 组内导航：tab 工具与容器滚动 ---------- */ // 实测：tab 是 app-expand 内 .tabs-content > a.tab#nav0..4，与子题一一对应； // 点击只切 active 类、不滚动 questions-container（滚动需自行处理）。 function groupTabs(group) { return [].slice.call(group.querySelectorAll('.tabs-content a.tab')); } function activateGroupTab(group, idx) { var tabs = groupTabs(group); if (tabs.length === subsOf(group).length && tabs[idx]) { tabs[idx].click(); return true; } return false; } // 把子题滚进 questions-container 可视区（顶部对齐留 12px；超高子题同样适用） function ensureSubVisible(group, sub) { try { var qc = group.querySelector('.questions-container'); if (!qc) return; var qcr = qc.getBoundingClientRect(); var r = sub.getBoundingClientRect(); var delta = r.top - qcr.top - 12; if (delta < 0 || r.bottom > qcr.bottom - 8) { qc.scrollTop = Math.max(0, qc.scrollTop + delta); } } catch (e) {} } // 「下一题」统一入口：子题优先推进组内下一个 tab（组末才进下一道 .ti）； // 进入组时复位到第一个子题；普通题保持原行为（滚动居中 + 强制开草稿）。 function goNextFrom(scope) { var group = scope && typeof scope.closest === 'function' ? scope.closest('.ti') : null; var inGroup = group && isGroupTi(group); if (inGroup) { var subs = subsOf(group); var i = subs.indexOf(scope); if (i > -1 && i < subs.length - 1) { activateGroupTab(group, i + 1); if (group.getAttribute(FLAT_ATTR) === '1') centerTi(subs[i + 1]); // 展平：页面滚动 else ensureSubVisible(group, subs[i + 1]); // 原生：容器滚动 return; } } var all = tis(); var idx = all.indexOf(inGroup ? group : scope); var next = idx > -1 ? all[idx + 1] : null; if (!next) return; centerTi(next); if (isGroupTi(next)) activateGroupTab(next, 0); // 进入组时从第一个子题开始 processTi(next, { force: true, sync: true }); // 草稿/画布立即就位（不等滚动扫描） if (!isGroupTi(next)) { clickDraftTool(next); // 用户主动：强制打开原生草稿 setTimeout(function () { lockDraft(next); }, 450); } } // 组级原生草稿：absolute top:0 覆盖整个 .ti（含材料与 tab 栏），吃掉全部指针事件， // 是「一拖五草稿不可用」的直接原因；粉笔重载还会自动恢复打开，故每次扫描都压制。 // 实测 display:none 无副作用（不影响 tab 切换与页面其它交互）。 function neutralizeGroupDraft(group) { // v2.8.12：标记「这一组由我们的整页草稿接管」——会话期间据此让组内原生草稿 // 画布彻底收不到指针事件（见 fpQuietOn）。 try { group.setAttribute(FPGRP_ATTR, '1'); } catch (e) {} [].slice.call(group.children).forEach(function (ch) { if (!ch.classList || !ch.classList.contains('draft-container')) return; if (ch.getAttribute(HIDE_ATTR) === '1') return; ch.style.setProperty('display', 'none', 'important'); ch.setAttribute(HIDE_ATTR, '1'); }); } /* ---------- ⑪ 一拖五「解锁盒子」（v2.6.x，按用户澄清迭代） ---------- */ // 需求本源：盒子高度被写死 70vh（.resizable-container / .nz-resizable.left 内联 height:70vh）， // 5 道子题只能在盒子内滚动翻题。要的不是打散重组，而是**把盒子做高**： // - 保持左右两栏（材料在左、题目在右，双双向下延伸，页面整体滚动）； // - 全部高度锁（70vh）解锁 → height auto；questions-container overflow visible； // - 两栏宽度一个不动（左栏 615px 定宽保留、分隔条保留仍可拖宽材料栏）； // - tab 栏隐藏（整列延伸后无意义）；子题逐层解锁宽度（relaxEl，原始 style // 存 data-marvis-relax 供还原）；通用兜底 expandScrollBoxes 解除任何残留内滚盒子； // - 材料共享画布保留、子题画布照常、「下一题」组内推进 = 页面滚动到下一子题。 // 子题节点原地不动（Angular 无感）；每次扫描幂等重断言（MO 兜底粉笔重渲染）。 // 默认开启；控制台 __MARVIS_FENBI_FLATTEN__() 切换（持久化），关掉回原生分栏。 // v2.6.1：开关状态换新 key（旧 key 可能被逃生门持久化成 '0' 导致"改了没效果"）； // 页面右下角加可见状态胶囊（展开开/关/失败 · 版本号，点按即切换）， // 展开异常时胶囊变红并在控制台给出原因；__MARVIS_FENBI_DIAG__() 输出结构自检。 // v2.6.3：解锁范围扩展到组的祖先滚动壳（整页外层 overflow 滚动壳不解锁的话， // 组内撑开了仍被外层兜住——「依然没有向下延伸」的根因）；body/html overflow // hidden 时显式放开；DIAG 增加祖先壳链路信息。 var FLAT_ATTR = 'data-marvis-flat'; var FLAT_BOX = 'data-marvis-flatbox'; // v2.6.1：换新 key——旧 key 可能因用户跑过逃生门 __MARVIS_FENBI_FLATTEN__(false) // 被持久化成 '0'，导致每次打开都是原生分栏（这正是「改了没效果」的真凶）。 var FLAT_LS = 'marvis-fb-flatten2'; var FLAT_LS_OLD = 'marvis-fb-flatten'; lsRemove(FLAT_LS_OLD); // 一次性清掉旧 key function flattenEnabled() { return lsGet(FLAT_LS) !== '0'; } // 通用兜底：组内任何仍有内滚的盒子（overflow auto/scroll 且内容超高）一律解除 // 限制、整页向下拓展——不依赖白名单，粉笔改版多套一层容器也能展开。 // 计算样式判定天然幂等（展开后 overflowY=visible 不再命中）；每次扫描都跑，代价 O(组内节点数)。 function expandScrollBoxes(group) { var els = [group].concat([].slice.call(group.querySelectorAll('*'))); for (var i = 0; i < els.length; i++) { var el = els[i]; if (el.tagName === 'CANVAS') continue; // 画布 absolute 覆盖，永远不滚 if (el.hasAttribute(STICKY_ATTR)) continue; // 吸顶左栏：overflow/高度是吸顶机制的一部分，不能解锁 // v2.9.26：先比滚动尺寸（布局缓存值，便宜）再取计算样式—— // 组内几百个节点，逐个 getComputedStyle 是每次扫描的大头； // 判定逻辑与原来等价：可滚(overflow auto/scroll) 且内容超高才解锁。 try { if (el.scrollHeight <= el.clientHeight + 2) continue; } catch (e) { continue; } var cs = null; try { cs = getComputedStyle(el); } catch (e) {} var oy = (cs && cs.overflowY) ? cs.overflowY : el.style.overflowY; if (oy === 'auto' || oy === 'scroll') { el.style.overflowY = 'visible'; el.style.height = 'auto'; el.style.maxHeight = 'none'; el.setAttribute(FLAT_BOX, '1'); } } } // v2.6.3 关键补漏：组外面的祖先滚动容器也要解锁——70vh 盒子只在组内， // 整个题目列表外层很可能还有一层 overflow:auto/hidden 的滚动壳（截图里贯穿全屏的 // 滚动条就是它）；只展开组内的话内容撑开了还是被外层壳兜住，用户看到的仍是"没延伸"。 // 祖先链逐层上溯到 body：内容真实超高（scrollHeight > clientHeight）才解锁， // 记入 flatAncestors 供关展平还原；body/html 只修 overflow（hidden→auto），不动高度。 var flatAncestors = []; function unlockScroller(el) { if (!el || !el.style || el.tagName === 'CANVAS') return; if (el.hasAttribute(FLAT_BOX)) return; var cs = null; try { cs = getComputedStyle(el); } catch (e) {} var oy = (cs && cs.overflowY) ? cs.overflowY : el.style.overflowY; if ((oy === 'auto' || oy === 'scroll' || oy === 'hidden') && el.scrollHeight > el.clientHeight + 2) { if (!el.hasAttribute(RELAX_ATTR)) el.setAttribute(RELAX_ATTR, el.getAttribute('style') || ''); el.style.setProperty('overflow-y', 'visible', 'important'); el.style.setProperty('height', 'auto', 'important'); el.style.setProperty('max-height', 'none', 'important'); el.setAttribute(FLAT_BOX, '1'); if (flatAncestors.indexOf(el) === -1) flatAncestors.push(el); } } function expandAncestorBoxes(group) { var el = group.parentElement; while (el && el !== document.body && el !== document.documentElement) { unlockScroller(el); el = el.parentElement; } // 顶层兜底：SPA 常把 body/html 设 overflow:hidden、改用内层滚动壳—— // 内层解锁后若 body 不能滚，页面会整页卡死，这里显式放开 [document.body, document.documentElement].forEach(function (el) { if (!el) return; var cs = null; try { cs = getComputedStyle(el); } catch (e) {} if (cs && cs.overflowY === 'hidden') el.style.setProperty('overflow-y', 'auto', 'important'); }); } // 逐层解锁布局：记下原始 style（data-marvis-relax）供关展平精确还原，然后： // 宽度/max-width 100%、min-width 0、left/right auto、margin/float 归零、transform none； // absolute/fixed 转 relative（脱离分栏偏移锚定，同时保住绝对定位子元素的包含块）。 var RELAX_ATTR = 'data-marvis-relax'; function relaxEl(el, keepPosition) { if (!el || !el.style) return; var first = !el.hasAttribute(RELAX_ATTR); if (first) el.setAttribute(RELAX_ATTR, el.getAttribute('style') || ''); el.style.setProperty('width', '100%', 'important'); el.style.setProperty('max-width', '100%', 'important'); el.style.setProperty('min-width', '0', 'important'); el.style.setProperty('left', 'auto', 'important'); el.style.setProperty('right', 'auto', 'important'); el.style.setProperty('margin-left', '0', 'important'); el.style.setProperty('margin-right', '0', 'important'); el.style.setProperty('float', 'none', 'important'); el.style.setProperty('box-sizing', 'border-box', 'important'); el.style.setProperty('transform', 'none', 'important'); if (first && !keepPosition) { var cs = null; try { cs = getComputedStyle(el); } catch (e) {} if (cs && (cs.position === 'absolute' || cs.position === 'fixed')) { el.style.setProperty('position', 'relative', 'important'); } } } // 高度解锁：盒子高度锁（70vh 等）→ auto（含 max-height），记 style 供还原 function relaxHeight(el) { if (!el || !el.style) return; if (!el.hasAttribute(RELAX_ATTR)) el.setAttribute(RELAX_ATTR, el.getAttribute('style') || ''); el.style.setProperty('height', 'auto', 'important'); el.style.setProperty('max-height', 'none', 'important'); } // 子题内容层拉满整宽（只解锁祖先链，不动题意/选项自身的内联样式） function relaxSubLayout(sub) { relaxEl(sub, true); sub.style.setProperty('display', 'block', 'important'); var probe = sub.querySelector('app-question-choice') || sub.querySelector('.ti-container') || sub.firstElementChild; var el = probe; while (el && el !== sub) { relaxEl(el); el = el.parentElement; } } // v2.7.1 左栏吸顶（两栏延伸形态）：滚动右侧小题时材料始终钉在左侧完整可见， // 滚过组内最后一题（.resizable-container 底边过去）后自然释放、随页面滚走。 // 三个要点： // ① align-self:flex-start——resizable-container 默认 align-items:stretch // 会把左栏拉到右栏题目等高，sticky 就没有行程可走； // ② max-height 收进视口（扣除固定页头），装不下时栏内 overflow-y:auto 自滚； // ③ 每次扫描重断言（Angular 重渲染会重置左栏行内样式）。 var STICKY_ATTR = 'data-marvis-sticky'; var stickyTopOff = 0; function stickyTopOffset() { if (stickyTopOff) return stickyTopOff; var off = 8; // 没有固定页头时的回退 /* v2.9.39：先查候选，不再一上来就遍历 document.querySelectorAll('body *')。 110 题的页面轻松上万节点，逐个 getComputedStyle 是纯浪费；而转屏会把 stickyTopOff 清掉（见下面的 resize 监听），平板每转一次就重走一遍全 DOM。候选命中即止；一个都不中才退回原来的全量遍历（保证正确性不受影响）。 */ var found = false; try { var cands = document.querySelectorAll( 'header, [class*="header"], [class*="Header"], [class*="navbar"], ' + '[class*="topbar"], [class*="top-bar"], [class*="fixed-top"], [class*="fixedTop"]'); for (var c = 0; c < cands.length && c < 60; c++) { var cel = cands[c]; if (!cel || !cel.tagName || cel.tagName === 'CANVAS') continue; var ccs = getComputedStyle(cel); if (ccs.position !== 'fixed' && ccs.position !== 'sticky') continue; var cr = cel.getBoundingClientRect(); if (cr.top < 4 && cr.height >= 20 && cr.height <= 240 && cr.width > 300) { off = Math.round(cr.height) + 8; found = true; break; } } } catch (e0) {} if (!found) { try { var els = document.querySelectorAll('body *'); for (var i = 0; i < els.length; i++) { var el = els[i]; if (!el || !el.tagName) continue; var cs = getComputedStyle(el); if (cs.position === 'fixed') { var r = el.getBoundingClientRect(); if (r.top < 4 && r.height >= 20 && r.height <= 240 && r.width > 300) { off = Math.round(r.height) + 8; break; } } } } catch (e) {} } stickyTopOff = off; return off; } function stickLeftCol(group) { var left = group.querySelector('.nz-resizable.left') || group.querySelector('.left'); if (!left || !left.style) return; var top = stickyTopOffset(); left.style.setProperty('position', 'sticky', 'important'); left.style.setProperty('top', top + 'px', 'important'); left.style.setProperty('align-self', 'flex-start', 'important'); left.style.setProperty('max-height', 'calc(100vh - ' + (top + 8) + 'px)', 'important'); left.style.setProperty('overflow-x', 'hidden', 'important'); left.style.setProperty('overflow-y', 'auto', 'important'); left.setAttribute(STICKY_ATTR, '1'); // 打断 flex 拉伸链（v2.7.1 实测修复）：栏被 max-height 收进视口后，若链条继续 // align-items:stretch，每层都被拉成栏高——材料多出的部分被 .left-section 的 // overflow:hidden 裁掉，且栏内滚动失效（scrollHeight 被锁成栏高：实测材料 // 901px 只露出 776px、scrollTop 置 300 也弹回 0）。让链上各层按内容高度排 // （flex:0 0 auto），溢出统一交给栏内 overflow-y:auto。 // 原始 style 记 RELAX_ATTR，关展平时随还原链路一起恢复。 ['.left-section', '.left-part', 'app-materials', '.materials-container', '.material-body'].forEach(function (sel) { var el = group.querySelector(sel); if (!el || !el.style) return; if (!el.hasAttribute(RELAX_ATTR)) el.setAttribute(RELAX_ATTR, el.getAttribute('style') || ''); el.style.setProperty('align-self', 'flex-start', 'important'); el.style.setProperty('flex', '0 0 auto', 'important'); // v2.7.2 修复（真机实测定位）：flex-basis:auto + align-self:flex-start 会让链上 // 各层按内容的 max-content 宽度排布——材料文字 max-content 1664px 时整条链被撑到 // 1704px，而左栏只有 996px，overflow-x:hidden 把右半全部裁掉：文字被横切、 // 表格/图片被横切（用户报「图片显示不全、文字也显示不全」）。显式 width 压住 // max-content：横向恒等栏宽（拖分隔条/适应收窄时跟随重排），纵向仍靠 // flex:0 0 auto 按内容高度流式排布（拉伸链修复不受影响）。 // 宿主 .materials-container 是 cvZoomApply 的缩放对象：宽度恒 100%—— // v2.7.6 实测：zoom 坐标系里 width:100% 的视觉宽本就等于栏宽（百分比在 // 元素自身坐标系解析），补偿 100/s% 反而溢出 (1/s-1)×栏宽被裁。 // 宿主缩放时 stickLeftCol 不得按 zoom 改宽度，只保留 100%。 el.style.setProperty('width', '100%'); el.style.setProperty('min-width', '0', 'important'); el.style.setProperty('box-sizing', 'border-box', 'important'); }); } try { window.addEventListener('resize', function () { stickyTopOff = 0; }); } catch (e) {} function flattenGroup(group) { /* v2.9.39：幂等快路径 —— 结构代际没变、展平标记还在、左栏吸顶哨兵还在，就整段跳过。旧版每轮扫描都重写约 180 个 setProperty（stickLeftCol 26 次 + relaxSubLayout 每个子题约 30 次）+ 遍历组内全部后代读 scrollHeight （首次读就强制整组重排），MO 突发时每秒最多三轮，全在空转。哨兵检查本身就覆盖「Angular 重渲染把行内样式冲掉」：样式一被重置， position/overflow 就不对 → 自动落回慢路径重新断言，行为不变。 */ if (group.getAttribute(FLAT_ATTR) === '1' && group.__mvFlatEpoch === structEpoch) { var lchk = group.querySelector('.nz-resizable.left') || group.querySelector('.left'); if (lchk && lchk.style && lchk.style.position === 'sticky' && lchk.style.overflowY === 'auto' && lchk.getAttribute(STICKY_ATTR) === '1') { return; } } if (group.getAttribute(FLAT_ATTR) !== '1') { relaxEl(group); relaxHeight(group); // 分栏骨架：只解锁高度——两栏布局原样保留（材料在左向下延伸、题目在右向下延伸， // 页面整体滚动）；宽度一个不动（左栏 615px 定宽、分隔条都还能拖）。 // 例外：某层若是 absolute/fixed 定位（分栏偏移锚定），才连带解锁宽度与偏移。 function relaxCol(el) { if (!el) return; relaxHeight(el); var cs = null; try { cs = getComputedStyle(el); } catch (e) {} if (cs && (cs.position === 'absolute' || cs.position === 'fixed')) relaxEl(el); } relaxCol(group.querySelector('.resizable-container')); relaxCol(group.querySelector('app-resizable')); ['.nz-resizable.left', '.left', '.left-section', '.left-part', 'app-materials'].forEach(function (sel) { relaxCol(group.querySelector(sel)); }); var mat = group.querySelector('.materials-container'); if (mat) relaxHeight(mat); var mb = group.querySelector('.material-body'); if (mb) relaxHeight(mb); ['.right', '.right-section', '.right-part'].forEach(function (sel) { relaxCol(group.querySelector(sel)); }); var qc = group.querySelector('.questions-container'); if (qc) { relaxCol(qc); qc.style.setProperty('overflow', 'visible', 'important'); } // tab 栏隐藏（整列延伸后无意义）；分隔条保留（仍可拖宽材料栏） var anchors = group.querySelector('.questions-anchors'); if (anchors) anchors.style.setProperty('display', 'none', 'important'); [].slice.call(group.querySelectorAll('a.label-tab')).forEach(function (el) { el.style.setProperty('display', 'none', 'important'); }); group.setAttribute(FLAT_ATTR, '1'); } // 左栏吸顶（幂等重断言： Angular 重渲染会重置左栏行内样式） stickLeftCol(group); // 子题逐层解锁宽度（幂等；重渲染后 Angular 可能重置，扫描时重断言） subsOf(group).forEach(relaxSubLayout); // 材料大图/表格不超出所在栏 [].slice.call(group.querySelectorAll('.material-body img, .material-body table')).forEach(function (el) { el.style.setProperty('max-width', '100%', 'important'); }); expandScrollBoxes(group); expandAncestorBoxes(group); // 组外的祖先滚动壳同样解锁（v2.6.3 关键补漏） group.__mvFlatEpoch = structEpoch; // v2.9.39：登记本轮已断言完，同代际直接跳过 } // 关闭展平（控制台切换）：还原内联样式（relax 记录的原始 style 优先，最后写回） function unflattenGroup(group) { if (group.getAttribute(FLAT_ATTR) !== '1') return; [].slice.call(group.querySelectorAll('[' + STICKY_ATTR + ']')).forEach(function (el) { el.removeAttribute(STICKY_ATTR); // 行内样式由下方 RELAX_ATTR 还原链路恢复 }); ['.nz-resizable-handle', '.nz-resize-handle', '.questions-anchors'].forEach(function (sel) { var el = group.querySelector(sel); if (el) el.style.display = ''; }); [].slice.call(group.querySelectorAll('a.label-tab')).forEach(function (el) { el.style.display = ''; }); [].slice.call(group.querySelectorAll('[' + FLAT_BOX + ']')).forEach(function (el) { el.style.overflowY = ''; el.style.height = ''; el.style.maxHeight = ''; el.removeAttribute(FLAT_BOX); }); // 还原组外被解锁的祖先滚动壳（v2.6.3） flatAncestors.forEach(function (el) { if (!el || !el.isConnected) return; var saved = el.getAttribute(RELAX_ATTR); el.setAttribute('style', saved || ''); if (!saved) el.removeAttribute('style'); el.removeAttribute(FLAT_BOX); el.removeAttribute(RELAX_ATTR); }); flatAncestors.length = 0; var relaxed = [group].concat([].slice.call(group.querySelectorAll('[' + RELAX_ATTR + ']'))); relaxed.forEach(function (el) { var saved = el.getAttribute(RELAX_ATTR); el.setAttribute('style', saved || ''); if (!saved) el.removeAttribute('style'); el.removeAttribute(RELAX_ATTR); }); group.removeAttribute(FLAT_ATTR); } /* ---------- ⑧ B2 自制画布：材料草稿 + 子题草稿 ---------- */ // 为什么自制：粉笔 web 端材料区没有草稿入口；子题的 li.draft.tool 实测点击无效 // （草稿由组级托管，且组级草稿会覆盖全组）。因此材料与每个子题各挂一个自制画布： // - absolute 覆盖宿主（材料=整个材料区；子题=题干+选项区），z-index 130 与原生草稿同级， // 字母盒 260 / 工具条 140 仍在其上； // - 模式两档循环：演算（手/笔皆可写）↔ 穿透（画布不挡指针）； // - 笔迹按归一化坐标（0~1）存 localStorage，退出重进自动重放，容器尺寸变化不失真； // - 笔画用 arc 逐点画圆（与粉笔同款渲染路径），笔色/粗细走⑤笔刷 hook（class 含 pen）。 var CV_LS_PREFIX = 'marvis-fb-cv-'; var CV_MAX_STROKES = 300; // 单画布笔画数上限（超出丢最旧） var CV_MAX_POINTS = 1200; // 单笔画点数上限 var CV_MAX_BYTES = 200000; // 单 key 存储上限（约 200KB） var CV_LS_BUDGET = 3600000; // v2.9.26：全部画布 key 的字符预算（约 3.6MB）， // 逼近 localStorage 5MB 配额前就开始 LRU 淘汰 var CV_ZOOM_MIN = 0.55; // 材料自适应缩小的可读性下限 // （材料含被栏宽钳制的图片/表格时 zoom 缩不动媒体， // 收窄也装不下就缩到下限、剩余滚动查看） var CV_MODES = ['draw', 'pass']; // 演算(全写，默认) ↔ 穿透，点按循环 var cvRegistry = []; // 所有存活画布（pagehide 时统一落盘） var cvSaveTimers = {}; var cvStorageOk = true; function cvLoad(key) { try { var raw = lsGet(CV_LS_PREFIX + key); if (!raw) return null; var d = JSON.parse(raw); return d && Array.isArray(d.strokes) ? d : null; } catch (e) { return null; } } /* v2.9.26：LRU 淘汰——每个 key 的 payload 带 t（写入时间戳）。要写入但没配额 / 总量超预算时，删掉最旧的画布 key 腾地方，而不是像旧版那样一爆配额就整个会话都不再落盘（所有题一起失忆）。 */ function cvEvictLRU(keepKey) { var entries = []; try { for (var i = 0; i < localStorage.length; i++) { var k = localStorage.key(i); if (!k || k.indexOf(CV_LS_PREFIX) !== 0) continue; if (k === CV_LS_PREFIX + keepKey) continue; var t = 0; try { t = (JSON.parse(localStorage.getItem(k)) || {}).t || 0; } catch (e) {} entries.push({ k: k, t: t, len: (localStorage.getItem(k) || '').length }); } } catch (e) { return 0; } if (!entries.length) return 0; entries.sort(function (a, b) { return a.t - b.t; }); // 最旧在前 var freed = 0; for (var j = 0; j < entries.length; j++) { lsRemove(entries[j].k); cvLedgerDrop(entries[j].k.slice(CV_LS_PREFIX.length)); // v2.9.40：同步下账 freed += entries[j].len; if (freed > 600000) break; // 一次清 600KB 足够本次写入 } return freed; } /* v2.9.40：localStorage 字量内存记账 —— 旧版 cvLsUsage 每 10s 全量读一遍所有画布 payload 字符串来算总字节（5MB 级同步 I/O，快写落盘时正好撞上）。改为：写入/删除时增量维护 key→字节数，预算检查直接用账本（零 I/O）；每 60s 才做一次全量对账，兜住多标签页互写 / 旧版残留 / 手动改存储带来的漂移。 zoom-/fitw- 偏好键个位数字节：不计入账本（没有写/删路径），对账总量仍含它们，漂移由下一次对账校准。 */ var cvLedger = { keys: {}, total: 0, syncAt: 0 }; // key（无前缀）→ 最近一次落盘 payload 长度 function cvLedgerNote(key, len) { var prev = cvLedger.keys[key]; if (prev === len) return; cvLedger.keys[key] = len; cvLedger.total += len - (prev || 0); } function cvLedgerDrop(key) { var prev = cvLedger.keys[key]; if (prev === undefined) return; cvLedger.total -= prev; delete cvLedger.keys[key]; } function cvLsUsage() { var now = Date.now(); if (now - cvLedger.syncAt < 60000) return cvLedger.total; // 平时零 I/O cvLedger.syncAt = now; var t = 0, seen = {}; try { for (var i = 0; i < localStorage.length; i++) { var k = localStorage.key(i); if (!k || k.indexOf(CV_LS_PREFIX) !== 0) continue; var len = (localStorage.getItem(k) || '').length; t += len; var short = k.slice(CV_LS_PREFIX.length); if (short.indexOf('zoom-') === 0 || short.indexOf('fitw-') === 0) continue; seen[short] = len; } } catch (e) {} cvLedger.keys = seen; cvLedger.total = t; return t; } var cvBudgetCheckAt = 0; function cvBudgetEvictIfNeeded(key, payloadLen) { // v2.9.40：用量走内存账本（60s 对账一次），这里保留 10s 节流作写放大护栏—— // 真爆配额仍由 cvSave 里的 lsSet 失败路径被动淘汰兜底 var now = Date.now(); if (now - cvBudgetCheckAt < 10000) return; cvBudgetCheckAt = now; if (cvLsUsage() + payloadLen > CV_LS_BUDGET) cvEvictLRU(key); } // 笔画统一用归一化坐标 [x, y]（0~1，相对画布尺寸）存储，分辨率无关 function cvCap(strokes) { var out = strokes.slice(-CV_MAX_STROKES); for (var i = 0; i < out.length; i++) { if (out[i] && out[i].length > CV_MAX_POINTS) out[i] = out[i].slice(-CV_MAX_POINTS); } return out; } // v2.7.8：清洗笔迹——旧版 fpFinish 的坐标 bug（把 [x,y] 数组当对象读）会往存储里 // 写一堆 null；这些 null 再被 fpMigrate 迁移会压成同一个常量点（整笔退化成一个点， // 画出来什么都没有）。加载时直接丢弃「非法点」和「所有点重合」的坏笔。 function cvSanitize(strokes) { var out = []; for (var i = 0; i < strokes.length; i++) { var s = strokes[i]; /* v2.9.32：橡皮笔程照单清洗（单点也算——点擦是合法操作） */ if (s && s.e && s.pts) { var eps = []; for (var j = 0; j < s.pts.length; j++) { var q = s.pts[j]; if (!q || q.length < 2) continue; var qx = +q[0], qy = +q[1]; if (!isFinite(qx) || !isFinite(qy)) continue; eps.push([qx, qy]); } if (eps.length) out.push({ e: 1, r: isFinite(+s.r) ? +s.r : 0, pts: eps }); continue; } if (!s || !s.length) continue; var pts = []; for (var j = 0; j < s.length; j++) { var p = s[j]; if (!p || p.length < 2) continue; var x = +p[0], y = +p[1]; if (!isFinite(x) || !isFinite(y)) continue; pts.push([x, y]); } if (pts.length < 2) continue; // 单点笔迹不算笔（tap 本来就不落笔） var degenerate = true; for (var k = 1; k < pts.length; k++) { if (Math.abs(pts[k][0] - pts[0][0]) > 1e-6 || Math.abs(pts[k][1] - pts[0][1]) > 1e-6) { degenerate = false; break; } } if (!degenerate) out.push(pts); } return out; } function cvSave(key, strokes, mode, coordVer) { if (!cvStorageOk) return; try { // v2.7.8：v=2 表示「视口归一化坐标」（整页草稿层）；v=1 是旧版题目框坐标。 // 记录版本是为了让刷新后的新 cv 知道笔迹已迁移过——否则每次重开都会把 // 视口坐标当框坐标再迁移一次，笔迹越跑越偏（真机 E2E 实测：刷新后重开 // 笔迹数据还在但画到视口外、看不见）。 var ver = coordVer === 2 ? 2 : 1; var capped = cvCap(strokes); var payload = JSON.stringify({ v: ver, t: Date.now(), mode: mode || 'draw', strokes: capped }); if (payload.length > CV_MAX_BYTES) { payload = JSON.stringify({ v: ver, t: Date.now(), mode: mode || 'draw', strokes: capped.slice(-40) }); } // v2.9.26：定期看总量预算，超了就先淘汰最旧的再写 cvBudgetEvictIfNeeded(key, payload.length); var ok = lsSet(CV_LS_PREFIX + key, payload); if (!ok) { // 配额溢出：淘汰最旧的画布 key 腾地方，重试一次；仍失败才放弃本 key cvEvictLRU(key); ok = lsSet(CV_LS_PREFIX + key, payload); if (!ok) { // 连淘汰都救不了（隐私模式 / 存储整体不可用）：本会话不再落盘（内存笔迹不受影响） cvStorageOk = false; } } if (ok) cvLedgerNote(key, payload.length); // v2.9.40：成功落盘才记账 } catch (e) { cvStorageOk = false; } } function cvScheduleSave(cv) { var key = cv.key; if (cvSaveTimers[key]) clearTimeout(cvSaveTimers[key]); cvSaveTimers[key] = setTimeout(function () { cvSaveTimers[key] = 0; cvSave(key, cv.strokes, cv.mode, cv.coordVer); }, 500); } function cvFlushAll() { Object.keys(cvSaveTimers).forEach(function (k) { if (cvSaveTimers[k]) { clearTimeout(cvSaveTimers[k]); cvSaveTimers[k] = 0; } }); cvRegistry.forEach(function (cv) { cvSave(cv.key, cv.strokes, cv.mode, cv.coordVer); }); } /* v2.9.40：一笔之内画布矩形不变。pointermove 的合并采样批循环里逐子事件各调一次 getBoundingClientRect（快写时一帧 10+ 次）是纯浪费 → 支持传入循环外量好的 rect；单点调用（pointerdown 等）不传 rect，行为不变。批循环同步执行、中间无布局改动，缓存一个批次严格安全。 */ function penPoint(canvas, e, rect) { var r = rect || canvas.getBoundingClientRect(); var sx = r.width ? canvas.width / r.width : 1; var sy = r.height ? canvas.height / r.height : 1; return { x: (e.clientX - r.left) * sx, y: (e.clientY - r.top) * sy }; } // 平板 / 触控笔快速书写时，浏览器会把一次笔程里的多个点合并进同一个 pointermove // 事件（coalesced events）。若只取 e.clientX/Y 就会丢掉中间点 → 采样过稀 → // 曲线被近似成折线、圆圈变成多边形（典型「画不了弧线」症状）。展开被合并的 // 中间点，笔迹才平滑。无该 API 的环境（旧 Safari 等）回退到单点，行为不变。 function penCoalesce(e) { try { if (typeof e.getCoalescedEvents === 'function') { var list = e.getCoalescedEvents(); if (list && list.length) return list; } } catch (err) {} return [e]; } function penDot(ctx, x, y) { if (!ctx) return; if (!isFinite(x) || !isFinite(y)) return; // 防御：历史坏数据里的 null/NaN 不画 ctx.fillStyle = brushColor; // 笔刷 hook 统一改写为当前笔色（保留 alpha） ctx.beginPath(); ctx.arc(x, y, 2, 0, Math.PI * 2); // 半径 2 量级，落在 hook 的缩放区间内 ctx.fill(); } function penReplay(canvas, strokes) { var ctx = null; try { ctx = canvas.getContext('2d'); } catch (e) {} if (!ctx) return; ctx.clearRect(0, 0, canvas.width, canvas.height); var w = canvas.width, h = canvas.height; for (var i = 0; i < strokes.length; i++) { var s = strokes[i]; if (!s) continue; /* v2.9.32：橡皮笔程重放（dest-out，半径按记录的归一化值还原） */ if (s.e && s.pts) { var ex = []; for (var j2 = 0; j2 < s.pts.length; j2++) ex.push({ x: s.pts[j2][0] * w, y: s.pts[j2][1] * h }); penErasePath(ctx, ex, (s.r || 0) * w); continue; } if (!s.length) continue; var px = []; for (var j = 0; j < s.length; j++) px.push({ x: s[j][0] * w, y: s[j][1] * h }); penStrokePath(ctx, px); } } // 笔迹统一笔刷样式：色走笔刷 hook（已在 Fenbi 草稿 canvas 上强制为当前笔色、保留 alpha）， // 线宽 = 4×笔宽（与旧点阵直径一致：旧点半径 2、hook 再乘笔宽 → 直径 4×笔宽）。 function penStrokeStyle(ctx) { if (!ctx) return; ctx.strokeStyle = brushColor; ctx.lineWidth = 4 * brushWidth; ctx.lineCap = 'round'; ctx.lineJoin = 'round'; } /* 笔迹绘制：Catmull-Rom 样条（与粉笔原生画笔同族：cardinal spline，tension 0.5）转三次贝塞尔逐段描。为什么不用「中点二次贝塞尔」：那条曲线虽然平滑，但**不经过采样点**—— 采样一稀（平板主线程卡、pointermove 被浏览器合并）形状就走样成折线； Catmull-Rom 从前后邻点取切线，既没有尖角、又贴着笔的真实轨迹，视觉上与粉笔原生草稿画出来的完全一致。 v2.9.26：曲线数学只保留这一份（crSegment），整页草稿（penAdvance/penFinalize）与分栏草稿（appSeg）共用，平滑口径不再有两处实现。 */ function crSegment(ctx, p0x, p0y, p1x, p1y, p2x, p2y, p3x, p3y) { var c1x = p1x + (p2x - p0x) / 6, c1y = p1y + (p2y - p0y) / 6; var c2x = p2x - (p3x - p1x) / 6, c2y = p2y - (p3y - p1y) / 6; ctx.beginPath(); ctx.moveTo(p1x, p1y); ctx.bezierCurveTo(c1x, c1y, c2x, c2y, p2x, p2y); ctx.stroke(); } /* done：已画到第几段（增量调用时只补画新段，不全量重绘）。 */ function penAdvance(ctx, pts, done) { if (!ctx) return done || 0; var n = pts.length, d = done || 0; while (d + 2 <= n - 1) { // 需要 pts[d+2] 才能定右切线，缺就等下一个点 var p0 = d > 0 ? pts[d - 1] : pts[d]; var p1 = pts[d], p2 = pts[d + 1]; var p3 = d + 2 <= n - 1 ? pts[d + 2] : pts[d + 1]; crSegment(ctx, p0.x, p0.y, p1.x, p1.y, p2.x, p2.y, p3.x, p3.y); d++; } return d; } // 收尾：补最后一段（末端用沿末段方向的虚拟点，曲线不留尖角）；2 点笔画则直接连线。 function penFinalize(ctx, pts) { if (!ctx) return; var n = pts.length; if (n < 2) return; if (n === 2) { ctx.beginPath(); ctx.moveTo(pts[0].x, pts[0].y); ctx.lineTo(pts[1].x, pts[1].y); ctx.stroke(); return; } var p0 = pts[n - 3], p1 = pts[n - 2], p2 = pts[n - 1]; var p3 = { x: p2.x + (p2.x - p1.x), y: p2.y + (p2.y - p1.y) }; crSegment(ctx, p0.x, p0.y, p1.x, p1.y, p2.x, p2.y, p3.x, p3.y); } // 整笔（用于重放）：单点画圆点，多点点阵平滑成曲线。 function penStrokePath(ctx, pts) { if (!ctx || !pts || !pts.length) return; if (pts.length === 1) { penDot(ctx, pts[0].x, pts[0].y); return; } penStrokeStyle(ctx); penAdvance(ctx, pts, 0); penFinalize(ctx, pts); } /* ---- v2.9.32 橡皮（焦点触控笔 Pro 按键适配） ---- 擦除 = destination-out 圆点 + 圆头粗线，逐点增量走笔（与书写路径同构， penAdvance 的 done 契约照搬）。只作用于自制画布（整页层/材料/子题/分栏）；粉笔原生草稿的橡皮行为由粉笔自己决定——它若不支持笔橡皮，用户仍可用它工具栏自带的橡皮。橡皮半径随笔刷滑块（0.4×~4×），基准 12px。 */ function penEraserR() { return 12 * (brushWidth || 1); } function erX(p) { return p.length ? p[0] : p.x; } // fp 路径点 {x,y}，app 路径点 [x,y] function erY(p) { return p.length ? p[1] : p.y; } function penEraseDot(ctx, x, y, r) { if (!ctx || !isFinite(x) || !isFinite(y) || !(r > 0)) return; ctx.save(); ctx.globalCompositeOperation = 'destination-out'; ctx.beginPath(); ctx.arc(x, y, r, 0, Math.PI * 2); ctx.fill(); ctx.restore(); } function penEraseSeg(ctx, a, b, r) { if (!ctx || !(r > 0)) return; ctx.save(); ctx.globalCompositeOperation = 'destination-out'; ctx.beginPath(); ctx.moveTo(erX(a), erY(a)); ctx.lineTo(erX(b), erY(b)); ctx.lineWidth = r * 2; ctx.lineCap = 'round'; ctx.lineJoin = 'round'; ctx.stroke(); ctx.restore(); } // 整条橡皮笔程重放（penReplay / 分栏 acts 用） function penErasePath(ctx, px, r) { if (!ctx || !px || !px.length || !(r > 0)) return; penEraseDot(ctx, erX(px[0]), erY(px[0]), r); for (var i = 1; i < px.length; i++) penEraseSeg(ctx, px[i - 1], px[i], r); } // 增量擦（与 penAdvance 同一 done 契约：返回已处理到的点数） function penEraseAdvance(ctx, pts, done) { if (!ctx) return done || 0; var n = pts.length, d = done || 0; if (d === 0 && n > 0) { penEraseDot(ctx, erX(pts[0]), erY(pts[0]), penEraserR()); d = 1; } while (d < n) { penEraseSeg(ctx, pts[d - 1], pts[d], penEraserR()); d++; } return d; } // 找元素向上最近的「真滚动容器」（内容超高且 overflow 可滚）；找不到返回 null = 滚页面 function scrollerOf(el) { var n = el; for (var i = 0; n && i < 12; i++) { try { if (n.scrollHeight - n.clientHeight > 4) { var win = n.ownerDocument && n.ownerDocument.defaultView; var oy = (win || window).getComputedStyle(n).overflowY; if (oy === 'auto' || oy === 'scroll') return n; } } catch (e) {} n = n.parentElement; } return null; } function attachPen(canvas, cv) { var ctx = null; try { ctx = canvas.getContext('2d'); } catch (e) {} var drawing = false, pts = [], last = null, done = 0; var stroke = null; // v2.8.11：本笔所属指针 + 已收坐标（防两路指针流把笔画画两遍） cv.__drawing = false; cv.__abort = function () { // 模式切换/重建时中断进行中的书写 drawing = false; pts = []; last = null; done = 0; cv.__drawing = false; stroke = null; }; canvas.addEventListener('pointerdown', function (e) { if (cv.mode === 'pass') return; // 穿透模式 pointer-events:none，理论收不到，兜底 if (e.pointerType === 'mouse' && e.button !== 0) return; if (!penWritable(e)) return; // v2.9.27：笔侧键 / 橡皮键不是落笔 drawing = true; cv.__drawing = true; try { canvas.setPointerCapture(e.pointerId); } catch (err) {} last = penPoint(canvas, e); pts = [last]; done = 0; stroke = { pointerId: e.pointerId, pointerType: e.pointerType, seen: {}, seenKeys: [], // v2.8.13：与 fp 路径同一套归属语义（允许中途换 id，只拒绝自己 down 过的指针） ids: (function () { var m = {}; m[e.pointerId] = true; return m; })(), downIds: penDownIds, erase: penEraser(e) }; // v2.9.32：橡皮态落笔 → 这一整笔都是擦除 fpStrokeDup(stroke, last); if (stroke.erase) penEraseDot(ctx, last.x, last.y, penEraserR()); else { penDot(ctx, last.x, last.y); penStrokeStyle(ctx); } e.preventDefault(); }); canvas.addEventListener('pointermove', function (e) { if (!drawing) return; // v2.8.11：只收本笔所属指针的事件；同一物理坐标不收两遍 if (!fpStrokeOwns(stroke, e)) return; var evs = penCoalesce(e); var batchRect = canvas.getBoundingClientRect(); // v2.9.40：一批合并采样量一次 for (var k = 0; k < evs.length; k++) { var p = penPoint(canvas, evs[k], batchRect); var dx = p.x - last.x, dy = p.y - last.y; var dist = Math.sqrt(dx * dx + dy * dy); if (dist >= 0.35) { // 只收有意义的位移；阈值调细（一页成卷下主线程卡、采样稀），贝塞尔曲线更顺 if (fpStrokeDup(stroke, p)) continue; pts.push(p); last = p; } } // 增量补画新段，不全量重绘（v2.9.32：橡皮走 dest-out 圆头线） if (stroke.erase) done = penEraseAdvance(ctx, pts, done); else done = penAdvance(ctx, pts, done); e.preventDefault(); }); ['pointerup', 'pointercancel', 'lostpointercapture'].forEach(function (t) { canvas.addEventListener(t, function (e) { if (!drawing) return; // v2.8.11/v2.8.13：别的指针收笔不动本笔（只认本笔认领过的指针） if (e && !fpStrokeEnds(stroke, e)) return; drawing = false; cv.__drawing = false; if (!stroke.erase && pts.length >= 2) penFinalize(ctx, pts); if (pts.length >= 1) { var w = canvas.width || 1, h = canvas.height || 1; if (stroke.erase) { /* v2.9.32：橡皮笔程落账（单点也算——点擦）；r 按画布宽归一化，重放时还原 */ cv.strokes.push({ e: 1, r: penEraserR() / w, pts: pts.map(function (p) { return [p.x / w, p.y / h]; }) }); } else { cv.strokes.push(pts.map(function (p) { return [p.x / w, p.y / h]; })); } cvScheduleSave(cv); } pts = []; last = null; done = 0; stroke = null; }); }); } // 模式全句提示（弹窗用）：材料=材料区域；子题=第 N 题的题目区域 function cvSubNo(cv) { var idx = cv.host && cv.host.querySelector ? cv.host.querySelector('.title-index') : null; return idx ? (idx.textContent || '').replace(/[^\d]/g, '') : ''; } function drawLabel(cv) { if (cv.key && cv.key.indexOf('mat-') === 0) return '材料区域草稿已打开，当前可书写，不可触摸。'; var no = cvSubNo(cv); return (no ? '第' + no + '题的题目区域' : '题目区域') + '草稿已打开，当前可书写，不可触摸。'; } function passLabel(cv) { if (cv.key && cv.key.indexOf('mat-') === 0) return '材料区域草稿已让位，当前可触摸，不可书写。'; var no = cvSubNo(cv); return (no ? '第' + no + '题的题目区域' : '题目区域') + '草稿已让位，当前可触摸，不可书写。'; } // v2.7.8 整页草稿提示：整页都可写、滚动已锁定（用户 iPad 实测书写/滚动冲突后定稿） // v2.7.9：两态化——可触摸不再是「退出」，而是「只放行 ABCD/下一题」的锁定态 // v2.8.0：入口改成题目右上角的原生草稿笔图标，出口在右侧草稿竖条上 function fpDrawLabel(cv) { var no = cvSubNo(cv); return (no ? '第' + no + '题' : '本题') + '整页草稿已打开：整个页面都可书写（滚动已锁定）；写完点右侧草稿栏的「当前可触摸」答题。'; } function fpPassLabel(cv) { var no = cvSubNo(cv); return (no ? '第' + no + '题' : '本题') + '当前可触摸：只可点 ABCD / 下一题 / 右侧草稿栏，其余按钮已锁定；点「当前可书写」可继续写。'; } function fpExitLabel() { return '已退出整页草稿：页面恢复正常，笔迹已保存；再点这道题的草稿笔图标可继续写。'; } /* ---- v2.7.8 整页草稿态锁定滚动 ---- 用户 iPad 实测：整页草稿开着时笔在写、手指一碰页面就滚，两个手势互相打架。定稿：可书写态 = 纯书写状态，页面不许滚。实现选择（真机两次实测对比后定）： ① 不用 html/body overflow:hidden 锁——文档滚动容器一消失，Chrome 会把 scrollY 钳回 0（实测：43k 高的文档一开层就从 42934 跳回顶部，用户正在看的那道题瞬间「跳走」）；且粉笔自己的 JS 还会把 html 行内 style 重写成「overflow-y:auto !important」覆盖我们的样式，要不停补锁； ② 改为拦输入事件：document 捕获层 touchmove / wheel preventDefault—— 页面停在原位，手指拖不动、滚轮也滚不动；笔的 pointer 流不受影响（书写照常），轻点（tap）也不受影响（只拦 move，我们自己的按钮照常点）。 fpClose 移除监听即恢复。 */ var fpScrollLock = null; function fpLockScroll() { /* v2.9.31：可书写态给 html 挂标记，CSS 据此压住文字选中/长按菜单/双击放大（原来这三件事靠 touchstart preventDefault 一并兜住；现在 touchstart 要让路给双指缩放手势，改由 CSS + touchend 兜，见 fpTouchStart / fpTouchEnd）。 */ try { document.documentElement.setAttribute('data-marvis-fp-draw', '1'); } catch (e0) {} if (fpScrollLock) return; fpScrollLock = { touch: function (e) { /* v2.9.31：双指 = 缩放手势 → 放行给浏览器（用户要求「手缩放 + 笔写字」：双指捏合缩放页面，单指仍不许滚动，笔照常书写）。 */ if (e.touches && e.touches.length >= 2) return; e.preventDefault(); // 单指拖动一律不给页面（页面停在原位） }, wheel: function (e) { if (e.ctrlKey) return; // v2.9.31：Ctrl+滚轮 = 桌面端缩放，放行 e.preventDefault(); // 桌面滚轮/触控板同样不滚 } }; document.addEventListener('touchmove', fpScrollLock.touch, { capture: true, passive: false }); document.addEventListener('wheel', fpScrollLock.wheel, { capture: true, passive: false }); } function fpUnlockScroll() { if (!fpScrollLock) return; document.removeEventListener('touchmove', fpScrollLock.touch, { capture: true }); document.removeEventListener('wheel', fpScrollLock.wheel, { capture: true }); fpScrollLock = null; try { document.documentElement.removeAttribute('data-marvis-fp-draw'); } catch (e0) {} } // 全句提示弹窗（顶部居中淡入淡出，不打断操作；仅用户切到演算态时弹出） var cvToastTimer = 0; function cvToast(msg) { if (!document.body) return; var el = document.getElementById('marvis-cv-toast'); if (!el) { el = document.createElement('div'); el.id = 'marvis-cv-toast'; el.style.cssText = 'position:fixed;left:50%;top:12%;transform:translateX(-50%);z-index:2147483000;' + 'padding:10px 18px;border-radius:10px;background:rgba(28,32,38,.88);color:#fff;' + 'font:600 15px/1.5 -apple-system,"PingFang SC",sans-serif;box-shadow:0 4px 16px rgba(0,0,0,.25);' + 'pointer-events:none;opacity:0;transition:opacity .25s;max-width:80vw;text-align:center;'; document.body.appendChild(el); } el.textContent = msg; el.style.opacity = '1'; clearTimeout(cvToastTimer); cvToastTimer = setTimeout(function () { el.style.opacity = '0'; /* v2.9.31：淡出后再把节点整个摘掉——此前只把 opacity 归零，元素常驻 DOM，少数内核上（opacity 过渡被中断/样式失效）会变成「提示文字一直在，固定在那个位置」的残留。延时窗口内来了新 toast（opacity 又变回 1）则不摘，复用原节点继续显示。 */ setTimeout(function () { if (el.parentNode && el.style.opacity === '0') { try { el.parentNode.removeChild(el); } catch (e2) {} } }, 450); }, 2600); } function applyCvMode(cv) { if (!cv) return; if (cv.fpEligible) { // v2.8.0：整页草稿是一个「会话」，会话内两态：可书写(draw) ↔ 可触摸(pass)。 // 未开会话时（__fpSess=false）什么也不做：不建层、不锁滚动、不拦点击。 if (!cv.__fpSess) { cvSyncBtn(cv); return; } if (cv.mode === 'draw') fpOpen(cv); // 可书写：开层 + 锁滚动 + 手指点按无效 else fpEnterPass(cv); // 可触摸：层留着（笔迹可见）+ 解锁滚动 + 只放行 ABCD fpQuietSync(); // v2.8.13：静音跟着模式走（可触摸态要能用手写原生草稿） cvSyncBtn(cv); return; } if (!cv.canvas) return; cv.canvas.style.pointerEvents = cv.mode === 'pass' ? 'none' : 'auto'; cvSyncBtn(cv); if (cv.__abort) cv.__abort(); // 模式切换即中断进行中的书写/滚动手势 } function cvSyncBtn(cv) { // v2.8.0：资料分析子题没有自己的悬浮按钮，状态同步全交给右侧草稿竖条 if (cv && cv.fpEligible) { fpDockSync(); return; } if (!cv || !cv.toggleBtn) return; var meta = { draw: ['当前可书写', '演算中：手/笔皆可书写；点按切到「当前可触摸」'], pass: ['当前可触摸', '画布不挡指针：可滚动/选中/点击下方内容；点按切回「当前可书写」'] }[cv.mode] || ['当前可书写', '']; cv.toggleBtn.textContent = meta[0]; cv.toggleBtn.title = meta[1]; cv.toggleBtn.className = 'marvis-cvbtn' + (cv.mode === 'pass' ? '' : ' marvis-cvbtn-on'); } /* ---------- v2.7.7 整页草稿层（仅资料分析子题，fpEligible） ---------- */ // 展开态：body 级透明层(fixed inset:0, pointer-events:none)盖住视口，笔/鼠标经 // window 捕获层 + setPointerCapture 在层内 canvas 上书写；层对 HitTesting 隐身， // 页面本体的滚动/点击照旧。任何时候最多一层。 // v2.7.9：会话两态（可书写 / 可触摸·锁定），工具条不再飞右上角。 var FP_LAYER_ID = 'marvis-fp-layer'; var FP_DOCK_ID = 'marvis-fp-dock'; // v2.8.0 草稿竖条（替代原来的两个悬浮按钮） var FP_PILL_ID = 'marvis-fp-pill'; // 仅用于清理旧版残留的右上角胶囊 // 我们自己的悬浮控件：落在上面一律放行（保持原生点击），绝不当成笔迹 var FP_CTRL_SEL = '#marvis-fp-dock, #marvis-flat-chip, .marvis-brush-panel, ' + '.answer-card-container, #marvis-cv-toast, #marvis-fp-pill'; // 书写态手指唯一可点的东西：草稿竖条（切换/清空/退出都在里面，必须够得着） // v2.9.30：诊断浮层已删除，白名单里不再有 #marvis-pen-diag-box var FP_TOUCH_SEL = '#marvis-fp-dock, #marvis-flat-chip, .marvis-brush-panel, #marvis-cv-toast'; // 触摸态唯一可点的东西：上面这些 + 本题字母盒（ABCD + 下一题）+ 本子的草稿笔图标 var FP_CLICK_SEL = FP_TOUCH_SEL + ', .marvis-lbox, .marvis-lbtn, .marvis-next, li.draft.tool'; // 页面可交互元素：鼠标落上去放行（点选项=点击）；笔落上去轻点则转发点击 var FP_BTN_SEL = 'button, a[href], input, select, textarea, label, [role="button"], ' + '[role="radio"], [role="checkbox"], [nz-radio], nz-radio-group, li.choice-radio, .marvis-lbtn, ' + 'li.draft.tool'; var fpOwner = null; // 会话归属画布（draw/pass 两态都算会话开着） var fpPen = null; // 层内 canvas（全局唯一，随层创建） var fpDown = null; // 进行中的笔势 { pts, last, t0, target, cv } var fpTipAt = 0; // 「当前不可触摸 / 已锁定」提示节流时间戳 function fpHitSel(el, sel) { return !!(el && typeof el.closest === 'function' && el.closest(sel)); } /* v2.8.1：整页草稿的唯一准入判据 =「一拖五」资料分析组内子题。 `app-ti.question-multiple` 是全站题目的组件名（普通单题也用它，2026-10-26 真机实测：题 1~8 全是 app-ti.question-multiple），所以它**绝不能**当子题判据 ——v2.8.0 就栽在这里：普通题点草稿笔图标也被拽进整页草稿 + 右侧竖条。真判据只有一个，与 processTi 建画布的口径完全一致：所在的 .ti 是组（含 .materials-container / .questions-anchors）。 */ function fpInGroup(sub) { // 纯结构判定（不看开关） if (!sub || typeof sub.closest !== 'function') return null; var ti = sub.closest('.ti'); if (!ti) return null; return isGroupTi(ti) ? ti : null; } // 决策版（三道闸都用它）：v2.8.2 起再叠一层「板块开关」——用户可以在右下角 // 胶囊面板里把「资料分析 · 1拖5」单独关掉，那时整页草稿一律不受理。 function fpGroupOfSub(sub) { if (!groupEnabled()) return null; return fpInGroup(sub); } // 自愈：清掉 v2.8.0 在普通题（非组内子题）上误建的 fpEligible 画布。 // 只认「被我们打过 CV_ATTR 的 app-ti」，正常资料分析子题原样保留。 function cvPurgeStrayFp() { var tagged; try { tagged = document.querySelectorAll('app-ti.question-multiple[' + CV_ATTR + ']'); } catch (e) { return; } for (var i = 0; i < tagged.length; i++) { var sub = tagged[i]; var cv = sub.__marvisCv; if (!cv || !cv.fpEligible) continue; // 不是整页草稿画布，不动 if (fpInGroup(sub)) continue; // 结构上确实是（一拖五）子题：保留 if (fpOwner === cv) fpExit(); try { delete sub.__marvisCv; } catch (e2) { sub.__marvisCv = null; } try { sub.removeAttribute(CV_ATTR); } catch (e3) {} var junk = sub.querySelectorAll('canvas.marvis-pen, .marvis-cv-tools'); for (var j = 0; j < junk.length; j++) junk[j].remove(); } } function fpIsInteractive(el) { return fpHitSel(el, FP_BTN_SEL); } // 指针分流总闸（纯函数，单测直接打表）：这一笔到底抓不抓 // 笔(pen)的走向： // - 普通单题（fpOwner 为空）→ 此处直接 false，笔与手指一样落粉笔原生草稿（原生画曲线） // - 一拖五/一页成卷组（fpOwner 存在）→ 原生组级草稿被 neutralizeGroupDraft 隐藏 // （它本是盖住整组的透明层、会吃掉所有点击，不能复活），故笔被脚本接管、走自建 // 整页草稿层；该层自 v2.8.5 起已用二次贝塞尔平滑，v2.8.6 又把采样阈值调细，曲线更顺。 // 结论：两种情况笔都不再画折线；若仍见折线，几乎必然是 Tampermonkey 仍是旧版未更新。 function fpGate(e) { if (!fpOwner || fpOwner.mode !== 'draw') return false; if (e.pointerType === 'touch') return false; // 手指不接管 → 落原生草稿（画曲线） if (e.pointerType !== 'pen' && e.pointerType !== 'mouse') return false; if (!penWritable(e)) return false; // v2.9.27：Android 笔侧键按下不算落笔 var t = e.target; if (fpHitSel(t, FP_CTRL_SEL)) return false; if (e.pointerType === 'mouse' && fpIsInteractive(t)) return false; // 鼠标点按钮=点击 return true; } // 提示节流：手指连点时不要把 toast 刷成闪烁 function fpTip(msg, gap) { var now = Date.now(); if (now - fpTipAt < (gap || 1500)) return; fpTipAt = now; cvToast(msg); } /* 书写态：手指点按一律无效（纯书写状态，笔写/手指滚动手势不能打架）。 v2.9.31 改法：touchstart 不再 preventDefault——第一根手指的 touchstart 一旦被取消，这根手指的整段手势就被浏览器判死，双指缩放永远起不来（用户要求「手缩放 + 笔写字」）。改由三层兜住手指： ① touchmove 单指 preventDefault（fpScrollLock.touch）→ 页面不滚； ② touchend preventDefault（fpTouchEnd）→ 不合成 click，点按仍无效； ③ html[data-marvis-fp-draw] 的 CSS → 不选中文字、不弹长按菜单、不双击放大（双指捏合缩放不受影响）。仍在我们自己的控件（竖条/胶囊）上放行——否则连「切换/清空/退出」都按不了。 v2.8.0：静默拦截，不弹提示。 */ function fpTouchStart(e) { if (!fpOwner || fpOwner.mode !== 'draw') return; if (fpHitSel(e.target, FP_TOUCH_SEL)) return; e.stopPropagation(); // 页面收不到手指触摸（不拦默认动作，缩放手势才起得来） } function fpTouchEnd(e) { if (!fpOwner || fpOwner.mode !== 'draw') return; if (fpHitSel(e.target, FP_TOUCH_SEL)) return; e.preventDefault(); // 杜绝手指点按合成 click（误触选项/按钮） } /* 触摸态（锁定）：只放行 ABCD / 下一题 / 草稿竖条 / 本题草稿图标，其余点击全部吃掉（用户：「别的按钮应该都覆盖掉」）。用捕获层 click 过滤而不是遮罩层：不改布局、不影响滚动、也不影响笔迹重放。我们自己为了「点 ABCD 就等于点原生选项」而合成的 click（label.click()）走 fpAllowOnce 记数放行，否则会被自己拦掉、选项永远选不上。 */ var fpClickBypass = 0; function fpAllowOnce(fn) { fpClickBypass++; try { fn(); } finally { fpClickBypass--; } } function fpPassClick(e) { if (!fpOwner || fpOwner.mode !== 'pass') return; if (fpClickBypass > 0) return; // 我们自己的合成点击 if (fpHitSel(e.target, FP_CLICK_SEL)) return; // 白名单：ABCD/下一题/竖条/草稿图标 e.preventDefault(); e.stopPropagation(); if (e.stopImmediatePropagation) e.stopImmediatePropagation(); fpTip('当前只可点 ABCD / 下一题 / 右侧草稿按钮'); } /* ---------- v2.8.0 草稿竖条（仿粉笔原生草稿工具条） ---------- 用户要求：「把『当前可触摸』和『当前可书写』集成到原生那个草稿按钮，清空也集成进去」。实测结构（tools/cdp-probe-native-draft*.js）：资料分析组的原生草稿是**整组一条** （.ti > .draft-container > app-draft > canvas#draft + .tools-container），而且被本脚本整体隐藏（组成员画布会给全组指针事件兜底，见 neutralizeGroupDraft）——没地方直接塞按钮，也不该复活它。所以做一条与它同款（#3c464f 深色、竖排、贴右边缘、 12px 圆角、20px 图标 + 11px 白字、activate 高亮）的竖条，只放这套草稿真正用得上的三项：书写/触摸切换 · 清空（两步确认）· 退出。入口用**原生那个草稿笔图标**（li.draft.tool，每道子题各有一个）——点它就打开/收起这道题的整页草稿，和原生草稿按钮的操作感一致，不用再多一个悬浮小按钮。 */ var fpDock = null; var FP_ICO = { draw: '', touch: '', clear: '', exit: '' }; function fpDockItem(ico, name, cls) { var b = document.createElement('button'); b.type = 'button'; b.className = 'marvis-fpd-item' + (cls ? ' ' + cls : ''); b.innerHTML = ico + '' + name + ''; return b; } function fpDockEnsure() { if (fpDock && fpDock.el.isConnected) return fpDock; var old = document.getElementById(FP_DOCK_ID); if (old) old.remove(); var el = document.createElement('div'); el.id = FP_DOCK_ID; var toggle = fpDockItem(FP_ICO.draw, '当前可书写', 'fpd-toggle'); var clear = fpDockItem(FP_ICO.clear, '清空', 'fpd-clear'); var exit = fpDockItem(FP_ICO.exit, '退出', 'fpd-exit'); el.appendChild(toggle); el.appendChild(clear); el.appendChild(exit); document.body.appendChild(el); fpDock = { el: el, toggle: toggle, clear: clear, exit: exit }; toggle.addEventListener('click', function (ev) { ev.preventDefault(); ev.stopPropagation(); fpDockToggle(); }); clear.addEventListener('click', function (ev) { ev.preventDefault(); ev.stopPropagation(); fpDockClear(); }); exit.addEventListener('click', function (ev) { ev.preventDefault(); ev.stopPropagation(); fpExit(); cvToast(fpExitLabel()); }); return fpDock; } // 竖条状态同步（会话开关 / 两态文案 / 清空二次确认 / 归属题图标高亮） function fpDockSync() { var d = fpDock; if (!d) return; var cv = fpOwner; var on = !!cv; d.el.classList.toggle('on', on); /* v2.9.31：行内 display 跟随会话态（开=交还 CSS 控制，关=行内钉死 hidden），不依赖样式表是否完好（防「提示条残留」复发，见 fpExit）。 */ try { d.el.style.display = on ? '' : 'none'; } catch (e0) {} var draw = on && cv.mode === 'draw'; var name = d.toggle.querySelector('.fpd-name'); if (name) name.textContent = draw ? '当前可书写' : '当前可触摸'; d.toggle.classList.toggle('on', draw); d.toggle.title = draw ? '整页书写中（页面滚动已锁定、手指点按无效）：点按切到「当前可触摸」答题' : '点按切回「当前可书写」，继续在这道题上写'; var armed = !!(on && cv.clearArmed && (Date.now() - cv.clearArmed) < 3000); var cname = d.clear.querySelector('.fpd-name'); if (cname) cname.textContent = armed ? '确认清空' : '清空'; d.clear.classList.toggle('warn', armed); d.clear.title = '清空这道题的整页草稿笔迹（两步确认）'; d.exit.title = '退出整页草稿：页面恢复普通态，笔迹已保存'; // 归属提示：会话所属那道题的草稿笔图标高亮，再点它一次即可退出 try { var lit = document.querySelectorAll('li.draft.tool.marvis-fp-pen-on'); for (var i = 0; i < lit.length; i++) lit[i].classList.remove('marvis-fp-pen-on'); var sub = on && cv.host && cv.host.closest ? cv.host.closest('app-ti.question-multiple') : null; var pen = sub ? sub.querySelector('li.draft.tool') : null; if (pen) pen.classList.add('marvis-fp-pen-on'); } catch (e) {} } function fpDockToggle() { var cv = fpOwner; if (!cv) return; cv.mode = cv.mode === 'draw' ? 'pass' : 'draw'; applyCvMode(cv); cvSave(cv.key, cv.strokes, cv.mode, cv.coordVer); cvToast(cv.mode === 'draw' ? fpDrawLabel(cv) : fpPassLabel(cv)); } function fpDockClear() { var cv = fpOwner; if (!cv) return; var now = Date.now(); if (cv.clearArmed && now - cv.clearArmed < 3000) { cv.strokes.splice(0, cv.strokes.length); // 原地清空：canvas.__marvisStrokes 引用保持有效 if (cv.canvas) penReplay(cv.canvas, cv.strokes); cvSave(cv.key, cv.strokes, cv.mode, cv.coordVer); cv.clearArmed = 0; fpDockSync(); cvToast('已清空本题整页草稿'); } else { cv.clearArmed = now; fpDockSync(); cvToast('再点一次「清空」确认（3 秒内）'); var stamp = now; setTimeout(function () { if (cv.clearArmed === stamp) { cv.clearArmed = 0; fpDockSync(); } }, 3000); } } // 原生草稿笔图标 = 整页草稿开关（仅资料分析子题；普通题照旧开粉笔自己的草稿） function fpToggleSession(cv) { if (!cv || !cv.fpEligible) return; // v2.8.1：双保险——宿主必须是一拖五资料分析组内子题，别的一概不受理 if (!fpGroupOfSub(cv.host)) return; if (fpOwner === cv) { fpExit(); cvToast(fpExitLabel()); return; } cv.mode = 'draw'; // 每次都从「可书写」进（状态不记忆） cv.__fpSess = true; applyCvMode(cv); cvSave(cv.key, cv.strokes, cv.mode, cv.coordVer); cvToast(fpDrawLabel(cv)); } // 文档捕获层：抢在粉笔自己的草稿处理器之前接管图标点击（**仅一拖五组内子题**） // v2.9.26：window/document 双层注册的去重改用 WeakSet 记事件对象 //（旧方案往事件上写 __marvisPenDone 自定义属性，个别环境不给写就双触发） var penDoneEvents = (typeof WeakSet === 'function') ? new WeakSet() : null; function isPenDone(e) { return penDoneEvents ? penDoneEvents.has(e) : !!e.__marvisPenDone; } function markPenDone(e) { if (penDoneEvents) penDoneEvents.add(e); else e.__marvisPenDone = 1; } function fpPenEntry(e) { if (isPenDone(e)) return; // window/document 两层都挂，同一个事件只处理一次 var t = e.target; if (!t || typeof t.closest !== 'function') return; var pen = t.closest('li.draft.tool'); if (!pen) return; var sub = pen.closest('app-ti.question-multiple'); if (!sub) return; // v2.8.1：普通单题的草稿图标 → 一律交还原生（它的组件名同样是 question-multiple） if (!fpGroupOfSub(sub)) return; // v2.9.0：面板开了「分栏草稿 APP式」→ 走左右分栏那一套（整组一张纸） if (appModeOn()) { markPenDone(e); e.preventDefault(); e.stopPropagation(); if (e.stopImmediatePropagation) e.stopImmediatePropagation(); appToggle(sub.closest('.ti')); return; } var cv = sub.__marvisCv; if (!cv && typeof ensureSubCanvas === 'function') { try { cv = ensureSubCanvas(sub, true); } catch (e0) {} // 视口门控跳过时补建 } if (!cv || !cv.fpEligible) return; markPenDone(e); e.preventDefault(); e.stopPropagation(); if (e.stopImmediatePropagation) e.stopImmediatePropagation(); fpToggleSession(cv); } function fpEnsureLayer() { // 旧版（≤v2.7.8）留下的右上角胶囊：工具条已不再飞过去，见到就清掉 var oldPill = document.getElementById(FP_PILL_ID); if (oldPill) oldPill.remove(); if (fpPen && fpPen.isConnected) return fpPen; // 旧版本/重复注入可能留下同名层：先清再建，避免两层叠着 var oldLayer = document.getElementById(FP_LAYER_ID); if (oldLayer) oldLayer.remove(); var layer = document.createElement('div'); layer.id = FP_LAYER_ID; layer.style.display = 'none'; // 会话未开时收起：可书写/可触摸两态才显示笔迹层 var cv = document.createElement('canvas'); cv.className = 'marvis-pen pen'; layer.appendChild(cv); document.body.appendChild(layer); fpPen = cv; fpSizeCanvas(); window.addEventListener('resize', fpSizeCanvas); // 起笔/移动/收笔全挂 window 捕获层：不依赖 setPointerCapture 一定成功 // （捕获只是让事件重定向到 canvas；即使失败，窗口级监听照样收得到整段笔程， // iPad Safari 等环境也有兜底）。指针事件在捕获阶段最先到达 window。 window.addEventListener('pointerdown', fpOnDown, true); window.addEventListener('pointermove', fpOnMove, true); ['pointerup', 'pointercancel'].forEach(function (t) { window.addEventListener(t, fpFinish, true); }); // v2.7.9：两个态的门禁常驻（内部按 fpOwner.mode 判态，无需随开关增删） document.addEventListener('touchstart', fpTouchStart, { capture: true, passive: false }); // v2.9.31：touchstart 不再 preventDefault（给双指缩放让路），改拦 touchend 防误触点按 document.addEventListener('touchend', fpTouchEnd, { capture: true, passive: false }); document.addEventListener('click', fpPassClick, true); return cv; } /* v2.9.27：绘图区不要系统菜单。 Android WebView 上「笔按在屏幕上稍微久一点」就会触发长按手势 → 弹「复制 / 全选 / 分享」原生菜单，并且把这一笔的指针流 cancel 掉（用户感受就是写一半断了）。iPad 上长按文字同样会弹菜单。CSS 的 user-select:none 能压住选中，但系统菜单在部分内核上只有 preventDefault 才拦得住，所以两层都上。只管我们自己的纸面：整页草稿层开着（全屏是纸）、材料/子题画布、分栏纸面；页面别处的右键菜单原样保留。 */ function marvisContextMenu(e) { var own = false; try { // 只在「可书写」态全屏拦截；「可触摸」态整页层是透传的，右键要留给页面 if (fpOwner && fpOwner.mode === 'draw') own = true; else if (e.target && typeof e.target.closest === 'function' && e.target.closest('canvas.marvis-pen')) own = true; else if (appCur && typeof appSideAt === 'function' && appSideAt(e.clientX, e.clientY)) own = true; } catch (err) {} if (!own) return; e.preventDefault(); e.stopPropagation(); if (e.stopImmediatePropagation) e.stopImmediatePropagation(); } window.addEventListener('contextmenu', marvisContextMenu, true); function fpCtx(cv) { try { return cv.getContext('2d'); } catch (e) { return null; } } function fpSizeCanvas() { if (!fpPen) return; var w = window.innerWidth || 0, h = window.innerHeight || 0; if (!w || !h) return; if (fpPen.width !== w || fpPen.height !== h) { fpPen.width = w; fpPen.height = h; if (fpOwner) penReplay(fpPen, fpOwner.strokes); // 归一化坐标按新尺寸重放，笔迹不丢 } } /* ---------- v2.8.11 一笔之内的收点归属（治「一条笔画变成两条交错的线」） ---------- iPad 上 Apple Pencil 的接触会同时产生【两路指针事件】： · pointerType='pen' 的指针流（带 getCoalescedEvents 的真实采样） · pointerType='touch' 的指针流（iOS 的触摸兼容流，同一批物理采样、不同的 pointerId） v2.8.10 的 fpOnMove 挂在 window 捕获层、且对来者不拒 → 两路事件被一起喂进同一个点序，点序变成 A,B,A,B… → 样条沿同一条轨迹来回重描；而每次重描时 Catmull-Rom 的切线邻域（p0/p3）已被重复点污染 → 两次描出的曲线形状略有差异 → 屏幕上就是「一条笔画画成两条几乎平行、局部交叉的线」。修法（两道闸）： 1) fpStrokeOwns：一笔只认一个指针（pointerId + pointerType 都要匹配），另一路丢弃； 2) fpStrokeDup：同一物理坐标只收一次 —— 防 Safari 把同一批 coalesced 采样点重复投递。两者都是纯函数，tests/pen-dual-stream-sim.js 直接抽取本文件的实现做离线仿真。 */ /* v2.8.12：归属判定去掉 pointerType 硬排除。之前用「pointerType 必须一致」来隔开 Apple Pencil 的双路指针流，出发点没问题，但它隐含假设「同一路事件在整笔里 pointerType 不变」——这条假设在第三方 WebView 壳里不成立：pointerdown 可能报 'pen'、后续 move 报 'touch'（或反过来）。一旦被判成「不是本笔」，整段事件被丢弃 → 笔画被切成几截，每截只剩 1~2 个点 → 我们只能画直线 → 又是「折线」。现在只认 pointerId（指针身份的唯一硬指标）；类型差异交给「采样去重 + 回访检测」处理——那两路流报的是同一批物理采样，去重层会天然把重复的那一路吃掉。 */ /* v2.8.13：归属判定再放宽一步——**允许浏览器在一笔之内更换 pointerId**。 v2.8.12 只认 pointerId，一旦浏览器中途换了 id（第三方 WebView 壳常见：同一支笔的接触被拆成两段不同 id 的生命周期），后续事件全部被判「不是本笔」→ 笔画被截断成起笔点那一两个点 → 只能画直线（折线）。新规则： · 本笔已绑定的 id → 收； · 另一个 id，但**它没有自己 down 过**（浏览器中途换 id）→ 收，并改绑到它； · 另一个 id，且**它自己 down 过**（真·第二指针：手掌 / 另一支笔）→ 拒绝。 down 过哪些 id 由 penPtrWatch 登记（penDownIds），与我们的落笔路径无关。 */ function fpStrokeOwns(stroke, e) { if (!stroke) return false; if (!e) return true; var id = e.pointerId; if (id === undefined || id === null) return true; if (!stroke.ids) stroke.ids = {}; if (stroke.ids[id]) return true; // 本笔已认领的指针 if (stroke.downIds && stroke.downIds[id]) return false; // 自己 down 过的第二指针 → 拒绝 stroke.ids[id] = true; // 中途换 id → 认领并改绑 stroke.pointerId = id; return true; } /* v2.8.13：收笔判定与「移动」判定分开。移动：允许浏览器中途换 pointerId（见 fpStrokeOwns）——不收的话笔画会被截断成直线。收笔：**只认本笔已认领的指针**。别的指针抬笔（触摸兼容流先抬笔、手掌离开）不能把本笔提前收掉。 */ function fpStrokeEnds(stroke, e) { if (!stroke) return false; if (!e) return true; var id = e.pointerId; if (id === undefined || id === null) return true; if (!stroke.ids) return id === stroke.pointerId; return !!stroke.ids[id]; } // 同一物理采样点是否已经收过（v2.8.13：量化去重只当快速路径，真正的判定改成距离） // 亚像素抖动（重复投递时坐标常有 0.2~1px 偏差）抓不住 → 去重失效 → 样条沿同一条 // 轨迹来回重描 → 一条笔画分成两条交错的线。故：距离 1px 内一律判重（只比最近 256 点）。 function fpStrokeDup(stroke, p) { if (!stroke || !p) return false; if (!stroke.seen) { stroke.seen = {}; stroke.seenKeys = []; } var k = Math.round(p.x * 4) + ',' + Math.round(p.y * 4); if (stroke.seen[k]) return true; var n = stroke.pts ? stroke.pts.length : 0; var from = n - 256; if (from < 0) from = 0; for (var i = from; i < n; i++) { var q = stroke.pts[i]; var dx = p.x - q.x, dy = p.y - q.y; if (dx * dx + dy * dy < 1) { stroke.seen[k] = 1; return true; } // 1px 内 = 同一个物理点 } stroke.seen[k] = 1; stroke.seenKeys.push(k); if (stroke.seenKeys.length > 512) { try { delete stroke.seen[stroke.seenKeys.shift()]; } catch (e) {} } return false; } /* v2.8.12 回访检测：新采样点若离「已经走过的某个旧点」很近，说明这是被重复/乱序投递的旧采样，而不是笔真的又走了一遍。放行它 = 样条沿原路折返 → 屏幕上就是一条笔画分叉成两条。两档判定（量化去重是 O(1) 快速路径，但抓不住亚像素抖动，这里用距离兜底）： · 离**当前位置** < 0.6px → 只是抖动重复，丢掉； · 离**更早的点** < 1.2px → 回访，丢掉（只比最近 64 个点，且跳过紧邻的上一点，避免误杀正常的回头路与打勾）。 */ function fpStrokeRetrace(stroke, p) { if (!stroke || !p || !stroke.pts || !stroke.pts.length) return false; var n = stroke.pts.length; var last = stroke.pts[n - 1]; var ldx = p.x - last.x, ldy = p.y - last.y; if (ldx * ldx + ldy * ldy < 0.36) return true; // 0.6px：当前位置的抖动重复 var from = n - 64; if (from < 0) from = 0; for (var i = from; i < n - 1; i++) { var q = stroke.pts[i]; var dx = p.x - q.x, dy = p.y - q.y; if (dx * dx + dy * dy < 1.44) return true; // 1.2px：回访旧点 } return false; } function fpOnDown(e) { // v2.8.0：可书写态手指点按静默无效（用户不要「当前不可触摸」弹窗）—— // 一律不惊动页面。触摸态(pass)手指完全放行：答案靠点击、滚动靠手指， // 由 fpPassClick 把关只放行 ABCD/下一题/竖条。 var touchAsPen = false; if (e.pointerType === 'touch') { if (!fpOwner || fpOwner.mode !== 'draw') return; if (fpHitSel(e.target, FP_TOUCH_SEL)) return; // 竖条上的切换/清空/退出必须能按 if (penSeen) { // 这台设备会报 pointerType=pen → 这次的 touch 就是手指/手掌，不当笔收 //（防误触/防掌心）。v2.9.31：不再 preventDefault——pointerdown 一取消， // 这根手指的整段手势就被浏览器判死，双指缩放起不来；点按/滚动由 // fpTouchEnd / fpScrollLock 兜住，这里只管「不把手指当笔」。 return; } // v2.8.12 自适应：本会话从没见过 pointerType='pen' —— 说明这台浏览器根本不把 // 触控笔报成 pen（Via 的 WKWebView 壳就是这种），于是「触控笔」会以 touch 到达。 // 这时把 touch 当笔接管（= 用户说的「统一当成是手写的」），否则笔根本写不出字。 touchAsPen = true; } if (!touchAsPen && !fpGate(e)) return; e.preventDefault(); e.stopPropagation(); // 抢在原生草稿/页面处理器之前，书写不惊动页面 var cv = fpEnsureLayer(); try { cv.setPointerCapture(e.pointerId); } catch (err) {} var p = penPoint(cv, e); fpDown = { pts: [{ x: p.x, y: p.y }], last: p, done: 0, t0: Date.now(), target: e.target, cv: cv, // v2.8.11：记下本笔所属指针 —— 另一路（触摸兼容流）的事件一律不收 pointerId: e.pointerId, pointerType: e.pointerType, // v2.8.13：ids = 本笔认领过的指针集合（允许浏览器中途换 id 时改绑）； // downIds = 全局记录「哪些 id 自己 down 过」（用来分辨真·第二指针 vs 中途换 id） ids: (function () { var m = {}; m[e.pointerId] = true; return m; })(), downIds: penDownIds, seen: {}, seenKeys: [], rejected: 0, erase: penEraser(e) // v2.9.32：系统橡皮态（双击笔身切换）→ 这一整笔都是擦除 }; fpStrokeDup(fpDown, p); // 起笔点登记进「已收坐标」 if (fpDown.erase) { penEraseDot(fpCtx(cv), p.x, p.y, penEraserR()); } else { penDot(fpCtx(cv), p.x, p.y); penStrokeStyle(fpCtx(cv)); } } function fpOnMove(e) { if (!fpDown) return; if (e && e.__marvisSynth) return; // v2.8.7：原生草稿补密用的合成事件，别二次落笔 // v2.8.11/v2.8.12：只收本笔所属指针的事件（Apple Pencil 会同时冒出 touch 指针流） if (!fpStrokeOwns(fpDown, e)) { fpDown.rejected++; return; } var cv = fpDown.cv; var ctx = fpCtx(cv); var evs = penCoalesce(e); var batchRect = cv.getBoundingClientRect(); // v2.9.40：一批合并采样量一次 for (var k = 0; k < evs.length; k++) { var p = penPoint(cv, evs[k], batchRect); var last = fpDown.last; var dx = p.x - last.x, dy = p.y - last.y; var dist = Math.sqrt(dx * dx + dy * dy); if (dist >= 0.35) { // 只收有意义的位移；阈值调细（一页成卷下主线程卡、采样稀），贝塞尔曲线更顺，无需直线插值 if (fpStrokeDup(fpDown, p)) { fpDown.rejected++; continue; } // v2.8.11：同一采样点不收两遍 // v2.8.12：回访点（重复/乱序投递的旧采样）也不收——放行它会让样条沿原路折返 if (fpStrokeRetrace(fpDown, p)) { fpDown.rejected++; continue; } fpDown.pts.push({ x: p.x, y: p.y }); fpDown.last = p; } } // 增量补画新段（v2.9.32：橡皮走 dest-out 圆头线，不走样条） if (fpDown.erase) fpDown.done = penEraseAdvance(ctx, fpDown.pts, fpDown.done); else fpDown.done = penAdvance(ctx, fpDown.pts, fpDown.done); e.preventDefault(); e.stopPropagation(); // 笔程不带给页面（防选中文字/触发页面滚动手势） } function fpFinish(e) { if (!fpDown) return; // v2.8.11/v2.8.13：别的指针收笔不动本笔（触摸兼容流先抬笔时不能把笔的笔画提前收掉） if (e && !fpStrokeEnds(fpDown, e)) return; var d = fpDown; fpDown = null; var owner = fpOwner; if (!owner) return; /* v2.9.32：橡皮笔程落账——单点也算（点擦），不参与 isTap「轻点不成笔」逻辑； r 按画布宽归一化，重放/清屏恢复时按新宽还原。 */ if (d.erase) { var ew = d.cv.width || 1, eh = d.cv.height || 1; owner.strokes.push({ e: 1, r: penEraserR() / ew, pts: d.pts.map(function (p) { return [p.x / ew, p.y / eh]; }) }); cvScheduleSave(owner); return; } var maxMove = 0; for (var i = 1; i < d.pts.length; i++) { var dx = d.pts[i].x - d.pts[0].x, dy = d.pts[i].y - d.pts[0].y; var m = Math.sqrt(dx * dx + dy * dy); if (m > maxMove) maxMove = m; } var isTap = d.pts.length <= 2 && maxMove < 8 && (Date.now() - d.t0) < 400; if (isTap) { // 轻点不成笔迹：统一重放擦掉起笔那个点（否则画布上会留一个擦不掉的墨点） penReplay(d.cv, owner.strokes); // 落在按钮上（笔点答案/翻页）→ 转发一次原生点击，平板上用笔也能选答案。 // 转发目标取「落点处最深的那个元素」（等价于原生点击的 target），而不是 // closest 出来的外层按钮：粉笔的选项外层是 li，点多层标签时真正承接点击的是 // 里面的 label/input，打在外层 li 上的合成 click 不会触发选中。 if (fpIsInteractive(d.target)) { var p0 = d.pts[0]; var hit = null; try { hit = (p0 && typeof document.elementFromPoint === 'function') ? document.elementFromPoint(Math.round(p0.x), Math.round(p0.y)) : null; } catch (e3) {} var btn = hit || d.target.closest(FP_BTN_SEL) || d.target; if (btn && btn.dispatchEvent) { try { btn.dispatchEvent(new window.MouseEvent('click', { bubbles: true, cancelable: true, view: window })); } catch (e2) {} } } return; } if (d.pts.length >= 1) { if (d.pts.length >= 2) penFinalize(fpCtx(d.cv), d.pts); var w = d.cv.width || 1, h = d.cv.height || 1; // d.pts 里是 {x, y} 对象（笔迹按 Catmull-Rom 样条平滑渲染，存储仍是归一化坐标点序列） owner.strokes.push(d.pts.map(function (p) { return [p.x / w, p.y / h]; })); cvScheduleSave(owner); } } // 旧版（v2.7.6 及之前）子题笔迹存在题目框坐标系；首次展开整页层时按框的当前位置 // 重映射到视口坐标系——老笔迹不丢、不错位（框被滚出视口时原样保留归一化值）。 // v2.7.8：迁移状态随存储版本 v=2 持久化（原先是内存标记，刷新即丢，重开又迁移 // 一次 → 笔迹越迁越偏、画到视口外看不见；真机 E2E 实测）。 function fpMigrate(cv) { if (cv.__fpMigrated || !cv.strokes.length) return; var host = cv.host; if (!host || typeof host.getBoundingClientRect !== 'function') return; var r = host.getBoundingClientRect(); var vw = window.innerWidth || 1, vh = window.innerHeight || 1; // 题框量不到（还没排版/被滚出文档流）就原样保留、不标已迁移： // 标了就会把旧框坐标当视口坐标直接画，笔迹整体错位 if (!r.width || !r.height) return; cv.__fpMigrated = true; cv.coordVer = 2; cv.strokes = cv.strokes.map(function (s) { /* v2.9.32：橡皮笔程坐标同口径迁移（半径量级不随框缩放，误差可忽略） */ if (s && s.e && s.pts) { return { e: 1, r: s.r, pts: s.pts.map(function (p) { return [(r.left + p[0] * r.width) / vw, (r.top + p[1] * r.height) / vh]; }) }; } return s.map(function (p) { return [(r.left + p[0] * r.width) / vw, (r.top + p[1] * r.height) / vh]; }); }); // 立即落盘（含 v=2 标记）：不等 500ms 防抖，避免「迁移完立刻刷新」又迁一遍 cvSave(cv.key, cv.strokes, cv.mode, 2); } // 开会话 / 切到「可书写」态：层显示、笔迹重放、滚动锁定、手指点按变无效 /* ---------- v2.8.12 画者独占：会话期间让原生草稿「闭嘴」 ---------- 为什么必须做这一步：我们的捕获监听 + stopPropagation 只能拦住**同一个 JS world** 里的监听器。Via 这类自带脚本注入器的浏览器（iOS 版 = WKWebView 壳）可能把用户脚本注入到独立 content world —— 此时我们与页面里的粉笔原生草稿互不可见，同一笔会被「我们」和「原生」各画一遍：两套不同的平滑算法（Catmull-Rom vs 粉笔的 cardinal spline）画同一段轨迹，形状略有差异 → 屏幕上就是两条交错的线。结构性解法：**会话期间让原生草稿画布收不到任何指针事件**（pointer-events:none），这样不论几个 world、几个实例，都只有一个画者。作用域只限一拖五组（[data-marvis-fpgroup]），普通单题的原生草稿（用户还要用手指在上面写）完全不受影响。 */ var QUIET_ID = 'marvis-fp-quiet'; function fpQuietOn() { try { if (document.getElementById(QUIET_ID)) return; var st = document.createElement('style'); st.id = QUIET_ID; st.textContent = '[' + FPGRP_ATTR + '] app-draft canvas{pointer-events:none !important;}'; (document.head || document.documentElement).appendChild(st); } catch (e) {} } function fpQuietOff() { try { var st = document.getElementById(QUIET_ID); if (st) st.remove(); } catch (e) {} } /* v2.8.13：静音只在「可书写(draw)」态生效。 v2.8.12 把静音挂在**会话开关**上（会话一开就静默、退出才恢复），于是会话内切到「可触摸(pass)」后，组内原生草稿仍然收不到指针事件 → 用户用手指在原生草稿上写字时**根本写不了**（v2.8.12 引入的回归）。正确语义：可书写态 = 整页层接管书写，原生必须闭嘴（否则两个画者各画一遍）；可触摸态 = 层让开，原生草稿要能正常用手写 → 必须放开。 */ function fpQuietSync() { try { if (fpOwner && fpOwner.mode === 'draw') fpQuietOn(); else fpQuietOff(); } catch (e) {} } function fpOpen(cv) { // v2.8.2：板块被「部分关闭」时一律不开层（双保险，正常路径在 fpToggleSession 就挡了） if (!cv || !fpGroupOfSub(cv.host)) return; if (fpOwner !== cv) { if (fpOwner) fpClose(); // 一层制：上一个会话先整体退出（落盘 + 解滚动） var cvEl = fpEnsureLayer(); fpMigrate(cv); fpOwner = cv; cv.canvas = cvEl; fpSizeCanvas(); penReplay(cvEl, cv.strokes); } cv.__fpSess = true; var layer = document.getElementById(FP_LAYER_ID); if (layer) layer.style.display = ''; fpQuietSync(); // v2.8.13：只有「可书写」态才让原生草稿闭嘴 // v2.8.0：草稿竖条常驻右侧（切换/清空/退出都在里面，滚动锁了也够得着） fpDockEnsure(); fpDockSync(); fpLockScroll(); // v2.7.8：可书写态 = 纯书写，页面不许滚（笔写/手指滚动冲突） } // 会话内切到「可触摸」态：层不退（笔迹还看得见）、页面恢复滚动， // 点击由 fpPassClick 把关（只放行 ABCD/下一题/竖条/本子草稿图标） function fpEnterPass(cv) { if (fpOwner !== cv) fpOpen(cv); fpUnlockScroll(); } // 退出整个会话：落盘、解滚动、收层、竖条收起 function fpExit() { if (fpDown) fpDown = null; var owner = fpOwner; fpOwner = null; fpUnlockScroll(); // v2.7.8：恢复滚动 if (owner) { owner.__fpSess = false; owner.canvas = null; owner.mode = 'pass'; // 下次点开从「可书写」进（用户：状态不记忆） owner.clearArmed = 0; cvSave(owner.key, owner.strokes, owner.mode, owner.coordVer); // 立即落盘，不等防抖 } var layer = document.getElementById(FP_LAYER_ID); if (layer) layer.style.display = 'none'; fpQuietOff(); // v2.8.12：退出会话 → 恢复原生草稿的正常交互 var pill = document.getElementById(FP_PILL_ID); if (pill) pill.remove(); /* v2.9.31：退出时竖条行内 display:none 兜底——此前只靠摘 .on 类走 CSS 隐藏，样式块缺失/被换掉时会变成「当前可书写/清空/退出」的文字条一直钉在右边缘（用户实测的「草稿提示文字残留且固定那个位置」）。行内样式不依赖样式表。 */ if (fpDock && fpDock.el) { fpDock.el.classList.remove('on'); try { fpDock.el.style.display = 'none'; } catch (e2) {} } fpDockSync(); // 会话已空：竖条收起 + 清掉草稿图标高亮 } // 兼容旧调用点（重渲染/宿主报废一律整体退出会话）——fpClose 即 fpExit function fpClose() { fpExit(); } // 宿主被 Angular 重渲染/切题销毁 → 旧画布报废，它占用的整页层必须收掉 function fpCloseIfStale() { if (fpOwner && (!fpOwner.host || !fpOwner.host.isConnected)) fpClose(); } /* ---------- v2.9.0 资料分析「APP 式分栏草稿」（仿粉笔 APP，用户要求） ---------- 形态：顶部一条草稿栏（关闭 / 笔 / 橡皮 / 撤销 / 反撤 / 清空），下面左右两栏各自独立滚动——左栏材料、右栏 5 道子题（共用这一张纸）。笔迹落在「内容坐标系」：画在左栏的随材料滚、画在右栏的随题目滚，两侧互不带动（用户定稿：左右各一张独立画布）。每侧贴一条可拖的滚动滑块，拖动它滚动、不会碰到画布。与现有「整页草稿」并存：面板多一行开关，开了以后点子题的草稿笔图标进这个模式。笔迹自管（不碰粉笔组级草稿，它仍被 neutralizeGroupDraft 隐藏）；橡皮按用户要求先不做，按钮占位禁用。 */ var APP_LS = 'marvis-fp-appmode'; // 面板开关：1 = 草稿笔图标走 APP 式分栏 var APP_ATTR = 'data-marvis-app'; // 组壳标记（CSS 全靠它） var APP_BAR_ID = 'marvis-app-bar'; var APP_SHEET_ID = 'marvis-app-sheet'; // v2.9.17：每题一张的草稿纸（替代 v2.9.11 的答题面板） var APP_SHEET_RECT_LS = 'marvis-app-sheet-rect'; // v2.9.18 的旧存档，v2.9.19 起只读它把位置迁到中档 var APP_SHEET_ALPHA_LS = 'marvis-app-sheet-alpha'; // v2.9.18：纸的不透明度 /* v2.9.18：不透明度四档。用户原话「现在还是有点不够透明」—— 默认从 .90 降到 .70，再往下还有 .52 / .34（.34 时下面的题干基本看得清，写字仍够用）。 */ var SHEET_ALPHAS = [0.85, 0.70, 0.55, 0.42]; var SHEET_ALPHA_DEF = 0.70; var APP_SHEET_SIZE_LS = 'marvis-app-sheet-size'; // v2.9.19：尺寸档位（l / m / s） var APP_SHEET_POS_LS = 'marvis-app-sheet-pos'; // v2.9.19：每档各自记住一个位置 /* v2.9.19：尺寸从「拖手柄自由调」改成三档（用户原话「改成档位吧，默认是最大档，铺满屏幕，还有中档和小档」）。l = 铺满，m = 原来的默认，s = 更小一点。 */ var SHEET_SIZE_TXT = { s: '小', m: '中', l: '大' }; var SHEET_MIN_W = 380, SHEET_MIN_H = 220; // 纸头：题号 + ABCD + 小中大 + 4 颗图标所需宽度 var APP_STYLE_ID = 'marvis-app-style'; var APP_BAR_H = 46; var appCur = null; function appModeOn() { /* v2.9.5：默认开。只有用户显式关过（存了 '0'）才视为关闭 —— 以前是「没存过 = 关」，等于这个功能默认藏起来，用户得先翻面板才能用。 v2.9.27：窄视口（手机 / Via / 平板分屏）硬关 —— 左右分栏 + 材料一屏 + 选项一屏都是按 PC 栏宽设计的，600px 以下算出来的列宽必然挤成一团，开了只会比不开更难用。宽于 600 的平板竖屏（小米平板 800）不受影响。 */ if (padNarrow()) return false; var v = lsGet(APP_LS); return v === null ? true : v !== '0'; } /* ---- v2.9.25 材料一屏 ---- 面板开关：材料比一屏长时整体缩放到刚好放得下，不出现上下滚动条。默认开。只作用于左栏材料内容（缩放套在内容包裹层上，画布叠层不动，写字坐标不受影响）；关掉立刻恢复原样正常滚动。 */ var FITMAT_LS = 'marvis-fp-fitmat'; function fitMatOn() { if (padNarrow()) return false; // v2.9.27：窄屏下缩放只会把字缩到看不清 return lsGet(FITMAT_LS) !== '0'; } /* v2.9.25：右栏「选项一屏」——整组题目等比缩放到一屏内（跟材料同一套机制） */ var FITRIGHT_LS = 'marvis-fp-rightfit'; function fitRightOn() { if (padNarrow()) return false; // v2.9.27：窄屏「选项一屏」会缩出不可读的字号 return lsGet(FITRIGHT_LS) !== '0'; } /* v2.9.9 分栏的唯一交互语义（用户定稿，别再改回去）：「不管手和笔，草稿一打开就只能在纸上写字，不能滑动 / 点击下面那一层内容。」所以两栏内容区的 touch-action 必须是 none： · auto（v2.9.6）= 内核仍可能把笔的拖动当滚动手势 → 笔一落就 pointercancel，笔画只剩 1 个点被丢弃，用户看到的就是「用笔写也变成触摸的了」； · pan-y（v2.9.4）= 更糟，既替浏览器承诺了平移又收不回来，笔和手指一起废； · none = 浏览器在这个容器上完全不做手势滚动，指针流不会被抢走； · 也正因为是 none，内容区不存在任何手势滚动 —— 滚动只有两个入口：左右两侧那两颗滚动条（手指、笔都能拖）。落上来的指针不分 pen / touch / mouse，一律写成笔迹；pointerdown 与合成 click 都在滚动容器捕获层截住，下面的选项 / 收藏错题 / 子题 tab 一个也收不到。 */ var APP_STYLE_VER_ATTR = 'data-marvis-style-ver'; function appStyle() { /* v2.9.39：加版本戳 —— 旧版只看 id 存在就跳过，脚本热更新 / SPA 不刷新时分栏样式永远是上一版那份（主样式块有 STYLE_VER_ATTR、胶囊有 CHIP_STRUCT，只有这条是裸的），以后所有分栏样式改动都白改。版本不符就整块换掉。 */ var oldSt = document.getElementById(APP_STYLE_ID); if (oldSt && oldSt.getAttribute(APP_STYLE_VER_ATTR) === SCRIPT_VER) return; if (oldSt) { try { oldSt.remove(); } catch (e0) {} } var st = document.createElement('style'); st.id = APP_STYLE_ID; st.setAttribute(APP_STYLE_VER_ATTR, SCRIPT_VER); st.textContent = [ /* 组壳：整块钉在顶栏下方，左右两栏各自滚动，不再跟页面滚 */ '.ti[data-marvis-app]{position:fixed!important;left:0!important;right:0!important;', 'top:' + APP_BAR_H + 'px!important;bottom:0!important;height:auto!important;width:auto!important;', 'margin:0!important;z-index:2147482400!important;background:#fff!important;', 'display:flex!important;flex-direction:column!important;min-height:0!important;}', '.ti[data-marvis-app]>app-resizable{display:block!important;flex:1 1 auto!important;min-height:0!important;', 'height:auto!important;position:relative!important;}', /* 用绝对定位铺满：flex 项的高度不是「确定尺寸」，子元素 height:100% 不生效（真机实测：容器算出来是内容高 1650 而不是 817） */ '.ti[data-marvis-app] .resizable-container{display:flex!important;align-items:stretch!important;', 'position:absolute!important;left:0!important;top:0!important;right:0!important;bottom:0!important;', 'height:auto!important;min-height:0!important;}', /* 左栏：材料，独立滚动 */ '.ti[data-marvis-app] .nz-resizable.left{position:static!important;height:auto!important;', 'max-height:none!important;align-self:stretch!important;overflow-y:auto!important;', 'overflow-x:hidden!important;-webkit-overflow-scrolling:auto;', 'overscroll-behavior:contain!important;touch-action:none!important;}', '.ti[data-marvis-app] .left-section{position:relative!important;min-height:100%!important;', 'height:auto!important;overflow:visible!important;}', '.ti[data-marvis-app] .left-part,.ti[data-marvis-app] app-materials,', '.ti[data-marvis-app] .materials-container,.ti[data-marvis-app] .material-body{', 'height:auto!important;max-height:none!important;overflow:visible!important;}', /* 右栏：5 道子题顺排，共用一张纸，独立滚动 */ '.ti[data-marvis-app] .right{height:auto!important;align-self:stretch!important;', 'overflow-y:auto!important;overflow-x:hidden!important;-webkit-overflow-scrolling:auto;', 'overscroll-behavior:contain!important;touch-action:none!important;}', '.ti[data-marvis-app] .right-section,.ti[data-marvis-app] .right-part{', 'position:relative!important;min-height:100%!important;height:auto!important;overflow:visible!important;}', /* 我们自己的两张纸 v2.9.2：pointer-events:none —— 纸只负责显示，不吃任何事件。这样手指能原生滚动两栏、能直接点右边选项，笔由 scroller 上的捕获监听接走。（v2.9.0/2.9.1 踩的坑：纸铺满整栏又吃事件 → 选项点不动、手也滚不动） */ '.ti[data-marvis-app] canvas.marvis-app-ink{position:absolute!important;left:0!important;top:0!important;', /* v2.9.13：z-index 5 → 60。以前题内的注入元素（字母盒 z-index:260）会盖在画布上，笔从旁边写过去，墨迹被整片遮住，看着就是「笔触到那儿就断了」。 v2.9.15：60 → 2147483100 —— 粉笔页面上常驻的透明覆盖层（.modal-overlay / .tooltip-container / sticky 吸顶条）动辄 z-index 1000+，只要有一层压在题目上，墨迹就被整片挡住（用户说的「有东西把我写的字挡住了」）。取 3100 这一档：低于顶栏(3200) / 滚动条(3150) / 答题面板(3300)，高于页面一切元素。 */ 'pointer-events:none!important;touch-action:none!important;z-index:2147483100;}', /* v2.9.13：内容区里的原生控件一个都不参与命中 —— 笔落到题目里的任何位置都是写字。以前落点撞上原生按钮/链接/图标，hit-test 就跑到它们身上，落笔被它们吃掉。 */ '.ti[data-marvis-app] .left-section *,.ti[data-marvis-app] .right-section *{', 'pointer-events:none!important;}', /* 两栏内容不许横向撑破（治「右面被裁剪」：右栏 cw 380 而内容 sw 466，多出来的 86px 被 overflow-x:hidden 切掉） */ '.ti[data-marvis-app] .left-section,.ti[data-marvis-app] .right-section,', '.ti[data-marvis-app] .right-part,.ti[data-marvis-app] .left-part{', 'width:100%!important;max-width:100%!important;min-width:0!important;box-sizing:border-box!important;', 'touch-action:none!important;}', '.ti[data-marvis-app] .left-section *,.ti[data-marvis-app] .right-section *{', 'max-width:100%!important;min-width:0!important;box-sizing:border-box!important;}', /* v2.9.25 修复「选项一屏后右边一大片白」：一屏缩放的包裹层必须按栏宽÷缩放比加宽（scale 完视觉宽才正好铺满栏），上面那条 `* max-width:100%` 会把它钳回栏宽——内容缩完只占左半截，右半全白（真机复现实锤）。包裹层是脚本自己的元素，只在这里放开；退出分栏整条样式随之卸下，不碰外部脚本与粉笔原生结构。选择器多带一层 :nth-child 无意义，用 > 直接子代选择器把特异性抬过上面那条。 */ '.ti[data-marvis-app] .left-section>.marvis-fitmat-wrap,', '.ti[data-marvis-app] .right-section>.marvis-fitmat-wrap{max-width:none!important;}', /* 选项列数自适应（v2.9.25 用户定稿方案C：面积最大化）。列宽由 appOptColsFix() 按每题内容实测决定（短选项一行四个、长选项两列），样式表这里只做进场瞬间的兜底：先铺成可换行的 flex，不锁列数。 */ '.ti[data-marvis-app] .right-section ul.choice-radios{', 'display:flex!important;flex-wrap:wrap!important;column-gap:18px!important;row-gap:.3em!important;}', '.ti[data-marvis-app] .right,.ti[data-marvis-app] .nz-resizable.left{min-width:0!important;}', /* 旧的单题/材料悬浮画布与原生组级草稿：这个模式下全部让位 */ '.ti[data-marvis-app] canvas.marvis-pen{display:none!important;}', '.ti[data-marvis-app] .marvis-cv-tools{display:none!important;}', '.ti[data-marvis-app] .draft-container{display:none!important;}', /* 顶部草稿栏 */ '#marvis-app-bar{position:fixed;left:0;right:0;top:0;height:' + APP_BAR_H + 'px;', 'z-index:2147483200;display:flex;align-items:center;gap:4px;padding:0 8px;', 'background:#fff;border-bottom:1px solid #E3E6EA;box-shadow:0 1px 3px rgba(0,0,0,.05);}', '#marvis-app-bar .mab-btn{display:flex;align-items:center;justify-content:center;', 'width:40px;height:36px;border:0;border-radius:9px;background:transparent;color:#3C464F;padding:0;}', '#marvis-app-bar .mab-btn:active{background:#EFF2F5;}', '#marvis-app-bar .mab-btn.on{color:#2F5BEA;background:#EEF3FF;}', '#marvis-app-bar .mab-btn[disabled]{color:#C6CBD2;}', '#marvis-app-bar .mab-btn svg{width:22px;height:22px;display:block;}', '#marvis-app-bar .mab-sp{flex:1 1 auto;}', '#marvis-app-bar .mab-sep{width:1px;height:22px;background:#E7EAEE;margin:0 3px;}', /* 笔色圆点（v2.9.2：原来的笔色面板在页面 header 上，被这条栏整个盖住了） */ '#marvis-app-bar .mab-dot{width:24px;height:24px;border-radius:50%;border:2px solid transparent;', 'padding:0;margin:0 2px;box-sizing:border-box;box-shadow:inset 0 0 0 1px rgba(0,0,0,.10);flex:0 0 auto;}', '#marvis-app-bar .mab-dot.on{border-color:#2F5BEA;box-shadow:0 0 0 2px rgba(47,91,234,.20);}', /* 粗细：- / 倍率 / + */ '#marvis-app-bar .mab-w{min-width:40px;height:32px;border:0;border-radius:8px;background:transparent;', 'color:#3C464F;font:600 12px/1 -apple-system,"PingFang SC",sans-serif;padding:0 4px;flex:0 0 auto;}', '#marvis-app-bar .mab-w:active{background:#EFF2F5;}', /* v2.9.23：手写开关（防误触例外态）—— 橘色提醒「手掌/手指现在也会落墨」 */ '#marvis-app-bar .mab-btn.hand.on{color:#C9701A;background:#FFF4E8;}', '#marvis-app-bar .mab-wv{min-width:34px;text-align:center;font:600 12px/1 -apple-system,"PingFang SC",sans-serif;', 'color:#8A929B;flex:0 0 auto;}', /* 每侧可拖的滚动滑块（v2.9.2：7px→12px，并加 26px 透明热区，手指才按得住） */ '.marvis-app-thumb{position:fixed;width:12px;border-radius:6px;background:rgba(60,70,79,.30);', 'z-index:2147483150;touch-action:none;display:none;box-sizing:border-box;}', '.marvis-app-thumb::before{content:"";position:absolute;left:-5px;right:-5px;top:-3px;bottom:-3px;}', '.marvis-app-thumb.on{display:block;}', '.marvis-app-thumb.track{background:rgba(60,70,79,.16);}', '.marvis-app-thumb .mab-grip{position:absolute;left:3px;right:3px;top:50%;margin-top:-1px;height:2px;', 'border-radius:1px;background:rgba(255,255,255,.9);}', /* v2.9.13：字母盒在分栏里**彻底隐藏**（用户定稿：那块区域要能写字）。 v2.9.12 曾把它放回来并给了 z-index:260 —— 它盖在画布（z-index:5）上面，两个后果：① 笔落在这块上命中它、不走书写分支，起笔就写不出； ② 从旁边写过来的墨迹被它整片遮住，看着就是「笔触到那儿就断了」。答题入口统一走顶栏题号按钮弹出的面板（#marvis-app-qpop）。粉笔原生的三个工具图标（标记 / 草稿 / 收藏）同样藏起来。 */ '.ti[data-marvis-app] .marvis-lbox{display:none!important;}', /* v2.9.17：题号从「一颗 ▾ 按钮 + 五行的下拉面板」改成「五颗题号按钮」—— 一道题一颗，点谁滚到谁、并把这道题专属的草稿纸浮出来。做成紧凑分段控件：竖屏 iPad（768/810）也放得下。 */ '#marvis-app-bar .mab-qgrp{display:flex;align-items:center;flex:0 0 auto;', 'border:0.5px solid #D8DEE6;border-radius:9px;background:#fff;overflow:hidden;}', '#marvis-app-bar .mab-qn{min-width:34px;height:32px;padding:0 6px;border:0;border-radius:0;', 'background:transparent;color:#5F6670;font:600 11.5px/1 -apple-system,"PingFang SC",sans-serif;', 'display:flex;align-items:center;justify-content:center;flex:0 0 auto;}', '#marvis-app-bar .mab-qn+.mab-qn{border-left:0.5px solid #E7EAEE;}', '#marvis-app-bar .mab-qn.on{background:#EEF3FF;color:#2F5BEA;}', '#marvis-app-bar .mab-qn:active{background:#EFF2F5;}', /* v2.9.17 草稿纸：浮在右栏上，半透明白；v2.9.18 起不透明度可调（--mas-a / --mas-ha） */ '#' + APP_SHEET_ID + '{position:fixed;z-index:2147483080;display:none;flex-direction:column;', '--mas-a:.70;--mas-ha:.80;box-sizing:border-box;', 'background:rgba(255,255,255,var(--mas-a));border:1px solid rgba(60,70,79,.18);border-radius:12px;', 'box-shadow:0 8px 26px rgba(24,32,45,.16);overflow:hidden;', /* v2.9.28：整张草稿纸 touch-action:none。 v2.9.27 只给纸头(.mas-head)和 canvas 加了，纸身(.mas-body)漏了。Android WebView 里笔尖落纸拖动时，内核默认把它当滚动手势 → 一旦仲裁成功就 pointercancel，用户写不到两三个字就断（「只能写短线」）。touch-action:none 从 CSS 源头声明「这块不接受滚动/缩放手势」，内核就不会为这串指针做手势仲裁，笔程不再被打断。 */ 'touch-action:none!important;}', '#' + APP_SHEET_ID + '.on{display:flex;}', /* v2.9.19：大档 = 铺满，此时去掉圆角、边框、阴影，看着就是一张整纸 */ '#' + APP_SHEET_ID + '.mas-full{border:0;border-radius:0;box-shadow:none;}', '#' + APP_SHEET_ID + '.mas-full .mas-head{padding-left:14px;}', '#' + APP_SHEET_ID + '.mas-full .mas-body{border-radius:0;}', /* v2.9.21：纸头改成「一行装得下就一行，装不下才换行」—— 用户原话「小中大/透明度/撤销/反撤/删除/收藏标记这一排为什么换行了？除了最小的那个放不开，中和大应该都放得开呀」。 v2.9.20 是硬写死两行，中/大档明明有地方也被折成两行。现在：h1（题号 + ABCD）与 h2（工具条）都是 head 的 flex 子项 + flex-wrap， h2 的 min-content 装得下就跟在 h1 后面（一行），装不下才落到第二行（只有小档会）。 × 放在 h2 末尾 —— 一行时它就在最右边，两行时落在第二行右端。 */ '#' + APP_SHEET_ID + ' .mas-head{display:flex;flex-wrap:wrap;align-items:center;', 'column-gap:3px;row-gap:0;flex:0 0 auto;padding:4px 4px 4px 10px;', 'background:rgba(255,255,255,var(--mas-ha));', 'border-bottom:1px solid rgba(60,70,79,.10);touch-action:none;}', '#' + APP_SHEET_ID + ' .mas-h1{display:flex;align-items:center;gap:3px;height:32px;flex:0 0 auto;}', '#' + APP_SHEET_ID + ' .mas-h2{display:flex;align-items:center;gap:3px;height:32px;', 'flex:1 1 auto;min-width:0;}', '#' + APP_SHEET_ID + ' .mas-vs{width:1px;height:15px;flex:0 0 auto;margin:0 1px;', 'background:#D3DDF2;}', '#' + APP_SHEET_ID + ' .mas-t:disabled{opacity:.32;}', '#' + APP_SHEET_ID + ' .mas-num{font:600 12px/1 -apple-system,"PingFang SC",sans-serif;', 'color:#3C464F;margin-right:1px;flex:0 0 auto;}', /* v2.9.21：纸头上的框线统一成蓝色（用户：以前是蓝色框线，跟顶栏一致更好看） */ '#' + APP_SHEET_ID + ' .mas-l{width:28px;height:26px;flex:0 0 auto;padding:0;border-radius:6px;', 'border:1.5px solid #BFD0F4;background:#fff;color:#2F5BEA;', 'font:600 13px/1 -apple-system,"PingFang SC",sans-serif;}', '#' + APP_SHEET_ID + ' .mas-l.sel{background:#1B3A82;border-color:#1B3A82;color:#fff;}', '#' + APP_SHEET_ID + ' .mas-l.ok{background:#2E9E5B;border-color:#2E9E5B;color:#fff;}', '#' + APP_SHEET_ID + ' .mas-l.bad{background:#E24B4A;border-color:#E24B4A;color:#fff;}', '#' + APP_SHEET_ID + ' .mas-l:active{transform:scale(.94);}', '#' + APP_SHEET_ID + ' .mas-t{width:25px;height:26px;flex:0 0 auto;padding:0;border:0;border-radius:7px;', 'background:transparent;color:#2F5BEA;display:flex;align-items:center;justify-content:center;}', '#' + APP_SHEET_ID + ' .mas-t:active{background:#E4ECFF;}', '#' + APP_SHEET_ID + ' .mas-t svg{width:18px;height:18px;display:block;}', '#' + APP_SHEET_ID + ' .mas-sp{flex:1 1 auto;min-width:0;}', '#' + APP_SHEET_ID + ' .mas-body{position:relative;flex:1 1 auto;overflow:hidden;', 'touch-action:none!important;border-radius:0 0 12px 12px;}', '#' + APP_SHEET_ID + ' canvas.mas-ink{position:absolute;left:0;top:0;width:100%;height:100%;', 'pointer-events:none;touch-action:none;display:block;}', /* v2.9.19：尺寸三档（小 / 中 / 大）—— 分段控件，跟顶栏题号那颗同一种做法 */ '#' + APP_SHEET_ID + ' .mas-sz{display:flex;align-items:center;flex:0 0 auto;', 'border:0.5px solid #BFD0F4;border-radius:7px;background:#fff;overflow:hidden;}', '#' + APP_SHEET_ID + ' .mas-szb{width:21px;height:24px;padding:0;border:0;border-radius:0;', 'background:transparent;color:#2F5BEA;', 'font:600 11.5px/1 -apple-system,"PingFang SC",sans-serif;}', '#' + APP_SHEET_ID + ' .mas-szb+.mas-szb{border-left:0.5px solid #D3DDF2;}', '#' + APP_SHEET_ID + ' .mas-szb.on{background:#EEF3FF;color:#2F5BEA;}', '#' + APP_SHEET_ID + ' .mas-szb:active{background:#E4ECFF;}', '#' + APP_SHEET_ID + ' .mas-t.on{background:#EEF3FF;color:#2F5BEA;}', /* v2.9.20：标记 / 收藏一旦「已标记 / 已收藏」就把图标填成实心 —— 用户原话「点了以后没有一点互动的感觉，应该填充成实心的，就算是我标记上了」。原生 li.mark.tool / li.collect.tool 上会挂 .active（chunk-EYRW5JFG： _e("active", ques.marked_ / ques.collected_)），纸头按它同步这个 .on。 */ '#' + APP_SHEET_ID + ' .mas-t.on svg path{fill:currentColor;}', /* 内容区里那三个图标（标记/草稿/收藏）在分栏里也点不动，一起收进面板 */ '.ti[data-marvis-app] li.mark.tool,.ti[data-marvis-app] li.draft.tool,', '.ti[data-marvis-app] li.collect.tool{display:none!important;}' ].join(''); (document.head || document.documentElement).appendChild(st); } /* ---- 笔迹存储 ---- 两套历史，互不干扰： · `acts` = 左右两栏那张纸（同一条撤销栈，v2.9.x 老语义，别动） · `sheets` = v2.9.17 每题一张的草稿纸，键是题号（"116."），各自独立撤销栈 —— 不分开的话，在 117 的纸上点撤销会撤掉 116 的一笔（看不见），用户会以为撤销坏了。 */ function appStoreKey(key) { return 'marvis-app-draft:' + key; } function appLoad(key) { try { var raw = lsJSON(appStoreKey(key)); if (raw && raw.acts && typeof raw.acts.length === 'number') { var sheets = {}; if (raw.sheets && typeof raw.sheets === 'object') { for (var k in raw.sheets) { if (!raw.sheets.hasOwnProperty(k)) continue; var sh = raw.sheets[k]; if (sh && sh.acts && typeof sh.acts.length === 'number') { sheets[k] = { acts: sh.acts, at: Math.max(0, Math.min(sh.acts.length, sh.at | 0)) }; } } } return { acts: raw.acts, at: Math.max(0, Math.min(raw.acts.length, raw.at | 0)), sheets: sheets }; } } catch (e) {} return { acts: [], at: 0, sheets: {} }; } function appSaveSoon() { if (!appCur) return; if (appCur.saveTimer) clearTimeout(appCur.saveTimer); appCur.saveTimer = setTimeout(function () { if (!appCur) return; try { lsSet(appStoreKey(appCur.key), JSON.stringify({ acts: appCur.acts, at: appCur.at, sheets: appCur.sheets || {} })); } catch (e) {} }, 400); } /* ---- 画法：Catmull-Rom 转三次贝塞尔（与整页草稿共用 crSegment，见⑤） ---- */ function appSeg(ctx, p0, p1, p2, p3) { crSegment(ctx, p0[0], p0[1], p1[0], p1[1], p2[0], p2[1], p3[0], p3[1]); } function appStroke(ctx, pts, color, w) { var n = pts.length; if (n < 2) return; ctx.strokeStyle = color; ctx.lineWidth = w; ctx.lineCap = 'round'; ctx.lineJoin = 'round'; if (n < 4) { ctx.beginPath(); ctx.moveTo(pts[0][0], pts[0][1]); for (var i = 1; i < n; i++) ctx.lineTo(pts[i][0], pts[i][1]); ctx.stroke(); return; } for (var j = 0; j + 1 < n; j++) { appSeg(ctx, pts[j > 0 ? j - 1 : 0], pts[j], pts[j + 1], pts[j + 2 < n ? j + 2 : n - 1]); } } function appRenderSide(side) { var s = appCur && appCur.sides[side]; if (!s || !s.cv) return; var cv = s.cv, ctx = s.ctx, dpr = s.dpr || 1; ctx.setTransform(1, 0, 0, 1, 0, 0); ctx.clearRect(0, 0, cv.width, cv.height); ctx.setTransform(dpr, 0, 0, dpr, 0, 0); for (var i = 0; i < appCur.at; i++) { var a = appCur.acts[i]; if (a.t === 'clear') { ctx.setTransform(1, 0, 0, 1, 0, 0); ctx.clearRect(0, 0, cv.width, cv.height); ctx.setTransform(dpr, 0, 0, dpr, 0, 0); continue; } if (a.side !== side) continue; /* v2.9.32：橡皮笔程重放（撤销栈里它是一条普通 act，撤掉就恢复墨迹） */ if (a.t === 'erase') { penErasePath(ctx, a.pts, a.w || penEraserR()); continue; } appStroke(ctx, a.pts, a.color, a.w); } /* v2.9.10：正在写的这一笔还没进 acts，重绘必须把它一起补上 —— 否则任何一次重绘（画布尺寸变化、页面重渲染）都会把「写到一半的笔迹」整条抹掉，用户看到的就是笔迹消失、剩下的半截像是断触。 */ var live = appCur.stroke; if (live && !live.dead && live.side === side && live.pts && live.pts.length > 1) { if (live.t === 'erase') penErasePath(ctx, live.pts, live.w || penEraserR()); else appStroke(ctx, live.pts, live.color, live.w); } } /* v2.9.17：每题草稿纸的历史（键 = 题号）。没有就现建一个空栈。 */ function appSheetHist(num) { if (!appCur) return null; var k = num || appCur.sheetSub; if (!k) return null; if (!appCur.sheets) appCur.sheets = {}; if (!appCur.sheets[k]) appCur.sheets[k] = { acts: [], at: 0 }; return appCur.sheets[k]; } function appRenderSheet() { var s = appCur && appCur.sides.sheet; if (!s || !s.cv || !appCur.sheetOpen) return; var cv = s.cv, ctx = s.ctx, dpr = s.dpr || 1; ctx.setTransform(1, 0, 0, 1, 0, 0); ctx.clearRect(0, 0, cv.width, cv.height); ctx.setTransform(dpr, 0, 0, dpr, 0, 0); var h = appSheetHist(); if (h) { for (var i = 0; i < h.at; i++) { var a = h.acts[i]; if (!a) continue; if (a.t === 'clear') { ctx.setTransform(1, 0, 0, 1, 0, 0); ctx.clearRect(0, 0, cv.width, cv.height); ctx.setTransform(dpr, 0, 0, dpr, 0, 0); continue; } if (a.t === 'erase') { penErasePath(ctx, a.pts, a.w || penEraserR()); continue; } // v2.9.32 appStroke(ctx, a.pts, a.color, a.w); } } var live = appCur.stroke; // 在写的这一笔也要补上（同 v2.9.10 的老坑） if (live && !live.dead && live.side === 'sheet' && live.pts && live.pts.length > 1) { if (live.t === 'erase') penErasePath(ctx, live.pts, live.w || penEraserR()); else appStroke(ctx, live.pts, live.color, live.w); } } function appRedraw() { if (!appCur) return; appRenderSide('left'); appRenderSide('right'); appRenderSheet(); } /* ---- 尺寸（内容坐标系：画布铺满整段可滚内容） ---- v2.9.15：真凶找到了 —— 高度一直量的是「宿主那一层」，而宿主在粉笔这套 flex 布局里会被压成一屏高（height:auto + flex-shrink:1，内容溢出但不撑高 scrollHeight）。于是画布只有一屏高：第一屏能写，往下滚到第 117/118 题再写，点全都落在画布外面，墨迹根本不显示 —— 用户看到的就是「那块没有草稿覆盖 / 像被什么挡住了」。现在改成量「真实内容最底部」：一路往最后一个可见后代钻，取它的 bottom。 */ function appContentBottom(host, skip) { if (!host) return 0; var base; try { base = host.getBoundingClientRect().top; } catch (e) { return 0; } var el = host, guard = 0, next; while (el && guard++ < 80) { next = null; for (var i = el.children.length - 1; i >= 0; i--) { var c = el.children[i]; if (c === skip) continue; if (c.classList && c.classList.contains('marvis-app-ink')) continue; if (c.classList && c.classList.contains('marvis-app-thumb')) continue; var r; try { r = c.getBoundingClientRect(); } catch (e2) { continue; } if (r && r.height > 0.5) { next = c; break; } } if (!next) break; el = next; } var rb; try { rb = el.getBoundingClientRect(); } catch (e3) { return 0; } /* bottom 是相对视口的，减掉宿主 top 就是「相对画布原点」的偏移；两者一起滚动，所以这个差值不受 scrollTop 影响。底部再留 80px 空白区，最后一行下面照样能写。 */ return Math.max(0, Math.round(rb.bottom - base + APP_BOTTOM_PAD)); } function appSizeSide(side) { var s = appCur && appCur.sides[side]; if (!s || !s.cv || !s.host) return; var w = Math.max(1, Math.round(s.host.offsetWidth || s.host.getBoundingClientRect().width)); var prevH = s.cv.style.height; s.cv.style.height = '0px'; var need = appContentBottom(s.host, s.cv); /* 高度上限：防某个 position:fixed 的后代把「内容底部」撑到天上去 */ need = Math.min(need, 20000); var h = Math.max(1, Math.round(Math.max( need, // 真实内容最底部（v2.9.15 主口径） s.host.scrollHeight || 0, s.host.offsetHeight || 0, s.scroller ? s.scroller.clientHeight : 0, s.scroller ? (s.scroller.scrollHeight || 0) : 0 ))); s.cv.style.height = prevH; /* iOS/Safari 的 canvas 面积上限约 16.7M 像素，超了整个位图会被静默丢弃（画布全白）。画布现在铺满整段内容，长题很容易逼近上限 → 超了就退回 1x。 */ var dpr = Math.min(2, window.devicePixelRatio || 1); while (dpr > 1 && w * dpr * h * dpr > 12e6) dpr = dpr > 1.5 ? 1.5 : 1; var cw = Math.round(w * dpr), chh = Math.round(h * dpr); if (s.cv.width === cw && s.cv.height === chh && s.cv.style.width === w + 'px') return; s.dpr = dpr; s.cv.width = cw; s.cv.height = chh; s.cv.style.width = w + 'px'; s.cv.style.height = h + 'px'; appRenderSide(side); // 改尺寸会清空位图 → 重画 } function appSizeAll() { if (!appCur) return; appSizeSide('left'); appSizeSide('right'); } /* ---- v2.9.3 自适应列宽；v2.9.25 起全自动 ---- 不写死比例，按「屏幕宽度 + 这一组内容长什么样」现算： · 屏越窄越把空间让给题目（iPad 竖屏是最挤的场景） · 材料里有图/表 → 左边多给一点（图表挤窄了就得左右滚） · 选项文字被折成很多行 → 右边多给一点（选项一长，少一行就是少滚半屏） v2.9.25：进分栏永远自动自适应，删掉顶栏「⇔」按钮和手动比例记忆（旧版里笔迹收尾碰分隔条会被误记成手动列宽，是「点了没反应」的根源）。顺手清掉老版本留在 localStorage 里的手动比例。 */ lsRemove('marvis-app-cols'); /* 右栏「最长的那条选项」在宽度 Wr 下会折成几行。不量渲染高度（li 带内边距，量出来恒偏大），而是用一个 nowrap 探针量这段文字的【自然单行宽度】，再除以可用宽度 —— 结果只取决于「文字」和「给定宽度」，与当前实际列宽无关，所以不会出现「越调越宽/越窄」的反馈漂移。 */ function appOptNeedLines(R, Wr) { var lis = R.querySelectorAll('app-choice-radio li.choice-radio, .question-choice-container li'); if (!lis.length) return 0; var longest = ''; for (var i = 0; i < lis.length && i < 8; i++) { var t = (lis[i].innerText || '').replace(/\s+/g, ' ').trim(); if (t.length > longest.length) longest = t; } if (!longest) return 0; var probe = document.createElement('span'); probe.textContent = longest; probe.style.cssText = 'position:absolute;left:-99999px;top:0;white-space:nowrap;' + 'visibility:hidden;font:inherit;letter-spacing:inherit;'; R.appendChild(probe); var w = 0; try { w = probe.getBoundingClientRect().width; } catch (e) {} probe.remove(); if (!w) return 0; var avail = Math.max(60, Wr - 46); // 减掉 ABCD 标号那一列 return w / avail; } /* 材料里有没有「真的占地方的」图表：跳过 20px 的格式小图标 */ function appMaterialHasFigure(L) { var els = L.querySelectorAll('img, svg, table'); for (var i = 0; i < els.length && i < 40; i++) { var r = els[i].getBoundingClientRect(); if (r.width > 120 && r.height > 60) return true; } return false; } function appAutoRatio(W, L, R) { var r = W < 720 ? 0.40 : (W < 900 ? 0.43 : (W < 1200 ? 0.46 : 0.48)); /* v2.9.25（用户定稿）：材料一屏开着时材料反正整体缩放、不缺宽，左栏往窄收一截，把宽度让给右栏选项区（选项少折行、少滚动） */ if (fitMatOn()) r -= 0.05; try { if (appMaterialHasFigure(L)) r += 0.04; // 图表类材料要给宽 if (L.querySelector('table')) r += 0.02; // 表格最怕窄 } catch (e) {} if (r < 0.30) r = 0.30; if (r > 0.60) r = 0.60; // 第二遍：按「r 对应的右栏宽度」估算最长选项要折几行，太挤就再让一点 var lines = 0; try { lines = appOptNeedLines(R, W - Math.round(W * r) - 4); } catch (e) {} if (lines >= 3.4) r -= 0.05; else if (lines >= 2.4) r -= 0.03; if (r < 0.30) r = 0.30; if (r > 0.60) r = 0.60; return r; } function appApplyCols() { if (!appCur) return; var g = appCur.group; var cont = g.querySelector('.resizable-container'); var L = g.querySelector('.nz-resizable.left'); var R = g.querySelector('.right'); if (!cont || !L || !R) return; var W = cont.clientWidth || Math.round(cont.getBoundingClientRect().width); if (W < 240) return; var ratio = appAutoRatio(W, L, R); var gap = 4; // 两栏之间的分隔条 var minSide = Math.max(200, Math.min(Math.round(W * 0.28), 380)); var lw = Math.round(W * ratio); if (lw < minSide) lw = minSide; if (W - lw - gap < minSide) lw = W - minSide - gap; var rw = W - lw - gap; if (rw < 120) return; appCur.colW = { l: lw, r: rw }; // 粉笔给左栏写过 width:1143px 这类行内值（按它自己 1905 宽的桌面容器算的）， // 必须用行内 !important 压回去，否则用我们的 px 会被它盖掉 L.style.setProperty('width', lw + 'px', 'important'); L.style.setProperty('flex', '0 0 ' + lw + 'px', 'important'); R.style.setProperty('width', rw + 'px', 'important'); R.style.setProperty('flex', '0 0 ' + rw + 'px', 'important'); R.style.setProperty('min-width', '0px', 'important'); } /* 列宽算好后尺寸会变 → 画布、滑块都要重算 */ function appFitCols() { if (!appCur) return; appApplyCols(); appSizeAll(); appFitMat(); appRedraw(); appSyncThumbs(); } /* ---- v2.9.25 材料一屏：把左栏材料整体缩放到一屏内 ---- 做法：把 host 里除画布外的内容搬进一个包裹层，量出「内容自然高 / 视口高」，超出就等比 scale + 反向加宽，文字图表一起变小但完整可见；内容不比一屏长时不动。 */ function appFitMatWrapOf(s) { if (!s || !s.host) return null; var kids = s.host.children; for (var i = 0; i < kids.length; i++) { if (kids[i].classList && kids[i].classList.contains('marvis-fitmat-wrap')) return kids[i]; } return null; } function appFitScaleOf(s) { var wrap = s && appFitMatWrapOf(s); if (!wrap || !wrap.style.transform) return 1; var m = wrap.style.transform.match(/scale$([\d.]+)$/); return m ? parseFloat(m[1]) : 1; } function appFitMatUnwrap(s) { var wrap = s && appFitMatWrapOf(s); if (!wrap) return; appFitMatRestoreChildren(wrap); wrap.style.transform = ''; wrap.style.width = ''; wrap.style.transformOrigin = ''; var ro = s.__fitRO; if (ro) { try { ro.disconnect(); } catch (e) {} s.__fitRO = null; } while (wrap.firstChild) wrap.parentNode.insertBefore(wrap.firstChild, wrap); try { wrap.remove(); } catch (e) {} } /* v2.9.25 修复「材料区右边一大块空白」：粉笔给材料内层写死了固定 px 宽度（跟左栏 1143px 一个路数），包裹层加宽后内层纹丝不动，内容全挤在左半边。缩放前把直接子元素的宽度一并拉到目标宽，并记下原值好还原。 */ function appFitMatStretch(wrap, wpx) { var kids = wrap.children; for (var j = 0; j < kids.length; j++) { var k = kids[j]; if (k.getAttribute('data-marvis-origw') === null) { k.setAttribute('data-marvis-origw', k.style.width || ''); } k.style.width = wpx; } } function appFitMatRestoreChildren(wrap) { var kids = wrap.children; for (var j = 0; j < kids.length; j++) { var ow = kids[j].getAttribute('data-marvis-origw'); if (ow !== null) { kids[j].style.width = ow; kids[j].removeAttribute('data-marvis-origw'); } } } function appFitMatSide(s) { if (!s || !s.host) return; var host = s.host; var wrap = appFitMatWrapOf(s); if (!wrap) { /* 首次：把除画布外的子节点搬进包裹层（画布留在外面，坐标不受缩放影响） */ wrap = document.createElement('div'); wrap.className = 'marvis-fitmat-wrap'; var kids = [].slice.call(host.children); for (var i = 0; i < kids.length; i++) { var k = kids[i]; if (k.classList && (k.classList.contains('marvis-app-ink') || k.classList.contains('marvis-fitmat-wrap'))) continue; wrap.appendChild(k); } host.appendChild(wrap); wrap.style.transformOrigin = '0 0'; /* 内容后来变高（图片加载、切题重渲染）→ 重算一次（防抖到下一帧） */ if (window.ResizeObserver && !s.__fitRO) { s.__fitRO = new ResizeObserver(function () { if (!appCur || appCur.stroke) return; // 正在写字时不折腾 /* v2.9.25 防振荡：进场/转窗后 3.5s 内允许跟着内容重算，之后冻结。不冻的话两边互触死循环：一页成卷重排选项 → 高度变 → 这里重算 → 包裹层宽度变 → 它量到的可用宽变 → 它再重写 → 高度再变…… 冻结后它的测量签名不再变化、重写自动停，选项两列即成最终态。 */ if (Date.now() - (appCur.fitWindow || 0) > 3500) return; if (s.__fitRaf) return; s.__fitRaf = requestAnimationFrame(function () { s.__fitRaf = 0; appFitMat(); }); }); s.__fitRO.observe(wrap); } } var W = host.clientWidth, H = host.clientHeight; if (W < 120 || H < 80) return; /* 迭代求缩放比：加宽会让文字回流变矮，量一次算一次会留空白（v2.9.25 首版的坑），量→缩→再量→再缩，收敛到内容刚好填满一屏；每轮同步把内层宽度拉满 */ wrap.style.transform = 'none'; var scale = 1, fits = false; for (var it = 0; it < 6; it++) { var wpx = Math.round(W / scale) + 'px'; wrap.style.width = wpx; appFitMatStretch(wrap, wpx); var ch = wrap.scrollHeight; if (ch <= H + 2) { fits = true; break; } var ns = H / ch; if (Math.abs(ns - scale) < 0.004) { scale = ns; fits = false; break; } scale = ns; } if (fits && scale === 1) { // 本来就放得下 → 还原，不留缩放 wrap.style.transform = ''; wrap.style.width = ''; appFitMatRestoreChildren(wrap); return; } wrap.style.width = Math.round(W / scale) + 'px'; wrap.style.transform = 'scale(' + scale.toFixed(4) + ')'; } /* v2.9.41：右栏「选项一屏」是否实际生效 —— 字号 >100% 时让位（见 appFitMat）。总入口与 700ms 看门狗共用同一判定，避免「开关开着、适应却没了」的口径分裂。 */ function fitRightActive() { return fitRightOn() && fontZoomGet() <= 1.001; } /* 总入口：左栏「材料一屏」+ 右栏「选项一屏」，各自开关独立 */ function appFitMat() { if (!appCur) return; if (fitMatOn()) appFitMatSide(appCur.sides && appCur.sides.left); else appFitMatUnwrap(appCur.sides && appCur.sides.left); /* v2.9.41：字号 >100% 是用户明确的「字要这么大」。旧版适应按放大后的内容高重算缩小比，字号放大多少、缩小比就再降多少，两相抵消（五道子题顺排内容远超一屏，字号在右栏形同虚设）。现在字号 >100% 时右栏不再自动缩小凑一屏：按所选字号排版，超出部分走两侧滑块滚动；字号回到 ≤100% 才恢复一屏适应。 */ if (fitRightActive()) appFitMatSide(appCur.sides && appCur.sides.right); else appFitMatUnwrap(appCur.sides && appCur.sides.right); } /* ---- v2.9.25 右栏选项列数自适应（用户定稿方案C：面积最大化） ---- 目标：不管装不装一页成卷，分栏内每道题的选项都按面积最大化排 —— 短选项（A.7 B.6 C.5 D.4）自动一行四个，长选项自动两列，右边不留大片空白；一行放得下就绝不折成两行（折行只省宽、不省面积，还多占一行高）。做法：对每道题的选项列表逐个试 cols = N..1，真实排一次版、量容器高度，取总高最小的那一种（高度相同时取能整除的、列数多的）。一页成卷给选项写的是行内 !important，样式表打不过 —— 只能以行内制行内：进分栏时写行内 !important（原 style 记在 data-marvis-optcol），退出分栏原样还回。只动分栏内这一份，不碰外部脚本的 DOM 结构。 */ var OPTCOL_ATTR = 'data-marvis-optcol'; var OPTC_GAP = 18; function optcSet(el, prop, val) { if (el.style.getPropertyValue(prop) === val && el.style.getPropertyPriority(prop) === 'important') return; el.style.setProperty(prop, val, 'important'); } function optcBasis(cols) { if (cols <= 1) return '100%'; return 'calc(' + (100 / cols).toFixed(4) + '% - ' + (OPTC_GAP * (cols - 1) / cols).toFixed(2) + 'px)'; } /* 按 cols 列排一次（同步重排，浏览器不绘制中间态） */ function optcLayout(ul, lis, cols) { var b = optcBasis(cols); for (var i = 0; i < lis.length; i++) { optcSet(lis[i], 'flex', '0 0 ' + b); /* 一页成卷的 hardenOpts 给选项写死 width / max-width:列宽px —— max-width 会把我们的 flex-basis 钳回它的列宽（实测四列 305px），必须放开 */ optcSet(lis[i], 'width', 'auto'); optcSet(lis[i], 'max-width', 'none'); optcSet(lis[i], 'box-sizing', 'border-box'); } } /* 试遍列数，取「总高度最小」的排法 —— 高度最小 = 空白最少 = 面积利用最大；高度打平时再比「文字总行数」（少者优先，避免同高却把选项折得稀碎，实例：'上升了3个百分点以上' 四列会折成两行、两列一行正好放下）；再平取整除、列多的 */ function optcPick(ul, lis) { var n = lis.length, best = 1, bestH = Infinity, bestLines = Infinity, bestExact = false; var lh = parseFloat(getComputedStyle(lis[0]).lineHeight) || 0; var maxCols = Math.min(n, 4); for (var c = maxCols; c >= 1; c--) { optcLayout(ul, lis, c); var h = ul.getBoundingClientRect().height || ul.offsetHeight || 0; var lines = 0; if (lh > 0) { for (var i = 0; i < lis.length; i++) { lines += Math.max(1, Math.round(lis[i].scrollHeight / lh)); } } var exact = n % c === 0; if (h > 0 && ( bestH === Infinity || h < bestH - 0.6 || /* 高差在一行文本以内时行数少者优先（row-gap 常让折行排法反而矮几像素，纯比高会把 '上升了3个百分点以上' 这类选项折成两行） */ (Math.abs(h - bestH) <= Math.max(0.6, lh * 0.8) && lines < bestLines - 0.5) || (Math.abs(h - bestH) <= 0.6 && exact && !bestExact))) { best = c; bestH = h; bestLines = lines; bestExact = exact; } } return best; } /* v2.9.25：进场为「不闪」而临时藏起来的右栏，等布局连续两帧稳定再放出来（最多等 600ms 兜底）。判据用 scrollWidth×scrollHeight —— 列数、缩放、图片加载任何一项还在变，尺寸就不会连续相同，也就不会提前放行。 */ function appReveal(host) { if (!host) return; var t0 = Date.now(), lastKey = '', same = 0; function step() { if (!host.isConnected) return; var key = host.scrollWidth + 'x' + host.scrollHeight; if (key === lastKey) same++; else { same = 0; lastKey = key; } if (same >= 1 || Date.now() - t0 > 600) { host.style.removeProperty('visibility'); return; } requestAnimationFrame(step); } requestAnimationFrame(step); } /* 列容器公共样式（幂等写：值没变就不写，避免自触发 mutation） */ function optcSetUl(ul) { optcSet(ul, 'display', 'flex'); optcSet(ul, 'flex-wrap', 'wrap'); optcSet(ul, 'column-gap', OPTC_GAP + 'px'); optcSet(ul, 'row-gap', '.3em'); } /* 一页成卷（以及粉笔本体）也会往这些选项上写行内列宽，两边互相覆盖 —— 这就是「选项自己排好几下版」的主因（实测进场后 3.6 秒里被改回去十来次）。它一写我们就改回来：MutationObserver 回调跑在微任务里，浏览器还没绘制就被覆盖，所以它的排法永远上不了屏。写入幂等，不会互相触发。 */ function optcGuard(ul, lis) { if (ul.__marvisGuard) return; var mo = new MutationObserver(function () { if (!appCur || !ul.isConnected) { try { mo.disconnect(); } catch (e) {} ul.__marvisGuard = null; return; } optcSetUl(ul); if (ul.__marvisCols) optcLayout(ul, lis, ul.__marvisCols); }); mo.observe(ul, { attributes: true, attributeFilter: ['style'], subtree: true }); ul.__marvisGuard = mo; } function appOptColsSide(s, force) { if (!s || !s.host) return; var hostW = Math.round(s.host.clientWidth || 0); var uls = s.host.querySelectorAll('ul.choice-radios, ul[class*="choice"]'); for (var i = 0; i < uls.length; i++) { var ul = uls[i]; if (ul.getAttribute(OPTCOL_ATTR) === null) { ul.setAttribute(OPTCOL_ATTR, ul.getAttribute('style') || ''); } optcSetUl(ul); var lis = []; for (var j = 0; j < ul.children.length; j++) { if (ul.children[j].tagName === 'LI') lis.push(ul.children[j]); } if (!lis.length) continue; for (var k = 0; k < lis.length; k++) { if (lis[k].getAttribute(OPTCOL_ATTR) === null) { lis[k].setAttribute(OPTCOL_ATTR, lis[k].getAttribute('style') || ''); } } /* 测量前提：进场时先算列数、再算缩放（此时包裹层还没加宽），量到的就是最终视觉比例；缩放之后一律走上面的缓存，不再重新量 —— 否则同一道题在加宽坐标系里会算出一个不同的答案，看着就是排版自己变。转屏改栏宽时由 appOnResize 先拆包裹层再重算。决策记忆 = 「第几个选项列表 + 各选项文字长度」，存在 appCur 上、不挂在节点上 —— Angular 重渲染会换掉节点，挂节点上的缓存随之丢失、只好重算一遍（表现就是跳版）；存在组级对象上，换节点也照样命中。栏宽 ±4px 以内不重算。 */ var baseW = hostW || Math.round(ul.clientWidth || 0); /* v2.9.29：看门狗每 700ms 都会跑一遍这里；旧版在查缓存前就要把全部选项的 textContent 串一遍（110 题 × 4 选项的 DOM 序列化，纯浪费）。同代际（内容无任何变化）且栏宽没变 → 列数必然不变，直接跳过指纹与重排；内容变化由内容监听换代（appMarkDirty 里 bump optcGen，含 Angular 就地改文本节点）、转窗改栏宽走 appOnResize、force 重算都落回原路径。 */ if (!force && ul.__marvisCols && ul.__marvisLastW === baseW && appCur && ul.__marvisOptcGen === appCur.optcGen) { continue; } ul.__marvisLastW = baseW; if (appCur) ul.__marvisOptcGen = appCur.optcGen; var fp = lis.map(function (li) { return (li.textContent || '').replace(/\s+/g, '').length; }).join(','); var memoKey = i + '|' + fp; var store = appCur && appCur.optcMemo; var memo = store && !force ? store[memoKey] : null; var cols; if (!baseW) { cols = Math.min(2, lis.length); // 还没布局出来：先按两列占位 } else if (memo && memo.cols && Math.abs(baseW - memo.baseW) <= 4) { cols = memo.cols; } else { cols = optcPick(ul, lis); if (store) store[memoKey] = { cols: cols, baseW: baseW }; } ul.__marvisCols = cols; optcLayout(ul, lis, cols); optcGuard(ul, lis); } } function appOptColsFix(force) { if (!appCur) return; appOptColsSide(appCur.sides && appCur.sides.right, force); } function appOptColsRestore(scope) { try { [].slice.call((scope || document).querySelectorAll('[' + OPTCOL_ATTR + ']')) .forEach(function (el) { if (el.__marvisGuard) { try { el.__marvisGuard.disconnect(); } catch (e) {} el.__marvisGuard = null; } el.__marvisCols = 0; var saved = el.getAttribute(OPTCOL_ATTR); if (saved) el.setAttribute('style', saved); else el.removeAttribute('style'); el.removeAttribute(OPTCOL_ATTR); }); } catch (e) {} } /* v2.9.25：删除了「手拖分隔条记住比例」的监听（appWatchSplitter）—— 它只听 pointerup 不校验是否真的拖过，笔迹收尾碰分隔条就会被静默写入手动列宽；且手动模式已整体移除，列宽永远自动。 */ /* ---- 左栏的行内 !important 只能由 JS 覆盖（样式表 !important 打不过行内 !important） ---- 实测：粉笔会在 800ms 内把 position:sticky 等再写回去，所以除了开机时改一次，还挂一条 MutationObserver 盯着 style 属性，被改回就立刻按住。 */ function appInlineNeedFix(L) { return L.style.getPropertyValue('position') !== 'static' || L.style.getPropertyValue('align-self') !== 'stretch' || L.style.getPropertyValue('max-height') !== 'none' || L.style.getPropertyValue('overflow-y') !== 'auto'; } function appGroupNeedFix(g) { return g.style.getPropertyValue('left') !== '0px' || g.style.getPropertyValue('right') !== '0px' || g.style.getPropertyValue('width') !== 'auto'; } function appInlineFix() { if (!appCur) return; var g = appCur.group; /* v2.9.2：组壳自己也被页面写了行内 !important（实测是 width:100%!important; left:auto!important; right:auto!important）。行内 !important 只有行内 !important 打得过，样式表那套全部失效 → 组壳留在 static 位置（实测 left:122.5px / 宽 1905px），整个右栏连带滑块被推出视口：这就是「右面被裁剪 + 看不到拖动按钮」。每次都写一遍 setProperty，页面改回也会被下一次看门狗按回去。 */ if (appGroupNeedFix(g)) { var pin = { position: 'fixed', left: '0px', right: '0px', top: APP_BAR_H + 'px', bottom: '0px', width: 'auto', height: 'auto', 'max-width': 'none', 'min-width': '0px', 'min-height': '0px', margin: '0px', transform: 'none', 'box-sizing': 'border-box', 'overflow-x': 'hidden', float: 'none' }; for (var k in pin) { if (pin.hasOwnProperty(k)) g.style.setProperty(k, pin[k], 'important'); } } var L = g.querySelector('.nz-resizable.left'); var LS = g.querySelector('.left-section'); if (L && appInlineNeedFix(L)) { // 页面给左栏写死了 position:sticky / max-height:calc(...) / align-self:flex-start， // 不放开就永远只有「内容高」，滚不起来、画布也铺不满 L.style.setProperty('position', 'static', 'important'); L.style.setProperty('top', 'auto', 'important'); L.style.setProperty('max-height', 'none', 'important'); L.style.setProperty('align-self', 'stretch', 'important'); L.style.setProperty('height', 'auto', 'important'); L.style.setProperty('overflow-y', 'auto', 'important'); L.style.setProperty('overflow-x', 'hidden', 'important'); } if (LS) { if (LS.style.getPropertyValue('align-self') !== 'stretch') LS.style.setProperty('align-self', 'stretch', 'important'); if (LS.style.getPropertyValue('min-height') !== '100%') LS.style.setProperty('min-height', '100%', 'important'); if (LS.style.getPropertyValue('height') !== 'auto') LS.style.setProperty('height', 'auto', 'important'); } } /* ---- v2.9.29 分栏内容自愈：脏标记 + 一帧内补量重绘 ---- 旧看门狗每 700ms 盲目全量量尺寸+重绘（80 层深 DOM walk × 2 + 全部笔画重画）。现在内容何时会变，我们其实都知道： · Angular 增删/重建节点、就地改文本（childList / characterData）→ 内容监听； · 图片真实尺寸晚于 DOM 到位（无 MO 事件）→ 组上捕获层的 load 兜底； · 撤销/重做/清空、转窗 → 各自入口直接打脏标记。监听只打标记并排一个 rAF，量尺寸与重绘合并到一帧里做——mutation 风暴期间不会连环全量重画；正在写字时不量不画（v2.9.10 的老坑），留到收笔后。 */ function appMarkDirty() { if (!appCur) return; appCur.dirty = true; appCur.optcGen = (appCur.optcGen || 0) + 1; // 内容变了 → 选项列数指纹代际失效 if (appCur.healRaf || appCur.stroke) return; appCur.healRaf = requestAnimationFrame(function () { appCur.healRaf = 0; if (!appCur || appCur.stroke || !appCur.dirty) return; appCur.dirty = false; appSizeAll(); appRedraw(); appSyncThumbs(); }); } function appWatchContent() { if (!appCur || typeof MutationObserver !== 'function') return; if (appCur.moContent) { try { appCur.moContent.disconnect(); } catch (e) {} appCur.moContent = null; } try { appCur.group.removeEventListener('load', appMarkDirty, true); } catch (e) {} appCur.moContent = new MutationObserver(function () { appMarkDirty(); }); appCur.moContent.observe(appCur.group, { childList: true, subtree: true, characterData: true }); try { appCur.group.addEventListener('load', appMarkDirty, true); } catch (e) {} } function appWatchInline() { if (!appCur || typeof MutationObserver !== 'function') return; var L = appCur.group.querySelector('.nz-resizable.left'); if (!L) return; if (appCur.mo) { try { appCur.mo.disconnect(); } catch (e) {} appCur.mo = null; } appCur.mo = new MutationObserver(function () { if (!appCur) return; if (appInlineNeedFix(L)) { appInlineFix(); appSizeAll(); appSyncThumbs(); } }); appCur.mo.observe(L, { attributes: true, attributeFilter: ['style'] }); } function appEnter() { return !!appCur; } /* ---- 内容区没有任何手势滚动（v2.9.9）---- 草稿打开后就是盖在题目上的一张纸：手和笔一模一样，落上来只写字，谁也别想把这张纸拖走、更别想点到纸下面那一层。滚动只有两个入口 —— 左右两侧那两颗滚动条（手指、笔都能拖）。这里只剩一条兜底：个别内核不认 touch-action:none、仍把触摸当滚动手势时，把 touchmove 的默认动作掐掉，免得整页 / 整栏被拖走。 */ function appBindScrollTouch(side, scroller) { function onTouchMove(e) { if (!appCur) return; if (e.touches && e.touches.length > 1) return; // 双指缩放留给浏览器 e.preventDefault(); // 内容区不许滚（滚动请拖滚动条） } scroller.addEventListener('touchmove', onTouchMove, { capture: true, passive: false }); /* 退出分栏要能把这条摘干净：否则每进一次就叠一层 */ return function () { try { scroller.removeEventListener('touchmove', onTouchMove, { capture: true }); } catch (e) {} }; } /* ---- 每侧一张纸 ---- */ function appBuildSide(side, scroller, host) { if (!host) return null; var cv = document.createElement('canvas'); cv.className = 'marvis-app-ink'; cv.setAttribute('data-marvis-app-ink', side); host.appendChild(cv); var thumb = document.createElement('div'); thumb.className = 'marvis-app-thumb'; thumb.setAttribute('data-marvis-app-thumb', side); thumb.innerHTML = ''; document.body.appendChild(thumb); var s = { cv: cv, ctx: cv.getContext('2d'), host: host, scroller: scroller, thumb: thumb, dpr: 1 }; cv.__appSide = side; /* v2.9.2：监听挂在 scroller 上（画布本身 pointer-events:none）。这样手指的 pointerdown/touch 一路直达原生内容 → 手指能滚、能点选项；只有笔会被我们在这里拦下来写成笔迹。 */ scroller.__appSide = side; /* v2.9.15：落笔与阻挡改挂 document 捕获层（见 appShieldDown / appSideAt）—— 挂在这里的话，只要页面上有一层透明覆盖物盖住这块区域，事件就绕开滚动容器，那块地方「怎么写都写不出」。document 层按坐标归属，盖什么都拦不住。 */ scroller.addEventListener('scroll', function () { appSyncThumb(side); /* v2.9.15：滚到没画布的地方就等于「那块没有草稿」—— 滚动后按真实内容底部补量一次。正在写字时绝不量（量尺寸会重设画布位图，把在写的墨迹抹掉，v2.9.10 的老坑）。 */ if (!s.__sizeRaf && !(appCur && appCur.stroke)) { s.__sizeRaf = requestAnimationFrame(function () { s.__sizeRaf = 0; if (!appCur || appCur.stroke) return; appSizeSide(side); }); } /* v2.9.11：右栏滚动 → 顶栏题号跟着换，面板里的当前行也跟着亮 */ if (side === 'right' && !appQScrollRaf) { appQScrollRaf = requestAnimationFrame(function () { appQScrollRaf = 0; appQBarSync(); appSheetSyncStates(); }); } }, { passive: true }); s.detachTouch = appBindScrollTouch(side, scroller); // v2.9.6：原生滚不动时由我们接管 thumb.addEventListener('pointerdown', function (ev) { ev.preventDefault(); ev.stopPropagation(); /* v2.9.7：把指针捕获在这颗滑块上 —— 笔/手指拖得快、拖出 12px 的窄条时 pointermove 仍然送到 window，滚动不会半路断掉。 */ try { thumb.setPointerCapture(ev.pointerId); } catch (e) {} appThumbDrag(side, ev); }, true); return s; } function appSyncThumb(side) { var s = appCur && appCur.sides[side]; if (!s || !s.thumb || !s.scroller) return; var el = s.scroller, r = el.getBoundingClientRect(); var ch = el.clientHeight, sh = el.scrollHeight, th = s.thumb; if (r.height < 40 || r.width < 40) { th.classList.remove('on'); return; } /* v2.9.2：以前只有「需要滚」才显示滑块，内容一旦被内层裁住就静默消失，用户以为没有拖动按钮。现在只要这一栏在，就显示一条轨道；不能滚时滑块占满整条且颜色更淡（track 样式），能滚才是实心滑块。 */ var canScroll = sh > ch + 6; var h = canScroll ? Math.max(48, Math.round(r.height * ch / sh)) : r.height; var maxScroll = sh - ch; var ratio = (canScroll && maxScroll > 0) ? Math.max(0, Math.min(1, el.scrollTop / maxScroll)) : 0; th.classList.add('on'); if (canScroll) th.classList.remove('track'); else th.classList.add('track'); /* 贴右边缘，且夹在视口内（组壳偏出去时滑块会跟着跑出屏，等于没有） */ var vw = window.innerWidth || document.documentElement.clientWidth || r.right; /* v2.9.29：看门狗每轮都会调这里；值没变就不写（写 style 会标脏样式，空转白耗） */ var nl = Math.round(Math.max(0, Math.min(r.right - 16, vw - 16))) + 'px'; var nt = Math.round(r.top + ratio * (r.height - h)) + 'px'; var nh = Math.round(h) + 'px'; if (th.style.left !== nl) th.style.left = nl; if (th.style.top !== nt) th.style.top = nt; if (th.style.height !== nh) th.style.height = nh; } function appSyncThumbs() { appSyncThumb('left'); appSyncThumb('right'); } function appThumbDrag(side, ev) { var s = appCur && appCur.sides[side]; if (!s || !s.scroller) return; var el = s.scroller; var r = el.getBoundingClientRect(); var ch = el.clientHeight, sh = el.scrollHeight; var h = Math.max(48, Math.round(r.height * ch / sh)); var span = Math.max(1, r.height - h); var maxScroll = sh - ch; var startY = ev.clientY, startTop = el.scrollTop; function mv(e2) { var next = startTop + ((e2.clientY - startY) / span) * maxScroll; el.scrollTop = Math.max(0, Math.min(maxScroll, next)); appSyncThumb(side); } function up() { window.removeEventListener('pointermove', mv, true); window.removeEventListener('pointerup', up, true); window.removeEventListener('pointercancel', up, true); appSyncThumb(side); } window.addEventListener('pointermove', mv, true); window.addEventListener('pointerup', up, true); window.addEventListener('pointercancel', up, true); } /* ---- 书写 ---- */ var appInkBox = null; // 刚收笔那一笔的屏幕 bbox：只有落在笔画上的 click 才吞 function appPenClickGuard(ev) { if (!appCur || !appInkBox) return; if (appClickBypass > 0) return; // v2.9.11：面板代点的 click 不算「写完顺手点选项」 if (Date.now() - appInkBox.t > 600) return; var x = ev.clientX, y = ev.clientY; if (x < appInkBox.x1 - 10 || x > appInkBox.x2 + 10 || y < appInkBox.y1 - 10 || y > appInkBox.y2 + 10) return; // 不在刚写的笔画附近 → 放行 var t = ev.target; if (appInOwnUI(t)) return; // 顶栏 / 滑块 / 纸头按钮 —— 它们本来就要能点 ev.stopPropagation(); if (ev.stopImmediatePropagation) ev.stopImmediatePropagation(); ev.preventDefault(); } /* v2.9.9：草稿是一张纸，纸下面那层谁也碰不到 —— 手、笔、鼠标一视同仁。 v2.9.8 只挡手指、放行笔，是为了让「笔还能点选项」；用户明确不要这种区别：草稿一打开就是纯书写，要改答案先关草稿。放行的只有我们自己的 UI：顶栏与两颗滚动条。 */ function appInOwnUI(t) { /* v2.9.13：白名单只留「真的要用手/笔点」的三样 —— 顶栏、两颗滚动条、答题面板。字母盒（.marvis-lbox）已经在分栏里彻底隐藏，不再是点击目标，也就不再让路；更要紧的是：它以前在名单里，笔一落到题目左上角那块就被判成「点 UI」而不落笔，正是用户说的「笔触到那儿就断」。 */ /* v2.9.39：字号下拉菜单必须在这里 —— 它挂在 body 上、定位在顶栏下方，正好压在草稿纸上。不在白名单时：pointerdown 被 appShieldDown 判成「纸面」直接开一笔（点档位 = 在纸上画一道墨），click 又被 stopImmediatePropagation 掐掉 → 菜单永远选不中，连「点外面收起」都失灵。 */ return !!(t && typeof t.closest === 'function' && t.closest('#' + APP_BAR_ID + ', .marvis-app-thumb, ' + '#' + APP_SHEET_ID + ' .mas-head, ' + '#' + APP_SHEET_ID + ' .mas-sz, ' + '#marvis-app-fontmenu')); } /* ---- v2.9.15：落笔监听从「滚动容器」提到 document 捕获层 ---- 粉笔页面上常驻一批透明覆盖层（.modal-overlay / .tooltip-container / sticky 吸顶条 … 实测在选项 B 上做 elementFromPoint，命中的就是 div.modal-overlay）。它们一旦盖住某块区域， pointerdown 的传播路径就绕开了滚动容器 —— 我们收不到事件，那块区域「怎么都写不出字」，在用户眼里就是「这块没有草稿覆盖」，而画布其实是好的。现在落点只按【坐标】归属到左栏/右栏，谁盖在上面都拦不住。 */ /* v2.9.17：草稿纸浮在两栏之上，落点必须先归它 —— 否则纸上的笔会被判成「右栏」，墨迹画到纸下面那张画布上，看起来就是「在纸上写，字却出现在题目上」。 */ function appSheetBox() { var sh = appCur && appCur.sheetOpen && appCur.sides && appCur.sides.sheet; if (!sh || !sh.el) return null; var r; try { r = sh.el.getBoundingClientRect(); } catch (e) { return null; } if (!r || r.width < 2 || r.height < 2) return null; return { r: r, side: sh, headBottom: r.top + (sh.headH || 40) }; } function appSheetHit(x, y) { var b = appSheetBox(); if (!b) return null; if (x < b.r.left || x > b.r.right || y < b.r.top || y > b.r.bottom) return null; return y < b.headBottom ? 'head' : 'body'; } function appSideAt(x, y) { if (!appCur) return null; var b = appSheetBox(); if (b && x >= b.r.left && x <= b.r.right && y >= b.headBottom && y <= b.r.bottom) return b.side; var order = ['right', 'left']; for (var i = 0; i < order.length; i++) { var s = appCur.sides[order[i]]; if (!s || !s.cv || !s.scroller) continue; var r; try { r = s.scroller.getBoundingClientRect(); } catch (e) { continue; } if (!r || r.width < 2 || r.height < 2) continue; if (x >= r.left && x <= r.right && y >= r.top && y <= r.bottom) return s; } return null; } /* ---- v2.9.23 防误触：默认只认笔 ---- 用户定稿（本版）：「只认笔 + 一颗手写开关」，纸和两栏用同一套规则。 v2.9.9 那条「手和笔完全一样」的初衷是「手不许穿透到下面的题目」，副作用是手掌/皮肤一碰纸面就落墨 —— 手写时掌心、撑手、握笔的指节全在纸上。现在： · 默认只有 pointerType='pen'（以及鼠标左键）落墨； · 手指碰纸仍然什么都不透过去（下面那层选项照旧碰不到），只是不落墨； · 手指照样能按纸头按钮、拖纸头、拖两颗滚动条、按顶栏 —— 那些都是自家的 UI； · 真要手指写字，点顶栏那颗 ✋（橘色=已打开），选择记在 localStorage。 */ var APP_HAND_LS = 'marvis-app-handwrite'; function appHandWrite() { return lsGet(APP_HAND_LS) === '1'; } function appSetHandWrite(on) { lsSet(APP_HAND_LS, on ? '1' : '0'); } /* 这一次 pointerdown 能不能落笔 */ function appPointerWrites(e) { var t = e && e.pointerType; if (!penWritable(e)) return false; // v2.9.27：笔侧键 / 橡皮键不落墨 if (t === 'pen' || t === 'mouse') return true; // 笔 / 鼠标左键 if (!appHandWrite()) return false; // 默认：手指/手掌不落墨 /* 手写开关打开时也保让笔优先：笔正在写，手指/手掌一律让路 —— 既不落墨，也不许像以前那样把这一笔截断（v2.9.9 起的老毛病）。 */ var st = appCur && appCur.stroke; if (st && !st.dead && st.ptype === 'pen') return false; return true; } function appShieldDown(e) { if (!appCur) return; if (appInOwnUI(e.target)) return; // 顶栏 / 两颗滚动条 / 纸头按钮 —— 放行 /* 纸头 = 拖动纸的手柄，不是写字。**不能 stopPropagation** —— 纸头的 pointerdown 还要交给它自己的拖动处理器，一停就拖不动了。事件目标是纸头本身（纸在最上层），下面那层本来也收不到。 */ if (appSheetHit(e.clientX, e.clientY) === 'head') return; var s = appSideAt(e.clientX, e.clientY); if (!s) return; // 落在两栏之外（页面别处）→ 放行 /* 到这里 = 落在这张纸上：下面那一层（选项 / 收藏 / 子题 tab / 页面滚动）一个事件都别收 */ e.stopPropagation(); if (e.stopImmediatePropagation) e.stopImmediatePropagation(); if (appCur.mode !== 'pen') return; if (e.pointerType === 'mouse' && e.button !== undefined && e.button !== 0) return; /* v2.9.28：笔/手指落到纸上就 preventDefault。之前只 stopPropagation，Android WebView 里 Chromium 内核照样会对这串指针做「滚动手势 / 长按手势」仲裁 —— 一旦判成手势就 pointercancel，笔写两三个字就断（用户「只能写短线」）。preventDefault 让内核放弃为这串指针做手势仲裁，配合纸身 touch-action:none，笔程从落笔到抬笔全程不间断。 */ if (e.cancelable !== false) { try { e.preventDefault(); } catch (err) {} } appBeginStroke(s, e); } function appShieldClick(e) { if (!appCur) return; if (appClickBypass > 0) return; // v2.9.11：面板代点的原生 click，放行 if (appInOwnUI(e.target)) return; if (appSheetHit(e.clientX, e.clientY)) { // 纸上任何位置的 click 都不许穿透 e.stopPropagation(); if (e.stopImmediatePropagation) e.stopImmediatePropagation(); e.preventDefault(); return; } if (!appSideAt(e.clientX, e.clientY)) return; e.stopPropagation(); if (e.stopImmediatePropagation) e.stopImmediatePropagation(); e.preventDefault(); } /* v2.9.40：同 penPoint —— 合并采样批循环传入预量矩形，避免逐事件强制布局读取 */ function appPt(cv, e, rect) { var r = rect || cv.getBoundingClientRect(); return [e.clientX - r.left, e.clientY - r.top]; } /* v2.9.6：笔写期间把栏位钉住。有些内核（iPadOS 的 Safari/WKWebView）会把笔的拖动同时当成滚动手势。即便 CSS 已经回到 touch-action:auto，这里再兜一层：只要这一笔还没抬起来，滚动位移一律原样退回。写的这几百毫秒里用户不可能同时用手指滚这一栏，代价可以忽略。 */ function appScrollGuard(scroller, stroke) { if (stroke.guard) return; // v2.9.10：同一笔续写时不重复挂 var top = scroller.scrollTop, left = scroller.scrollLeft; var fn = function () { if (scroller.scrollTop !== top) scroller.scrollTop = top; if (scroller.scrollLeft !== left) scroller.scrollLeft = left; }; scroller.addEventListener('scroll', fn, { passive: true }); stroke.guard = fn; stroke.guardEl = scroller; } /* v2.9.15：真正的落笔入口。谁在上面盖着都不影响 —— 由 appShieldDown 按坐标挑好这一侧再进来。 */ function appBeginStroke(s, e) { if (!appCur || appCur.mode !== 'pen') return; if (!s || !s.cv) return; /* v2.9.23：防误触的总闸 —— 手指/手掌默认不落墨（见 appPointerWrites）。放在最前面：连「旧笔画收尾/接管」都不参与，笔正在写时手掌落下也动不了这一笔。 */ if (!appPointerWrites(e)) return; var sc = s.scroller; var side = s.cv.__appSide || (s === appCur.sides.left ? 'left' : 'right'); /* v2.9.9：不分区「谁能写」的老规矩见上；v2.9.23 起默认只认笔，手指/手掌要写必须先在顶栏把 ✋ 打开（appPointerWrites 已经把关）。 */ /* v2.9.32：橡皮意图（双击笔身切到橡皮后的笔尖接触）。提前算好：续写判定不许把「笔画」续成「橡皮」（反之亦然）。 */ var erasing = e.pointerType === 'pen' && penEraser(e); var old = appCur.stroke; if (old) { var pt = appPt(s.cv, e); var last = old.pts[old.pts.length - 1]; var near = !!last && Math.abs(pt[0] - last[0]) <= 48 && Math.abs(pt[1] - last[1]) <= 48; /* v2.9.28：孤儿笔（被 pointercancel 打断）续写判定放宽。 Android 上即便纸身已 touch-action:none，个别内核（MIUI/HyperOS 的手势增强、焦点触控笔 Pro 的悬停/压感上报）仍可能在运笔途中 cancel 一次。cancel 后用户手不停、笔继续走，下一次 down 的落点往往已经离开上次断点 50~120px —— 旧的 48px 阈值把它判成「新一笔」，于是屏幕上留下一段段短线（「只能写短线」）。孤儿笔 + 短时间内重连（≤700ms，同一支笔），把续写半径放到 160px：笔还在惯性里滑动，落点不会离谱，160px 足够覆盖绝大多数断触重连。 */ var orphanNear = old.orphan && (Date.now() - (old.ts || 0) < 700) && !!last && Math.abs(pt[0] - last[0]) <= 160 && Math.abs(pt[1] - last[1]) <= 160; if (e.pointerType === 'pen' && old.ptype !== 'pen') { /* Apple Pencil 会同时产生 pen 与 touch 两路指针。touch 先到就先建了笔画（点数少、位置粗），笔一到就把这条 touch 笔画丢掉、整笔由 pen 重画 —— 否则两条线交错（v2.8.11 同款问题）。 */ old.dead = true; appEndStroke(false); } else if (old.ptype === e.pointerType && (near || orphanNear) && !old.dead && old.t === (erasing ? 'erase' : 'stroke')) { /* v2.9.10：同一支指针「断了一下又接着来」不算新的一笔。真机上系统会在书写途中发 pointercancel（手掌压屏、内核手势仲裁、页面滚动），紧接着用一次新的 pointerdown 把笔交回来。以前 cancel 就收笔、新 down 再开一笔，一条连续的线被切成一段一段 —— 这正是用户说的「断触」。判据只看落点：接着上一笔的落点（≤48px）就续着画，别的什么都不管。 */ old.pid = e.pointerId; old.orphan = false; appScrollGuard(sc, old); e.preventDefault(); window.addEventListener('pointermove', appOnMove, true); window.addEventListener('pointerup', appOnUp, true); window.addEventListener('pointercancel', appOnUp, true); return; } else if (old.orphan) { appEndStroke(true); // 上一笔是被 cancel 打断的孤儿 → 就地收尾 } else if (Date.now() - (old.ts || 0) < 700) { return; // 另一支指针乱入，不打断当前笔画 } else { appEndStroke(true); // 悬挂的旧笔画（断触残留）→ 收尾再开新的 } } e.preventDefault(); /* 不在这里 setPointerCapture：捕获会把随后合成 click 的 target 改成这个滚动容器，而且单击时根本不需要捕获。改到真正开始画之后（appOnMove）再锁。 */ var stroke = { t: erasing ? 'erase' : 'stroke', side: side, color: brushColor, w: erasing ? penEraserR() : Math.max(1.4, 1.6 * brushWidth), pts: [appPt(s.cv, e)], pid: e.pointerId, ptype: e.pointerType, ts: Date.now() }; if (side === 'sheet') stroke.sub = appCur.sheetSub; // 这一笔记在哪道题的纸上 appCur.stroke = stroke; if (erasing) penEraseDot(s.ctx, stroke.pts[0][0], stroke.pts[0][1], stroke.w); // v2.9.32：点擦 appScrollGuard(sc, stroke); // 这一笔没抬起来之前，栏位不许滚走（手、笔都一样） var ctx = s.ctx; ctx.strokeStyle = stroke.color; ctx.lineWidth = stroke.w; ctx.lineCap = 'round'; ctx.lineJoin = 'round'; window.addEventListener('pointermove', appOnMove, true); window.addEventListener('pointerup', appOnUp, true); window.addEventListener('pointercancel', appOnUp, true); } function appOnMove(e) { var st = appCur && appCur.stroke; if (!st || st.dead) return; if (e.pointerId !== st.pid) { if (st.orphan) return; // v2.9.10：孤儿笔不许被别的指针续上（手掌乱扫会画歪） if (e.pointerType !== st.ptype) return; // 另一路指针（手/另一支笔）的 move，忽略 st.pid = e.pointerId; // 浏览器在一笔之内换了 pointerId → 认下来（v2.8.13 同款） } var s = appCur.sides[st.side]; if (!s) return; /* v2.9.4：合并采样补点。浏览器会把一帧里的多个物理采样合并成一个 pointermove —— 只取事件本身的话，快速运笔时相邻点距会拉到几十像素，样条被拉直、出现折角，看着就像「断了一下」。逐点过 0.5px 去重：已经完全投递过的采样会被自然跳过，所以不会出现 v2.8.11 那种「同一批采样喂两遍 → 两条交错线」。 */ var seq = [e]; try { if (e.getCoalescedEvents) { var ce = e.getCoalescedEvents(); if (ce && ce.length) { seq = []; for (var c = 0; c < ce.length; c++) seq.push(ce[c]); seq.push(e); // e 一定是最新位置；与列表尾部重复的会被去重挡掉 } } } catch (err) { seq = [e]; } var appRect = s.cv.getBoundingClientRect(); // v2.9.40：一批合并采样量一次 for (var k = 0; k < seq.length; k++) { var pk = (seq[k] === e) ? appPt(s.cv, e, appRect) : appPt(s.cv, seq[k], appRect); var pts = st.pts; var last = pts[pts.length - 1]; var dx = pk[0] - last[0], dy = pk[1] - last[1]; if (dx * dx + dy * dy < 0.25) continue; // 亚像素抖动 / 重复采样不记 pts.push(pk); var n = pts.length; if (n === 2) { /* 真正开始画了才锁指针（v2.9.8）：单击走原生路径（笔点选项才点得中），拖动才需要捕获 */ try { s.scroller.setPointerCapture(st.pid); st.captured = true; } catch (err) {} } /* v2.9.32：橡皮 = dest-out 圆头线逐段增量擦；书写 = 样条 */ if (st.t === 'erase') { if (n === 1) penEraseDot(s.ctx, pts[0][0], pts[0][1], st.w); else penEraseSeg(s.ctx, pts[n - 2], pts[n - 1], st.w); } else if (n === 2) { s.ctx.beginPath(); s.ctx.moveTo(pts[0][0], pts[0][1]); s.ctx.lineTo(pts[1][0], pts[1][1]); s.ctx.stroke(); } else { var i = n - 1; appSeg(s.ctx, pts[i - 2] || pts[i - 1], pts[i - 1], pts[i], pts[i]); } } st.ts = Date.now(); e.preventDefault(); } function appOnUp(e) { var st = appCur && appCur.stroke; if (!st || st.dead) return; /* v2.9.10：pointercancel 不是抬笔。 iPadOS 会在书写途中 cancel 掉笔的指针流（手掌压屏 / 手势仲裁 / 栏位滚动），随后再用一次 pointerdown 把笔交回来。这里若按抬笔收尾，一笔就被切成两段 —— 用户反馈的「断触」正是它。所以 cancel 只做两件事：摘掉滚动手闸（否则挂着的笔画会让滚动条失灵），并把它标成孤儿笔，等下一次 down 决定「续写」还是「收尾」。 */ if (e.type === 'pointercancel') { st.orphan = true; if (st.guard && st.guardEl) { try { st.guardEl.removeEventListener('scroll', st.guard, { passive: true }); } catch (e2) {} st.guard = null; st.guardEl = null; } return; } /* v2.9.4：以前这里严格比对 pointerId，一旦浏览器换 id（或手掌触发 pointercancel 用了另一个 id），笔画就收不了尾 → appCur.stroke 永久挂着 → 之后每一笔都被「已有笔画」挡掉。这就是用户遇到的断触。同类型指针一律当本笔的收尾。 v2.9.9 收细一点：同类型但 id 不同、且这一笔刚刚还在动（<260ms），多半是另一根手指抬起，不该把主指的笔画截断；真悬挂的笔画由 appBeginStroke 的 700ms 接管兜住。 */ if (e.pointerId !== st.pid) { if (e.pointerType !== st.ptype) return; if (Date.now() - (st.ts || 0) < 260) return; } appEndStroke(true); } function appEndStroke(commit) { var st = appCur && appCur.stroke; if (!st) return; appCur.stroke = null; if (st.guard && st.guardEl) { try { st.guardEl.removeEventListener('scroll', st.guard, { passive: true }); } catch (e) {} st.guard = null; st.guardEl = null; } window.removeEventListener('pointermove', appOnMove, true); window.removeEventListener('pointerup', appOnUp, true); window.removeEventListener('pointercancel', appOnUp, true); if (!commit || st.dead) return; /* 只点了一下（用笔点选项、点按钮）→ 不建笔画，也绝不能记 bbox。 v2.9.4 第一版在这里就设了 appInkBox，结果「笔点选项」等于把 box 设在选项上，紧接着的 click 被自己吞掉 —— 笔就永远点不动选项了。 */ if (st.pts.length < 2) return; /* 记下这一笔的屏幕 bbox：抬笔后 600ms 内、落点压在这条笔画上的 click 才吞掉（防「写完顺手把选项点了」）。以前是「抬笔后 420ms 内吞掉所有 click」，用笔点选项时会被误吞。 */ try { var r = appCur.sides[st.side].cv.getBoundingClientRect(); var x1 = 1e9, y1 = 1e9, x2 = -1e9, y2 = -1e9; for (var i = 0; i < st.pts.length; i++) { var p = st.pts[i]; if (p[0] < x1) x1 = p[0]; if (p[0] > x2) x2 = p[0]; if (p[1] < y1) y1 = p[1]; if (p[1] > y2) y2 = p[1]; } /* 拉出一点长度才算「写字」，抖动式的两三点不算 */ if (x2 - x1 > 8 || y2 - y1 > 8) { appInkBox = { x1: r.left + x1, y1: r.top + y1, x2: r.left + x2, y2: r.top + y2, t: Date.now() }; } } catch (err) {} /* v2.9.17：纸上的笔进这道题自己的历史，不进分栏那条撤销栈 */ if (st.side === 'sheet') { var h = appSheetHist(st.sub); if (h) { h.acts.length = h.at; // 撤销后写新笔 = 截断重做栈 h.acts.push(st); h.at = h.acts.length; if (h.acts.length > 400) { h.acts.shift(); h.at--; } } appSaveSoon(); appBarSync(); return; } appCur.acts.length = appCur.at; // 撤销后写新笔 = 截断重做栈 appCur.acts.push(st); appCur.at = appCur.acts.length; if (appCur.acts.length > 600) { appCur.acts.shift(); appCur.at--; } appSaveSoon(); appBarSync(); } /* ---- 撤销 / 反撤 / 清空 ---- v2.9.21：两套彻底独立（用户定稿）—— · 顶栏那三颗 = 左右两栏那张大画布（`appCur`），始终是它，跟纸开没开无关； · 纸头那三颗 = 眼前这张纸（`appCur.sheets[题号]`）。 v2.9.17~v2.9.20 的写法是「纸一开，顶栏三颗也改指向纸」—— 那等于顶栏那三颗忽然换了控制对象，用户看到的正是「外面的大按钮也在撤纸上的字」。 */ function appHistFor(sheet) { if (sheet) return (appCur && appCur.sheetSub) ? appSheetHist(appCur.sheetSub) : null; return appCur; } function appActiveHist() { return appCur; } function appUndo(sheet) { var h = appHistFor(sheet); if (!h || h.at <= 0) return; h.at--; appRedraw(); appSaveSoon(); appBarSync(); } function appRedo(sheet) { var h = appHistFor(sheet); if (!h || h.at >= h.acts.length) return; h.at++; appRedraw(); appSaveSoon(); appBarSync(); } function appClear(sheet) { if (!appCur) return; var h = appHistFor(sheet); if (!h) return; h.acts.length = h.at; h.acts.push({ t: 'clear' }); h.at = h.acts.length; appRedraw(); appSaveSoon(); appBarSync(); } /* ---- 顶部草稿栏 ---- */ /* ---- v2.9.11 答题面板：五道题的 ABCD / 标记 / 收藏都搬到顶栏 ---- 为什么非搬不可：v2.9.9 起分栏就是「一张盖在题目上的纸」，内容区的 pointerdown 与合成 click 都在滚动容器捕获层被整个吃掉 —— 内容区里那排 `marvis-lbox`（ABCD+下一题）和标记/收藏/草稿三个图标全都是死的（jsdom 探针实测：不进分栏点 A 能选中，进分栏后同一个按钮点不动）。顶栏与面板是我们自己的 UI（appInOwnUI 放行），所以只能在这里做。 */ var appClickBypass = 0; // 面板合成的原生点击要放行，否则被自己的纸吃掉 var appPopBuilding = false; var appQScrollRaf = 0; function appAllowOnce(fn) { appClickBypass++; try { fn(); } finally { appClickBypass--; } } function appSubs() { if (!appCur || !appCur.group) return []; return subsOf(appCur.group); } function appSubNum(sub, i) { var el = sub && sub.querySelector('.title-index'); var t = el ? String(el.textContent || '').replace(/\s+/g, '') : ''; return t || ((i + 1) + '.'); } /* 每道子题每个字母的状态：sel=已选 / ok=对 / bad=错（判定口径与 syncFeedback 完全一致） */ function appSubStates(sub) { var out = [], judged = false; var radios = [].slice.call(sub.querySelectorAll('li.choice-radio')); radios.forEach(function (li, i) { var ir = li.querySelector('div.input-radio'); if (!ir) return; if (ir.classList.contains('correct') || ir.classList.contains('correctLost')) { out[i] = 'ok'; judged = true; } else if (ir.classList.contains('wrong')) { out[i] = 'bad'; judged = true; } }); if (!judged) radios.forEach(function (li, i) { if (isRadioSelected(li)) out[i] = 'sel'; }); return out; } /* 右栏里「正在看的那道题」= 顶边已经越过视口顶部的最后一题 */ function appCurrentSub() { var s = appCur && appCur.sides.right; if (!s || !s.scroller) return null; var subs = appSubs(); if (!subs.length) return null; var sc = s.scroller; /* v2.9.20：已经滚到底时，「正在看的」就是最后一道。用户点 125 号题号 → 125 滚到顶 → 但内容到 125 就结束了、滚不动那么远，按「顶边越过视口顶」算出来的仍是 123 —— 用户截图里的「点开 125 的纸，顶栏却亮着 123」就是这条。到底了就把当前题认成最后一道。 */ var maxTop = 0, top0 = 0; try { maxTop = (sc.scrollHeight || 0) - (sc.clientHeight || 0); top0 = sc.scrollTop || 0; } catch (e) {} if (maxTop > 8 && maxTop - top0 <= 6) return subs[subs.length - 1]; var top = s.scroller.getBoundingClientRect().top + 10; /* 取「顶边已越过视口顶部」里最靠下的那道；几道题顶边重合时算第一道（首次进入还没滚动时不会误判成最后一道） */ var best = subs[0], bestTop = -1e9; for (var i = 0; i < subs.length; i++) { var t = subs[i].getBoundingClientRect().top; if (t <= top && t > bestTop) { best = subs[i]; bestTop = t; } } return best; } function appSubScrollTo(sub) { var s = appCur && appCur.sides.right; if (!s || !s.scroller || !sub) return; var sc = s.scroller; var top = sub.getBoundingClientRect().top - sc.getBoundingClientRect().top + sc.scrollTop - 8; sc.scrollTop = Math.max(0, Math.min(sc.scrollHeight - sc.clientHeight, top)); appQBarSync(); } /* ---- v2.9.17：五颗题号按钮 + 每题一张草稿纸 ---- 用户定稿：「做 5 个按钮，一道题一个草稿按钮」，并且把 v2.9.11 那颗「117.▾」下拉面板整个并进来 —— 点题号 = 滚到这道题 + 弹出这道题自己的纸；纸头一行就是这题的 ABCD / 标记 / 收藏。原来那颗按钮和五行的面板都删掉。为什么纸要按题分开：草稿纸是演算用的，116 的算式留在 116 上才有意义；共用一张纸的话，滚到下一题得先擦掉上一题的推导过程。 */ function appSubIndex(sub) { var subs = appSubs(); for (var i = 0; i < subs.length; i++) if (subs[i] === sub) return i; return -1; } function appQButtons(host, subs) { if (!host) return; host.innerHTML = ''; (subs || []).forEach(function (sub, i) { var num = String(appSubNum(sub, i) || ''); var b = document.createElement('button'); b.type = 'button'; b.className = 'mab-qn'; b.setAttribute('data-k', 'qn'); b.setAttribute('data-num', num); b.textContent = num.replace(/\.$/, ''); b.title = '第 ' + (i + 1) + ' 题：点一下滚到这道题并弹出它的草稿纸；再点收起'; b.addEventListener('click', function (ev) { ev.preventDefault(); ev.stopPropagation(); /* 按【序号】取当前 DOM 里的那道题：Angular 重渲染会把子题节点换掉，闭包里抓住的旧节点早就游离了，拿它去滚等于什么都不做。 */ appJumpSub(appSubs()[i]); }, true); host.appendChild(b); }); } function appQBarSync() { var bar = document.getElementById(APP_BAR_ID); if (!bar || !appCur) return; var grp = bar.querySelector('.mab-qgrp'); if (!grp) return; var subs = appSubs(); if (grp.children.length !== subs.length) appQButtons(grp, subs); var cur = appCurrentSub(); var curKey = cur ? appSubNum(cur, appSubIndex(cur)) : null; /* v2.9.22：高亮一律按【题号字符串】比，不按 DOM 节点比 —— Angular 重渲染会把子题节点整批换掉，节点身份一失配就整排不亮或亮错。纸开着时高亮就取纸上那道（纸头写 125、顶栏亮 123 的观感问题从根上断掉）；纸收起时才按滚动位置算。 */ var hiKey = (appCur.sheetOpen && appCur.sheetSub) ? appCur.sheetSub : curKey; for (var i = 0; i < grp.children.length; i++) { var num = grp.children[i].getAttribute('data-num'); var cls = 'mab-qn' + (num && num === hiKey ? ' on' : ''); if (grp.children[i].className !== cls) grp.children[i].className = cls; } /* v2.9.22：删掉「纸跟着当前题走」的自动改写（这是我 v2.9.17 自己加的，不是你要求的）。它害了两次：点开 125 的纸 → 开纸后的滚动 / 尺寸重算让「当前题」算回 123 → 纸被悄悄换成 123 的（顶栏也跟着变 123），用户看到的就是「我点的是 125，显示 123」。现在纸只由【点题号】决定：点哪道就是哪道，直到你点另一道。（appCurrentSub 仍算，只是不再拿它改纸。） */ appCur.qCurKey = curKey; appBarSync(); } /* 点一颗题号：滚过去 + 开这题的纸。点的是「这张纸已经开着的那道」→ 收起 */ function appJumpSub(sub) { if (!appCur || !sub) return; if (appCur.stroke) appEndStroke(true); var idx = appSubIndex(sub); /* v2.9.22：判据从「滚到哪 == 点的那道」改成「纸现在是不是就开着这道」—— 纸开着 116 而你在 125 的位置点 125，以前会被判成「点自己 → 收起」，结果是收纸而不是换纸。 */ var wasCur = !!appCur.sheetOpen && appCur.sheetSub === appSubNum(sub, idx < 0 ? 0 : idx); appSubScrollTo(sub); if (wasCur) { appSheetClose(); return; } appSheetOpenFor(sub); } function appSheetSubObj() { if (!appCur || !appCur.sheetSub) return null; var subs = appSubs(); for (var i = 0; i < subs.length; i++) { if (appSubNum(subs[i], i) === appCur.sheetSub) return subs[i]; } return null; } /* ---- 纸的位置 / 大小 ---- v2.9.19：尺寸改成三档（用户定稿：「改成档位吧，默认是最大档，铺满屏幕，还有中档和小档」）。v2.9.18 那套「点按钮进调整模式 + 8 个手柄 + 右下角三角」全部作废 —— 两套并存会互相打架（拖完手柄再点档位又变回去），留着只会让人困惑。现在： · 大 = 铺满屏幕（顶栏下方整块，圆角边框都去掉），默认就是这一档； · 中 = v2.9.18 的默认大小； · 小 = 再小一圈，方便对照题干。位置仍然可以拖纸头移动，并且**每档各记一个位置** —— 从中档拖到左上角、再切小档，小档不会跟着跑；切回中档还在左上角。 */ function appVW() { return window.innerWidth || document.documentElement.clientWidth || 1024; } function appVH() { return window.innerHeight || document.documentElement.clientHeight || 768; } function appSheetSizeSaved() { try { var v = lsGet(APP_SHEET_SIZE_LS); if (v && SHEET_SIZE_TXT[v]) return v; } catch (e) {} return 'l'; // 默认最大档 } function appSheetSizeApplySave(size) { lsSet(APP_SHEET_SIZE_LS, size); } /* 每档的位置（拖纸头才会写）。老版本只有一份 l/t，迁过来当中档的位置用。 */ function appSheetPosAll() { try { var o = lsJSON(APP_SHEET_POS_LS) || {}; if (o && typeof o === 'object') return o; } catch (e) {} return {}; } function appSheetPosGet(size) { var all = appSheetPosAll(); var p = all[size]; if (p && typeof p.l === 'number' && typeof p.t === 'number') return p; if (size === 'm') { // v2.9.18 的旧位置 → 中档 try { var r = lsJSON(APP_SHEET_RECT_LS); if (r && typeof r.l === 'number' && typeof r.t === 'number') return { l: r.l, t: r.t }; } catch (e) {} } return null; } function appSheetPosSave(size, l, t) { var all = appSheetPosAll(); all[size] = { l: Math.round(l), t: Math.round(t) }; lsSet(APP_SHEET_POS_LS, JSON.stringify(all)); } /* 一档对应的整块尺寸。大档忽略存下来的位置（铺满就是铺满）。 */ function appSheetBoxFor(size) { var vw = appVW(), vh = appVH(); if (size === 'l') return { l: 0, t: APP_BAR_H, w: vw, h: Math.max(240, vh - APP_BAR_H) }; var maxH = Math.max(200, vh - APP_BAR_H - 8); var w, h; if (size === 's') { w = Math.round(Math.min(470, Math.max(SHEET_MIN_W, vw * 0.40))); h = Math.round(Math.max(SHEET_MIN_H, Math.min(vh * 0.44, maxH))); } else { /* v2.9.21：中档略放宽（0.56 → 0.60，最小 430）—— 纸头工具条要一行放得下， 768 宽的 iPad 上 430 是刚好卡住的宽度，多给 15px 才稳。 */ w = Math.round(Math.min(720, Math.max(430, vw * 0.60))); h = Math.round(Math.max(320, Math.min(vh * 0.74, maxH))); } var p = appSheetPosGet(size); var l = p ? p.l : vw - w - 20; var t = p ? p.t : APP_BAR_H + 40; l = Math.max(4, Math.min(l, Math.max(4, vw - w - 4))); t = Math.max(APP_BAR_H + 4, Math.min(t, Math.max(APP_BAR_H + 4, vh - h - 4))); return { l: Math.round(l), t: Math.round(t), w: w, h: h }; } function appSheetPaint(box) { var s = appCur && appCur.sides && appCur.sides.sheet; if (!s || !s.el) return; appCur.sheetRect = box; s.el.style.left = Math.round(box.l) + 'px'; s.el.style.top = Math.round(box.t) + 'px'; s.el.style.width = Math.round(box.w) + 'px'; s.el.style.height = Math.round(box.h) + 'px'; s.el.classList.toggle('mas-full', appCur.sheetSize === 'l'); /* v2.9.20：纸头变两行 72px。落笔归属按「纸头顶边到纸头底边 = 纸头」判，这里量一次真实高度（jsdom 里量不到就退回 72），否则第一行的按钮会被当成纸面。 */ var hd = s.el.querySelector('.mas-head'); if (hd) { var hh = 0; try { hh = Math.round(hd.getBoundingClientRect().height || hd.offsetHeight || 0); } catch (e) { hh = 0; } if (hh > 20) s.headH = hh; } appSheetSize(true); } /* 按当前档位重排（开纸、转屏都走这里） */ function appSheetApplySize(size) { if (!appCur) return; if (size && SHEET_SIZE_TXT[size]) appCur.sheetSize = size; appSheetPaint(appSheetBoxFor(appCur.sheetSize)); } function appSheetSetSize(size) { var s = appCur && appCur.sides && appCur.sides.sheet; if (!appCur || !s || !s.el || !SHEET_SIZE_TXT[size]) return; if (appCur.stroke) appEndStroke(true); // 切档别把正在写的笔画切成两截 if (appCur.sheetSize === size) { appSheetSyncTools(); return; } appCur.sheetSize = size; appSheetSizeApplySave(size); appSheetApplySize(size); appSheetSyncTools(); cvToast('草稿纸：' + SHEET_SIZE_TXT[size] + (size === 'l' ? '（铺满屏幕）' : '')); } /* 拖纸头只改位置（大档铺满，拖不动） */ function appSheetMoveTo(l, t) { if (!appCur || appCur.sheetSize === 'l') return; var b = appCur.sheetRect || appSheetBoxFor(appCur.sheetSize); var vw = appVW(), vh = appVH(); var nl = Math.max(4, Math.min(l, Math.max(4, vw - b.w - 4))); var nt = Math.max(APP_BAR_H + 4, Math.min(t, Math.max(APP_BAR_H + 4, vh - b.h - 4))); appSheetPaint({ l: Math.round(nl), t: Math.round(nt), w: b.w, h: b.h }); } function appSheetSavePos() { if (!appCur || !appCur.sheetRect || appCur.sheetSize === 'l') return; appSheetPosSave(appCur.sheetSize, appCur.sheetRect.l, appCur.sheetRect.t); } /* ---- v2.9.18：不透明度（存 localStorage，全组共用一份） ---- */ function appSheetAlphaSaved() { try { var v = parseFloat(lsGet(APP_SHEET_ALPHA_LS)); if (isFinite(v) && v >= 0.2 && v <= 1) return v; } catch (e) {} return SHEET_ALPHA_DEF; } function appSheetAlphaApply(a) { var s = appCur && appCur.sides && appCur.sides.sheet; if (!s || !s.el) return; var v = Math.max(0.2, Math.min(1, a)); appCur.sheetAlpha = v; /* 纸头比纸面稍微实一点，不然标题和字母按钮会跟着淡到看不清 */ s.el.style.setProperty('--mas-a', String(v)); /* toFixed：0.7 + 0.1 在浮点里是 0.7999999999999999，写进样式太难看 */ s.el.style.setProperty('--mas-ha', (Math.min(1, v + 0.10)).toFixed(2)); appSheetSyncTools(); } function appSheetAlphaStep() { if (!appCur) return; var cur = appCur.sheetAlpha || SHEET_ALPHA_DEF; /* 找「比当前更透明的下一档」，到最淡一档再回到最实一档 */ var next = SHEET_ALPHAS[0]; for (var i = 0; i < SHEET_ALPHAS.length; i++) { if (SHEET_ALPHAS[i] < cur - 0.02) { next = SHEET_ALPHAS[i]; break; } } appSheetAlphaApply(next); lsSet(APP_SHEET_ALPHA_LS, String(next)); cvToast('草稿纸不透明度 ' + Math.round(next * 100) + '%'); } /* 纸头控件状态：三档里当前那档高亮 + 不透明度提示 + 撤销栈状态 + 标记/收藏是否已开 */ function appSheetSyncTools() { var s = appCur && appCur.sides && appCur.sides.sheet; if (!s || !s.el) return; var size = (appCur && appCur.sheetSize) || 'l'; [].slice.call(s.el.querySelectorAll('.mas-szb')).forEach(function (b) { var cls = 'mas-szb' + (b.getAttribute('data-sz') === size ? ' on' : ''); if (b.className !== cls) b.className = cls; }); var bop = s.el.querySelector('[data-t="alpha"]'); if (bop) { var pct = Math.round((appCur.sheetAlpha || SHEET_ALPHA_DEF) * 100); bop.title = '不透明度：' + pct + '%（点一下换下一档）'; bop.setAttribute('data-pct', String(pct)); } /* v2.9.20：撤销 / 反撤 / 清空 —— 没得撤就置灰，看着就知道「到底撤掉了没」。 v2.9.21：这三颗只看【这张纸】的栈，跟顶栏那三颗（两栏大画布）各算各的。 */ var hist = appHistFor(true); var bu = s.el.querySelector('[data-t="undo"]'); var br = s.el.querySelector('[data-t="redo"]'); var bc = s.el.querySelector('[data-t="clear"]'); if (bu) bu.disabled = !hist || hist.at <= 0; if (br) br.disabled = !hist || hist.at >= hist.acts.length; if (bc) bc.disabled = !hist || !hist.acts.length; /* v2.9.20：标记 / 收藏已开就填实心（读原生 li 上的 .active） */ var sub = appSheetSubObj(); [['mark', '标记 / 错题'], ['collect', '收藏']].forEach(function (tr) { var b = s.el.querySelector('[data-t="' + tr[0] + '"]'); if (!b) return; var src = sub && sub.querySelector('li.' + tr[0] + '.tool'); /* 原生的 active 挂在 li 上（Angular 的 _e("active", ques.marked_)）；个别版本会挂到里面的 svg 容器上，两种都认。 */ var on = !!(src && (src.classList.contains('active') || src.querySelector('.active'))); var cls = 'mas-t' + (on ? ' on' : ''); if (b.className !== cls) b.className = cls; var tip = tr[1] + (on ? '（已开，点一下取消）' : '（点一下打开）'); if (b.title !== tip) b.title = tip; }); } function appSheetSize(force) { var s = appCur && appCur.sides && appCur.sides.sheet; if (!s || !s.cv || !s.host) return; var w = Math.max(1, Math.round(s.host.clientWidth || 0)); var h = Math.max(1, Math.round(s.host.clientHeight || 0)); if (w < 2 || h < 2) return; var dpr = Math.min(2, Math.max(1, window.devicePixelRatio || 1)); if (w * dpr * h * dpr > 12e6) dpr = 1; // iOS canvas 像素上限（同 v2.9.15 的护栏） if (!force && s.w === w && s.h === h && s.dpr === dpr) return; s.w = w; s.h = h; s.dpr = dpr; s.cv.width = Math.round(w * dpr); s.cv.height = Math.round(h * dpr); s.cv.style.width = w + 'px'; s.cv.style.height = h + 'px'; appRenderSheet(); } function appSheetBuild() { var old = document.getElementById(APP_SHEET_ID); if (old) old.remove(); if (!appCur) return null; var el = document.createElement('div'); el.id = APP_SHEET_ID; el.innerHTML = '

' + '

' + '' + '' + '

' + '

' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '

' + '

'; document.body.appendChild(el); var head = el.querySelector('.mas-head'); var body = el.querySelector('.mas-body'); var cv = el.querySelector('canvas.mas-ink'); cv.__appSide = 'sheet'; var side = { el: el, cv: cv, ctx: cv.getContext('2d'), host: body, scroller: body, dpr: 1, headH: 72 }; appCur.sides.sheet = side; el.querySelector('[data-t="alpha"]').innerHTML = APP_ICON.alpha; el.querySelector('[data-t="close"]').innerHTML = APP_ICON.close; /* v2.9.20：撤销 / 反撤 / 清空搬进纸头 —— 只作用于【眼前这张纸】； v2.9.21 起跟顶栏那三颗彻底分家（顶栏恒管两栏那张大画布）。 */ [['undo', 'undo', function () { appUndo(true); }], ['redo', 'redo', function () { appRedo(true); }], ['clear', 'trash', function () { appClear(true); }]].forEach(function (tr) { var btn = el.querySelector('[data-t="' + tr[0] + '"]'); btn.innerHTML = APP_ICON[tr[1]] || ''; btn.addEventListener('click', function (ev) { ev.preventDefault(); ev.stopPropagation(); if (btn.disabled) return; tr[2](); }, true); }); [].slice.call(el.querySelectorAll('.mas-szb')).forEach(function (b) { b.addEventListener('click', function (ev) { ev.preventDefault(); ev.stopPropagation(); appSheetSetSize(b.getAttribute('data-sz')); }, true); }); el.querySelector('[data-t="alpha"]').addEventListener('click', function (ev) { ev.preventDefault(); ev.stopPropagation(); appSheetAlphaStep(); }, true); el.querySelector('[data-t="close"]').addEventListener('click', function (ev) { ev.preventDefault(); ev.stopPropagation(); appSheetClose(); }, true); [['mark', 'bookmark', '标记 / 错题'], ['collect', 'star', '收藏']].forEach(function (tr) { var btn = el.querySelector('[data-t="' + tr[0] + '"]'); btn.innerHTML = APP_ICON[tr[1]] || ''; btn.addEventListener('click', function (ev) { ev.preventDefault(); ev.stopPropagation(); var sub = appSheetSubObj(); var src = sub && sub.querySelector('li.' + tr[0] + '.tool'); if (!src) { cvToast(tr[2] + '：这题没有这个按钮'); return; } appAllowOnce(function () { src.click(); }); // 走原生按钮，状态回填全沿用 /* 原生的 marked_ / collected_ 是接口回来之后才翻的（rebuild 一个 tick 后），所以这里多刷几次；刷完图标就填实心了，用户能看到「已经标上」。 */ appSheetSyncTools(); [180, 420, 900].forEach(function (d) { setTimeout(appSheetSyncTools, d); }); }, true); }); /* 拖纸：只能拽纸头空白处（按钮在 appInOwnUI 白名单里，不会误触发拖动） */ head.addEventListener('pointerdown', function (ev) { if (ev.target && ev.target.closest && ev.target.closest('button')) return; ev.preventDefault(); ev.stopPropagation(); try { el.setPointerCapture(ev.pointerId); } catch (e) {} if (appCur.sheetSize === 'l') return; // 大档铺满，没有可拖的余地 var r0 = el.getBoundingClientRect(); var ox = ev.clientX - r0.left, oy = ev.clientY - r0.top; function mv(e2) { appSheetMoveTo(e2.clientX - ox, e2.clientY - oy); } function up() { document.removeEventListener('pointermove', mv, true); document.removeEventListener('pointerup', up, true); document.removeEventListener('pointercancel', up, true); appSheetSavePos(); } document.addEventListener('pointermove', mv, true); document.addEventListener('pointerup', up, true); document.addEventListener('pointercancel', up, true); }, true); /* v2.9.18：不透明度先按存下来的值铺上 */ appCur.sheetAlpha = appCur.sheetAlpha || appSheetAlphaSaved(); return el; } function appSheetSyncHead(force) { var s = appCur && appCur.sides && appCur.sides.sheet; if (!s || !s.el) return; var el = s.el; var numEl = el.querySelector('.mas-num'); var numTxt = appCur.sheetSub || ''; if (numEl && numEl.textContent !== numTxt) numEl.textContent = numTxt; var sub = appSheetSubObj(); var ls = el.querySelector('.mas-ls'); /* 除了题号变化，子题节点被重渲染（同一题号、新 DOM）也要重建字母，否则按钮还指着已经游离的那个

，点了没反应。 */ if (ls && (force || s.headFor !== appCur.sheetSub || s.headEl !== sub)) { s.headEl = sub; s.headFor = appCur.sheetSub; ls.innerHTML = ''; if (sub) { [].slice.call(sub.querySelectorAll('li.choice-radio')).forEach(function (li, k) { var letter = 'ABCD'.charAt(k); if (!letter) return; var b = document.createElement('button'); b.type = 'button'; b.className = 'mas-l'; b.setAttribute('data-letter', letter); b.textContent = letter; b.addEventListener('click', function (ev) { ev.preventDefault(); ev.stopPropagation(); sub.__marvisClickTs = Date.now(); var liNow = [].slice.call(sub.querySelectorAll('li.choice-radio'))[k] || li; var lab = liNow.querySelector('label.choice-radio-label') || liNow.querySelector('label'); if (lab) appAllowOnce(function () { lab.click(); }); appSheetSyncStates(); setTimeout(appSheetSyncStates, 260); // 等原生对错 class 落地再刷一次 }, true); ls.appendChild(b); }); } } appSheetSyncStates(); appSheetSyncTools(); // v2.9.20：换题后标记/收藏要重新读一遍（每题各一份） } function appSheetSyncStates() { var s = appCur && appCur.sides && appCur.sides.sheet; if (!s || !s.el) return; var sub = appSheetSubObj(); var st = sub ? appSubStates(sub) : []; [].slice.call(s.el.querySelectorAll('.mas-l')).forEach(function (b, k) { var cls = 'mas-l' + (st[k] ? ' ' + st[k] : ''); if (b.className !== cls) b.className = cls; }); } function appSheetOpenFor(sub) { var s = appCur && appCur.sides && appCur.sides.sheet; if (!s || !s.el) return; var idx = appSubIndex(sub); appCur.sheetSub = appSubNum(sub, idx < 0 ? 0 : idx); appCur.sheetOpen = true; s.el.classList.add('on'); appCur.sheetSize = appCur.sheetSize || appSheetSizeSaved(); appSheetAlphaApply(appCur.sheetAlpha || appSheetAlphaSaved()); appSheetApplySize(appCur.sheetSize); /* v2.9.22：顶栏高亮先刷 —— 以前它排在纸头刷新之后，纸头刷新一旦抛错（重渲染拿到游离节点等）后面的高亮就整段被跳过，顶栏会停在点之前亮着的那道题上。 */ appQBarSync(); try { appSheetSyncHead(true); appSheetSyncTools(); } catch (e) {} appBarSync(); /* 再补两拍：开纸后的尺寸重算 / Angular 重渲染都在一两帧内发生，晚一点再按纸上的题号刷一次高亮，免得停在旧节点上。 */ setTimeout(appQBarSync, 60); setTimeout(appQBarSync, 320); } function appSheetClose() { if (!appCur) return; if (appCur.stroke) appEndStroke(true); appCur.sheetOpen = false; var s = appCur.sides && appCur.sides.sheet; if (s && s.el) s.el.classList.remove('on'); appBarSync(); appQBarSync(); } function appSheetTeardown() { var el = document.getElementById(APP_SHEET_ID); if (el) el.remove(); if (appCur && appCur.sides) appCur.sides.sheet = null; } var APP_ICON = { close: '', /* v2.9.26：pen / eraser 图标已删（v2.9.16 起「笔」「橡皮」按钮移除，纯装饰） */ undo: '', redo: '', trash: '', cols: '', bookmark: '', star: '', /* v2.9.18：不透明度（半填充圆） */ alpha: '', /* v2.9.23：手写开关（手） */ hand: '' }; function appBarSync() { var bar = document.getElementById(APP_BAR_ID); if (!bar || !appCur) return; var undo = bar.querySelector('[data-k="undo"]'); var redo = bar.querySelector('[data-k="redo"]'); var hist = appActiveHist(); if (undo) undo.disabled = !hist || hist.at <= 0; if (redo) redo.disabled = !hist || hist.at >= hist.acts.length; var dots = bar.querySelectorAll('.mab-dot'); for (var i = 0; i < dots.length; i++) { var on = String(dots[i].getAttribute('data-color')).toLowerCase() === String(brushColor).toLowerCase(); dots[i].className = 'mab-dot' + (on ? ' on' : ''); } var wv = bar.querySelector('[data-k="wv"]'); if (wv) wv.textContent = brushWidth.toFixed(1) + '×'; /* v2.9.23：手写开关的状态 —— 橘色 = 手指也会落墨（防误触关闭） */ var hw = bar.querySelector('[data-k="handwrite"]'); if (hw) { var hwOn = appHandWrite(); hw.className = 'mab-btn hand' + (hwOn ? ' on' : ''); hw.title = hwOn ? '手指也能写（橘色 = 防误触已关，点一下改回只认笔）' : '只认笔：手掌/手指不落墨（点一下让手指也能写）'; } /* v2.9.25：删除原 colfit 按钮的状态同步（按钮已移除） */ /* v2.9.20：纸头那三颗（撤销/反撤/清空）跟着同一条历史走，状态一起刷 */ appSheetSyncTools(); /* v2.9.38：顶栏字号按钮显示当前档位（与右下角胶囊同步） */ var fbtn = bar.querySelector('[data-k="font"]'); if (fbtn) fbtn.textContent = '字号 ' + Math.round(fontZoomGet() * 100) + '%'; } /* ---- v2.9.38 分栏顶栏「题目字号」下拉菜单 ---- v2.9.39 按用户反馈重做交互：竖排档位列表「不好选择」，改为横排大按钮 [A－] [120%] [A＋] —— 与右下角胶囊同一套操作： · 连点 A－/A＋逐步调（每次 ±10%），菜单保持打开，方便连续点； · 点中间百分比 = 重置回 100%； · 点菜单外任意处才收起。档位与胶囊面板共用 fontZoomSet（自动触发草稿纸重测/分栏重排/顶栏标签同步）。 */ var FONT_MENU_ID = 'marvis-app-fontmenu'; function appFontMenuToggle(btn) { var old = document.getElementById(FONT_MENU_ID); if (old) { old.remove(); return; } if (!document.body) return; var menu = document.createElement('div'); menu.id = FONT_MENU_ID; var r = (btn && btn.getBoundingClientRect) ? btn.getBoundingClientRect() : { left: 12, width: 96 }; var vw = window.innerWidth || document.documentElement.clientWidth || 360; var left = Math.max(6, Math.min(r.left, vw - 250)); menu.style.cssText = 'position:fixed;top:' + (APP_BAR_H + 6) + 'px;left:' + Math.round(left) + 'px;' + 'z-index:2147483100;display:inline-flex;align-items:center;gap:8px;padding:8px;border-radius:10px;' + 'background:#fff;border:1px solid #E4E6EB;box-shadow:0 6px 20px rgba(0,0,0,.16);' + 'font:700 16px/1.2 -apple-system,BlinkMacSystemFont,"PingFang SC",sans-serif;color:#2B2F36;' + 'user-select:none;-webkit-user-select:none;touch-action:manipulation;'; var fstyle = 'font:700 16px/1 -apple-system,BlinkMacSystemFont,"PingFang SC",sans-serif;' + 'padding:12px 16px;border-radius:8px;border:1px solid #E4E6EB;background:#F8F9FA;' + 'color:#2B2F36;cursor:pointer;min-height:40px;'; function fbtn(text, color, fn) { var b = document.createElement('button'); b.type = 'button'; b.textContent = text; b.style.cssText = fstyle + (color ? 'color:' + color + ';' : ''); b.addEventListener('click', function (ev) { ev.preventDefault(); ev.stopPropagation(); fn(); var v2 = menu.querySelector('.mfm-val'); if (v2) v2.textContent = Math.round(fontZoomGet() * 100) + '%'; appBarSync(); }, true); menu.appendChild(b); return b; } fbtn('A－', '', function () { fontZoomSet(fontZoomGet() - FONTZOOM_STEP); }); var val = fbtn(Math.round(fontZoomGet() * 100) + '%', '#2F5BEA', function () { fontZoomSet(1); }); val.className = 'mfm-val'; val.title = '点一下 = 重置回 100%'; fbtn('A＋', '', function () { fontZoomSet(fontZoomGet() + FONTZOOM_STEP); }); document.body.appendChild(menu); if (!document.__marvisFontMenuOutside) { document.__marvisFontMenuOutside = 1; document.addEventListener('click', function (ev) { var m = document.getElementById(FONT_MENU_ID); if (!m) return; var t = ev.target; var inMenu = t && typeof t.closest === 'function' && (t.closest('#' + FONT_MENU_ID) || t.closest('[data-k="font"]')); if (!inMenu) { try { m.remove(); } catch (e) {} } }, true); } } function appBar() { var old = document.getElementById(APP_BAR_ID); if (old) old.remove(); var bar = document.createElement('div'); bar.id = APP_BAR_ID; function mk(k, icon, title, fn, extra) { var b = document.createElement('button'); b.className = 'mab-btn' + (extra || ''); b.setAttribute('data-k', k); b.title = title; b.innerHTML = APP_ICON[icon] || icon; b.addEventListener('click', function (ev) { ev.preventDefault(); ev.stopPropagation(); if (b.disabled) return; fn(); }, true); bar.appendChild(b); return b; } mk('close', 'close', '关闭草稿', function () { appClose(); }); /* v2.9.16：这里原来有「笔」「橡皮」两颗按钮，现按用户要求隐藏 —— 橡皮从未实现（title 写着「暂未实现」，disabled，点了没有任何反应）；笔是分栏草稿的唯一模式（appCur.mode 恒为 'pen'，没有别的可切），所以那颗「笔」永远亮着、点它等于空操作。两颗都是纯装饰，收掉。 v2.9.26：APP_ICON.pen / APP_ICON.eraser 图标也已删除（将来真做橡皮再加回）。 */ /* v2.9.17：五颗题号按钮（一道题一颗）—— 点谁滚到谁，并弹出那道题专属的草稿纸。内容区的 ABCD 在分栏里是死的，答题改在纸头那一行（纸 = 这题的面板）。 */ var qg = document.createElement('div'); qg.className = 'mab-qgrp'; qg.setAttribute('data-k', 'qgrp'); bar.appendChild(qg); appQButtons(qg, appSubs()); /* v2.9.2：笔色 / 粗细搬进这条栏。原来的笔色圆点在页面 header 上（app-setting 那一排），进分栏就被顶栏盖住，用户以为「换颜色没有了」——其实是看不见，不是没有。 */ function sep() { var d = document.createElement('span'); d.className = 'mab-sep'; bar.appendChild(d); } sep(); [['#000000', '黑'], ['#1e5eff', '蓝'], ['#e02020', '红']].forEach(function (pair) { var d = document.createElement('button'); d.type = 'button'; d.className = 'mab-dot'; d.setAttribute('data-k', 'color'); d.setAttribute('data-color', pair[0]); d.title = pair[1] + '色'; d.style.background = pair[0]; d.addEventListener('click', function (ev) { ev.preventDefault(); ev.stopPropagation(); brushColor = pair[0]; saveBrush(); if (typeof syncBrushPanel === 'function') { try { syncBrushPanel(); } catch (e) {} } appBarSync(); }, true); bar.appendChild(d); }); sep(); function wk(k, text, title, fn) { var b = document.createElement('button'); b.type = 'button'; b.className = 'mab-w'; b.setAttribute('data-k', k); b.textContent = text; b.title = title; b.addEventListener('click', function (ev) { ev.preventDefault(); ev.stopPropagation(); fn(); appBarSync(); }, true); bar.appendChild(b); return b; } wk('wdec', 'A−', '细一点', function () { brushWidth = Math.max(0.4, Math.round((brushWidth - 0.2) * 10) / 10); saveBrush(); }); var wv = document.createElement('span'); wv.className = 'mab-wv'; wv.setAttribute('data-k', 'wv'); bar.appendChild(wv); wk('winc', 'A+', '粗一点', function () { brushWidth = Math.min(4, Math.round((brushWidth + 0.2) * 10) / 10); saveBrush(); }); /* v2.9.38：题目字号下拉菜单 —— 进分栏后不用再去找右下角胶囊，顶栏直接调；档位与胶囊同一套（90%~160%，步进 10%，记忆共用）。 */ sep(); var fb = document.createElement('button'); fb.type = 'button'; fb.className = 'mab-w'; fb.setAttribute('data-k', 'font'); fb.title = '题目字号：点开选档位（90%~160%），草稿纸跟着变大变小'; fb.addEventListener('click', function (ev) { ev.preventDefault(); ev.stopPropagation(); appFontMenuToggle(fb); }, true); bar.appendChild(fb); /* v2.9.25：删掉顶栏「⇔ 列宽按内容自适应」按钮 —— 列宽已全自动 */ /* v2.9.23：手写开关。放在顶栏而不是纸头 —— ① 它要同时管「两栏大画布」，纸收起来时纸头根本不在； ② 大档铺满时纸从顶栏下沿开始，顶栏一直都在，伸手就够得到； ③ 纸头已经挤了 9 个控件（小档还得折行）。 */ mk('handwrite', 'hand', '只认笔：手掌/手指不落墨（点一下让手指也能写）', function () { var on = !appHandWrite(); appSetHandWrite(on); /* 切回只认笔时，正在写的如果是手指那一笔就收掉（已经画上的留着手动撤） */ var st = appCur && appCur.stroke; if (on === false && st && st.ptype !== 'pen' && st.ptype !== 'mouse') appEndStroke(true); appBarSync(); cvToast(on ? '手指也能写（防误触已关）' : '只认笔：手指不落墨'); }, ' hand'); var sp = document.createElement('span'); sp.className = 'mab-sp'; bar.appendChild(sp); mk('undo', 'undo', '撤销', appUndo); mk('redo', 'redo', '反撤', appRedo); mk('clear', 'trash', '清空', appClear); document.body.appendChild(bar); return bar; } /* ---- 进 / 出 ---- */ function appOpen(group, opts) { opts = opts || {}; if (!group || !isGroupTi(group) || !groupEnabled()) return false; /* v2.9.27：窄视口统一守卫。 appPenEntry 那条入口靠 appModeOn() 把关，但材料工具条上的「打开资料分析草稿」是直接调 appToggle → appOpen 的，不长这个记性 —— 窄屏下点它照样会分出两个 300px 都不到的窄栏。在这里兜一次，比在每个入口重复判断可靠。 */ if (padNarrow()) { if (!opts.quiet) cvToast('窄屏（<' + PAD_NARROW_W + 'px）不支持分栏：横屏或宽屏再用'); return false; } if (appCur) appClose(true); if (fpOwner) { try { fpExit(); } catch (e) {} } appStyle(); var key = 'app-' + groupKeyOf(group); var scrollerL = group.querySelector('.nz-resizable.left') || group.querySelector('.left-section'); var hostL = group.querySelector('.left-section'); var scrollerR = group.querySelector('.right'); var hostR = group.querySelector('.right-section') || group.querySelector('.right-part'); if (!scrollerL || !hostL || !scrollerR || !hostR) { /* v2.9.14：页面还没渲染完时结构可能缺一块 —— 自动打开走静默，稍后重试，不要一句「不支持」把一次渲染竞态定成永久失败。 */ if (!opts.quiet) cvToast('这题的结构不支持分栏草稿'); return false; } group.setAttribute(APP_ATTR, '1'); var saved = appLoad(key); appCur = { group: group, key: key, acts: saved.acts, at: saved.at, mode: 'pen', stroke: null, sides: {}, savedStyle: [], colW: null, /* v2.9.17：每题一张草稿纸（sheets[题号] = {acts, at}），纸默认收起 */ sheets: saved.sheets || {}, sheetSub: null, sheetOpen: false, sheetAlpha: appSheetAlphaSaved(), sheetSize: appSheetSizeSaved(), sheetRect: null, optcMemo: {}, /* v2.9.29：内容代际号——内容监听每次触发 +1，选项列数指纹据此跳过重算 */ optcGen: 0, dirty: false, tickN: 0, healRaf: 0, moContent: null }; appInkBox = null; // 换组了，上一组的「刚写完那笔」不能继续吞 click appCur.fitWindow = Date.now(); // v2.9.25：一屏缩放的重算窗口从进场起算（防振荡） // 记下要改行内样式的元素原貌（退出时原样还回去） // v2.9.3 起列宽也走行内 !important，右栏必须一起存，否则退出后宽度会留在页面上 [group, group.querySelector('.nz-resizable.left'), group.querySelector('.left-section'), group.querySelector('.right')].forEach(function (el) { if (el) appCur.savedStyle.push({ el: el, css: el.getAttribute('style') }); }); /* v2.9.4：整屏已经被组壳占满，页面本身不该再滚。以前没锁 body，手指在栏里滑的时候真正滚的是被盖在下面的页面（实测 385px）—— 视觉上就是「两栏怎么都不动」。这里锁住，栏内滚到底也不会链式带动页面。 */ [document.documentElement, document.body].forEach(function (el) { if (!el) return; appCur.savedStyle.push({ el: el, css: el.getAttribute('style') }); try { el.style.setProperty('overflow', 'hidden', 'important'); el.style.setProperty('overflow-x', 'hidden', 'important'); el.style.setProperty('overflow-y', 'hidden', 'important'); el.style.setProperty('overscroll-behavior', 'none', 'important'); } catch (e) {} }); appInlineFix(); appWatchInline(); appWatchContent(); // v2.9.29：内容变化打脏标记，替代看门狗的盲目全量重绘 appCur.sides.left = appBuildSide('left', scrollerL, hostL); appCur.sides.right = appBuildSide('right', scrollerR, hostR); appBar(); appSheetBuild(); // v2.9.17：草稿纸的 DOM 先建好（收起态），点题号才显示 appQBarSync(); // 五颗题号按钮先标出当前这一题 /* v2.9.25 修「选项区自己排好几下版」：进场先把右栏藏起来，等列数（内部要试排 4/3/2/1 列）和一屏缩放都算完、且布局连续两帧不再变，才放出来。否则试排和缩放的中间态会赶在首帧上屏，看着就是跳好几下。 visibility:hidden 仍然参与布局，量出来的宽高都是真的。 */ var revealHost = appCur.sides.right && appCur.sides.right.host; if (revealHost) revealHost.style.setProperty('visibility', 'hidden', 'important'); appApplyCols(); appSizeAll(); /* 列数的「最优」必须在缩放后的坐标系里判断（缩放是在加宽包裹层的同时把字整体缩小，同一道题在两种坐标系里折行结果不同；scale 大的那版字更大，才是真最优）。所以先缩放 → 在缩放后的比例里定列数 → 再缩放 → 复核一次；有限两轮， scale 提前稳定就收。全程同步执行 + 右栏还藏着，用户看不到任何中间态。 */ appFitMat(); for (var rnd = 0, prevS = appFitScaleOf(appCur.sides.right); rnd < 2; rnd++) { appOptColsFix(true); appFitMat(); var nowS = appFitScaleOf(appCur.sides.right); if (Math.abs(nowS - prevS) < 0.03) break; prevS = nowS; } appRedraw(); appSyncThumbs(); appReveal(revealHost); // 下一帧确认定稿后再显示 appBarSync(); /* v2.9.15：落笔 / 阻挡挂在 document 捕获层（不是滚动容器）—— 页面上任何透明覆盖层都拦不住我们。同函数同 capture 重复 add 不会叠加。 */ document.addEventListener('pointerdown', appShieldDown, true); document.addEventListener('click', appShieldClick, true); appCur.timer = setInterval(function () { if (!appCur) return; if (!appCur.group.isConnected) { appClose(true); return; } /* v2.9.14：页面重渲染可能把顶栏整条干掉（分栏还在、按钮没了）→ 补回来 */ if (!document.getElementById(APP_BAR_ID)) { try { appBar(); appQBarSync(); appBarSync(); } catch (e) {} } appInlineFix(); // Angular 重渲染会重写行内样式，定期按住 appOptColsFix(); // v2.9.25：选项列数自适应同样要按住（重渲染会换节点） // 切题/重渲染可能把画布从 DOM 里摘掉：挂回去再按新尺寸重画 ['left', 'right'].forEach(function (side) { var s2 = appCur && appCur.sides[side]; if (s2 && s2.cv && s2.host && (!s2.cv.isConnected || s2.cv.parentElement !== s2.host)) { try { s2.host.appendChild(s2.cv); } catch (e) {} } }); // 页面可能把列宽写回它自己的值（实测 800ms 内会动行内 style）→ 发现被改回就重算 var Lnow = appCur.group.querySelector('.nz-resizable.left'); if (appCur.colW && Lnow && Math.abs(Lnow.getBoundingClientRect().width - appCur.colW.l) > 6) { appCur.colW = null; appApplyCols(); } /* v2.9.25：切题/重渲染可能把缩放包裹层整个冲掉 → 发现没了就补上（两栏都看） */ if (!appCur.stroke && appCur.sides && ((fitMatOn() && appCur.sides.left && !appFitMatWrapOf(appCur.sides.left)) || (fitRightActive() && appCur.sides.right && !appFitMatWrapOf(appCur.sides.right)))) { try { appFitMat(); } catch (e) {} } /* v2.9.10：笔在写的时候不许量尺寸、不许重绘 —— appSizeSide 会把画布高度临时压成 0 去量内容高，这一下会让栏位 scrollHeight 抖动、 scrollTop 被夹回去；iPadOS 只要看到滚动发生就把笔的指针流 pointercancel 掉，笔画当场断一次。而 appRedraw 又会清空画布重画（那时这一笔还没进 acts）。两件事都在每 700ms 的看门狗里，正好对应「写字时每半秒断一下」。 */ /* v2.9.10：cancel 之后一直没等到笔交回来 → 1.5s 后当它已抬笔收尾，否则孤儿笔会一直挂着（看门狗也会跟着不重绘）。 */ if (appCur.stroke && appCur.stroke.orphan && Date.now() - (appCur.stroke.ts || 0) > APP_ORPHAN_MS) appEndStroke(true); /* v2.9.29：不再每 700ms 盲目「全量量尺寸+全量重绘」（旧版每轮 4 次强制回流 + 3 张画布清空重画全部笔画，空转也烧 CPU/电池）。改为事件驱动：内容监听 / 图片 load / 撤销重做清空 / 转窗 → 脏标记 → rAF 一帧内自愈（appMarkDirty，比旧轮询还快）；这里只在脏或每 8 轮（约 5.6s）兜底时全量，盖住没有任何信号的布局变化。空转 tick 只剩上面的廉价检查。 */ appCur.tickN = (appCur.tickN || 0) + 1; if (appCur.tickN % 8 === 0) appCur.dirty = true; if (!appCur.stroke && appCur.dirty) { appCur.dirty = false; appSizeAll(); appRedraw(); } appSyncThumbs(); }, 700); window.addEventListener('resize', appOnResize); window.addEventListener('click', appPenClickGuard, true); /* v2.9.12：这句提示还是 v2.9.7 的语义（手指滑=滚动），跟现在的「手和笔都只写字」不符 */ /* v2.9.17：提示语跟着新入口改 —— 答题/标记/收藏都在纸头，不在下拉面板里了 */ cvToast('分栏草稿：点顶栏题号开这题的草稿纸；手和笔都只管写字；滚动用两侧滑块'); return true; } function appOnResize() { if (!appCur) return; appCur.fitWindow = Date.now(); // v2.9.25：转窗重开 3.5s 重算窗口（防振荡） /* v2.9.25：栏宽变了 → 先拆掉一屏缩放的包裹层，回到「没缩放」的干净环境重算列数，否则会在加宽坐标系里量出另一个答案；算完再重新缩放一次。 v2.9.26：整组重排收进同一帧——unwrap 与 optcPick 之间若被别的样式读取打断，会量到中间态布局（列数漂移）。 */ if (appCur.resizeRaf) cancelAnimationFrame(appCur.resizeRaf); appCur.resizeRaf = requestAnimationFrame(function () { appCur.resizeRaf = 0; if (!appCur) return; try { appFitMatUnwrap(appCur.sides && appCur.sides.right); } catch (e) {} appFitCols(); // 转屏/改窗口 → 重新算一遍列宽 try { appOptColsFix(); appFitMat(); } catch (e) {} /* v2.9.17：草稿纸也要重新夹回视口（转屏后可能有一半在屏幕外） */ if (appCur.sheetOpen) appSheetApplySize(appCur.sheetSize); appMarkDirty(); // v2.9.29：重排后画布尺寸要跟着量一遍（rAF 合并，不重复量） }); } function appClose(silent) { if (!appCur) return; var cur = appCur; /* v2.9.25：退出分栏把两栏的缩放包裹层都拆掉，页面 DOM 还原成原样 */ try { appFitMatUnwrap(cur.sides && cur.sides.left); } catch (e) {} try { appFitMatUnwrap(cur.sides && cur.sides.right); } catch (e) {} /* v2.9.12：退出前先记住「正在看的那一道子题」。分栏里五道子题是顺排的（共用一张纸），退出后粉笔恢复成一次只显示一道、 tab 索引还停在第一个 → 用户被送回第一题。记住它，退出后再复位回去。 */ var backSub = null; try { backSub = appCurrentSub(); } catch (e) {} appCur = null; if (cur.saveTimer) clearTimeout(cur.saveTimer); if (cur.timer) clearInterval(cur.timer); if (cur.resizeRaf) { cancelAnimationFrame(cur.resizeRaf); cur.resizeRaf = 0; } if (cur.healRaf) { cancelAnimationFrame(cur.healRaf); cur.healRaf = 0; } if (cur.mo) { try { cur.mo.disconnect(); } catch (e) {} cur.mo = null; } if (cur.moContent) { try { cur.moContent.disconnect(); } catch (e) {} cur.moContent = null; } try { cur.group.removeEventListener('load', appMarkDirty, true); } catch (e) {} // v2.9.29 /* v2.9.10：还有一笔没落账（笔还按着 / cancel 留下的孤儿笔）→ 退出前先入库，不能丢 */ if (cur.stroke && !cur.stroke.dead && cur.stroke.pts && cur.stroke.pts.length > 1) { cur.acts.length = cur.at; cur.acts.push(cur.stroke); cur.at = cur.acts.length; cur.stroke = null; } lsSet(appStoreKey(cur.key), JSON.stringify({ acts: cur.acts, at: cur.at, sheets: cur.sheets || {} })); window.removeEventListener('resize', appOnResize); window.removeEventListener('click', appPenClickGuard, true); window.removeEventListener('pointermove', appOnMove, true); window.removeEventListener('pointerup', appOnUp, true); window.removeEventListener('pointercancel', appOnUp, true); document.removeEventListener('pointerdown', appShieldDown, true); // v2.9.15 document.removeEventListener('click', appShieldClick, true); // v2.9.15 /* v2.9.6：把还挂着的笔画滚动手闸和触摸滚动监听一起摘掉 */ if (cur.stroke && cur.stroke.guard && cur.stroke.guardEl) { try { cur.stroke.guardEl.removeEventListener('scroll', cur.stroke.guard, { passive: true }); } catch (e) {} } var bar = document.getElementById(APP_BAR_ID); if (bar) bar.remove(); var fmenu = document.getElementById(FONT_MENU_ID); // v2.9.38：菜单跟着顶栏一起退场 if (fmenu) fmenu.remove(); appSheetTeardown(); // v2.9.17：草稿纸跟着退场（笔画已随组存盘） ['left', 'right'].forEach(function (side) { var s = cur.sides[side]; if (!s) return; if (s.cv) s.cv.remove(); if (s.thumb) s.thumb.remove(); if (s.detachTouch) { try { s.detachTouch(); } catch (e) {} s.detachTouch = null; } }); appOptColsRestore(cur.group); // v2.9.25：选项两列的行内样式原样还回 (cur.savedStyle || []).forEach(function (rec) { try { if (rec.css === null) rec.el.removeAttribute('style'); else rec.el.setAttribute('style', rec.css); } catch (e) {} }); try { cur.group.removeAttribute(APP_ATTR); } catch (e) {} /* v2.9.12：退出后把「刚才在看的那一道」复位回去（否则会被送回第一题）。两条路：展平模式下是页面滚动 → 居中到那道；原生 tab 模式下是切 tab + 容器滚动。 Angular 恢复布局要一两拍，所以补两次。 */ if (backSub && cur.group && isGroupTi(cur.group)) { var backGroup = cur.group; var backFn = function () { try { if (!backGroup.isConnected || !backSub.isConnected) return; if (!backGroup.getAttribute(APP_ATTR)) { if (backGroup.getAttribute(FLAT_ATTR) === '1') { /* 展平模式：五道子题排在页面上，退出时页面滚回「刚才那道」的顶部。不能只靠恢复 scrollY —— 进分栏时把 html/body 的 overflow 锁成 hidden， WebKit 常常顺手把文档滚回 0，所以必须按当前这道题的绝对位置重算。 */ var absTop = backSub.getBoundingClientRect().top + (window.pageYOffset || 0) - 8; var vh = window.innerHeight || document.documentElement.clientHeight || 0; var docH = document.documentElement.scrollHeight || 0; var ty = Math.max(0, Math.round(absTop)); if (docH > 0 && vh > 0) ty = Math.min(ty, Math.max(0, docH - vh)); // 量不到文档高就不夹 window.scrollTo(0, ty); } else { var bsubs = subsOf(backGroup), bi = bsubs.indexOf(backSub); if (bi > 0) activateGroupTab(backGroup, bi); ensureSubVisible(backGroup, backSub); } } } catch (e) {} }; setTimeout(backFn, 60); setTimeout(backFn, 320); } if (!silent) cvToast('已退出分栏草稿'); } // 同一个组再点一次草稿笔图标 = 退出 function appToggle(group) { if (appCur && appCur.group === group) { appClose(); return; } appOpen(group); } /* v2.9.16：整段删掉「组一进视口就自动进分栏」（v2.9.14 加的，用户没有要过）。分栏只由用户点题旁的原生笔图标进入（见 fpPenEntry → appToggle）。教训记在这里，别再自作主张加回来：草稿是用户手上的纸，什么时候铺、铺哪张，必须由用户自己决定 —— 自动铺纸的代价是他在做题时突然被换掉一层界面。 */ /* ---- v2.7.7 草稿范围淡红框提示已删（v2.7.8 用户反馈没用） ---- */ // —— 材料智能适应 v2.7.0（仅材料画布挂「适应」按钮）—— // 点一次 = 整块材料一屏完整显示、文字尽量大。三层杠杆（扰动从小到大）： // L1 缩放：CSS zoom 布局级缩放（高度真实变矮、无需滚动），宽度恒 100% // （v2.7.6：zoom 坐标系里 100% 视觉宽即栏宽，补偿反而溢出被裁）； // L2 宽度：缩放低于 FIT_GOOD 时收窄材料栏——图表 max-width:100% 随栏变矮，材料整体 // 变矮，从而在 100%（或更高倍率）下完整显示；正文不缩只重排。分隔条本就可手拖， // 这里是程序化代拖（直接设左栏宽度，实测 Angular 不会重置，扫描时重复断言）； // L3 兜底：最窄栏 + 下限缩放，仍装不下提示滚动查看。 // 旧版 bug：真实高度锁在内层 .material-body（固定高 + overflow:auto），宿主 // scrollHeight 被内层裁成盒高 → 缩放比算成 ≥1 直接不缩。现在先解锁内层再量。 var FIT_GOOD = 0.82; // 缩放可接受线：≥此值直接用缩放，不动布局 var FIT_MIN_W = 420; // 材料栏收窄下限（px） var FIT_W_STEPS = [0.9, 0.8, 0.7, 0.6, 0.5]; // 收窄档位（相对当前栏宽） var FIT_BOX = 'data-marvis-fitbox'; // 适应临时解锁的内层盒标记 var FIT_W_ATTR = 'data-marvis-fitw'; // 适应收窄栏宽时保存的原始 style var fitGroups = {}; // key → true：该组因适应而被展平（关全局展平时也保持） // 用 CSS zoom 做布局级缩放（高度真实变矮、无需滚动），宽度恒 100%。 // v2.7.6（真机实测定论）：旧版在缩放时把宽度补偿成 100/s%「让文字铺满栏宽」—— // 但 Blink 的 zoom 模型里，百分比宽度是在**被缩放元素的自身坐标系**里解析的： // 探针实测（父 600px）width:100%+zoom:0.858 → 视觉宽恰 600px（已铺满，无需补偿）； // width:116.55%+zoom:0.858 → 视觉宽 699px = 600/0.858，溢出 (1/s-1)×栏宽。 // 补偿让宿主视觉宽 = 栏宽/s，右半被 .left-section 的 overflow-x:hidden 裁掉 // （真机：s=0.858 时视觉 1161px vs 栏宽 996px，右 165px 被裁——用户报 // 「材料图片还是会被裁剪」）。故补偿整体删除，zoom 时宽度恒 100%。 // 画布在宿主内绝对定位、坐标归一化存储，缩放后重放不失真。 function cvZoomApply(host, s) { if (s && s < 1) { host.style.zoom = String(s); host.style.width = '100%'; } else { host.style.zoom = ''; // v2.7.2：不能置空——吸顶展平态下宿主带 flex:0 0 auto，width 置空会按内容 // max-content 排布把整条链撑爆（文字/表格被裁）。固定回 100% 恒等栏宽。 host.style.width = '100%'; } } function cvZoomOf(host) { var z = parseFloat(host.style.zoom); return z > 0 && z < 1 ? z : 0; } // 材料里是否存在「被栏宽钳制的媒体」——图片/表格/SVG 的渲染宽≈宿主宽 // （max-width:100% 生效，或其自身 width:100%）。这类内容的渲染尺寸由栏宽决定： // 其布局宽被钳在「宿主本地宽 = 栏宽/zoom」上，视觉宽恒等于栏宽、视觉高也恒定 // （宽高比随钳制宽走）——zoom 再大也缩不动它，纯缩放档会白给（v2.7.6 实测： // 补偿删除后此结论不变，媒体仍随栏宽而非 zoom 收缩）。此时应优先收窄栏宽(L2)。 // zoom 归一（v2.7.2）：zoom 会改变 rect 与 clientWidth 的坐标系（实测同一盒子 // rect 报布局宽、clientWidth 报另一口径，比值永远判不准），故测量前临时摘掉 // zoom、量完写回——探测器由此可在任何调用时机（含缩放已生效后）安全运行。 function cvHasWidthBoundMedia(host) { if (!host || !host.querySelectorAll) return false; var prevZoom = host.style.zoom; if (prevZoom) host.style.zoom = ''; try { var els = host.querySelectorAll('img, table, svg'); for (var i = 0; i < els.length; i++) { var el = els[i]; if (el.closest && el.closest('.marvis-cv-tools')) continue; // 工具条图标不算 var cs = getComputedStyle(el); if (cs.position === 'absolute' || cs.position === 'fixed') continue; // 钳制宽度 = 父元素的内容宽（max-width:100% 的参照）；宿主自身可能带内边距 var p = el.parentElement; if (!p) continue; var pcs = getComputedStyle(p); var bound = p.clientWidth - (parseFloat(pcs.paddingLeft) || 0) - (parseFloat(pcs.paddingRight) || 0); if (bound <= 0) { // 父元素量不到宽度时退回宿主宽（兜底） var hr0 = host.getBoundingClientRect(); bound = hr0.width || 0; } if (bound <= 0) continue; var r = el.getBoundingClientRect(); if (r.width > 0 && r.width >= bound - 10) return true; } } catch (e) {} finally { if (prevZoom) host.style.zoom = prevZoom; } return false; } // 左栏（.nz-resizable.left）是粉笔的宽度属主；收窄它 = 代用户拖分隔条 function cvLeftCol(group) { return group ? (group.querySelector('.nz-resizable.left') || group.querySelector('.left')) : null; } function cvFitSetWidth(cv, w) { var group = cv.host && cv.host.closest ? cv.host.closest('.ti') : null; var left = cvLeftCol(group); if (!left) return; if (!left.hasAttribute(FIT_W_ATTR)) left.setAttribute(FIT_W_ATTR, left.getAttribute('style') || ''); left.style.setProperty('width', w + 'px', 'important'); } // 还原栏宽：只清理自己设过的（FIT_W_ATTR 在）；没设过就一个像素都不动 // （不能 removeProperty——那会把粉笔自己写在行内的宽度也抹掉） function cvFitClearWidth(cv) { var group = cv.host && cv.host.closest ? cv.host.closest('.ti') : null; var left = cvLeftCol(group); if (!left || !left.hasAttribute(FIT_W_ATTR)) return; left.setAttribute('style', left.getAttribute(FIT_W_ATTR) || ''); left.removeAttribute(FIT_W_ATTR); } function cvFitActive(cv) { if (cvZoomOf(cv.host)) return true; var group = cv.host && cv.host.closest ? cv.host.closest('.ti') : null; var left = cvLeftCol(group); return !!(left && left.hasAttribute(FIT_W_ATTR)); } // 解锁材料内部的滚动盒：.material-body 固定高 + overflow:auto 是真实高度锁， // 不解锁它宿主 scrollHeight 永远等于盒高、量不到内容真实高度。 // 展平已解锁过的（FLAT_BOX）跳过；解锁样式存 RELAX_ATTR 供还原。 function cvUnlockInner(group) { var mat = group.querySelector('.materials-container'); if (!mat) return; var els = [mat].concat([].slice.call(mat.querySelectorAll('*'))); for (var i = 0; i < els.length; i++) { var el = els[i]; if (el.tagName === 'CANVAS') continue; if (el.hasAttribute(FLAT_BOX) || el.hasAttribute(FIT_BOX)) continue; var cs = null; try { cs = getComputedStyle(el); } catch (e) {} var oy = (cs && cs.overflowY) ? cs.overflowY : el.style.overflowY; if (oy === 'auto' || oy === 'scroll' || oy === 'hidden') { if (el.scrollHeight > el.clientHeight + 2) { if (!el.hasAttribute(RELAX_ATTR)) el.setAttribute(RELAX_ATTR, el.getAttribute('style') || ''); el.style.setProperty('overflow', 'visible', 'important'); el.style.setProperty('height', 'auto', 'important'); el.style.setProperty('max-height', 'none', 'important'); el.setAttribute(FIT_BOX, '1'); } } } } // 确保材料内容能流动：解锁内层滚动盒 +（锁态布局下）把该组高度链展平。 // 返回组元素；展平由适应触发时记 fitGroups + __fitOwned，还原时收回。 function cvEnsureFlow(cv) { var host = cv.host; var group = host && host.closest ? host.closest('.ti') : null; if (!group) return null; cvUnlockInner(group); if (group.getAttribute(FLAT_ATTR) !== '1') { try { flattenGroup(group); } catch (e) {} fitGroups[groupKeyOf(group)] = true; cv.__fitOwned = true; } return group; } // 量材料自然高度（zoom=1）与可用高度： // natural = 宿主内容高（解拉伸后）+ 内层滚动盒内容高的较大者； // avail = 内层滚动盒 → 盒高；页面滚动 → 视口高减材料顶部位移（装进视口即完整）。 // 两个坑（真机实测）： // ① flex 拉伸：resizable-container 是 flex 行容器，align-items:stretch 会把左栏 // （连同材料）拉到右栏题目等高——短材料被题目高度撑爆，自然高度虚高 // （实测短文本材料被撑到 1421px，真实内容仅 229px）。量前给链上各层 // align-self:flex-start 中和，量完移除； // ② 画布 absolute 但高度是 px：stale 高度会溢出污染宿主 scrollHeight， // 量前先同步一次画布尺寸。 function cvMeasure(cv) { var host = cv.host; if (!host) return null; var prevZoom = host.style.zoom, prevWidth = host.style.width; host.style.zoom = ''; // v2.7.2：宽度不能置空——宿主带 flex:0 0 auto，置空后按内容 max-content 排布， // 文字材料整块不换行、塌成一行，natural 被量成一行高（真机实测 1196px 材料量成 // ~250px）→ 误判「装得下」不缩放。固定 100%（=栏宽）量得的自然高度才是用户 // 可见排版下的高度；L2 收窄后重量的口径也随之正确。 host.style.width = '100%'; var chain = []; var n = host; while (n) { chain.push(n); if (n.classList && n.classList.contains('resizable-container')) break; n = n.parentElement; } // 记下链上原有的行内 align-self（吸顶左栏自带 flex-start），量完原样写回—— // 早先直接 removeProperty 会把吸顶样式抹掉，左栏重新被拉伸、吸顶失效（v2.7.1） var prevAligns = []; for (var i = 0; i < chain.length; i++) { if (chain[i].style) { prevAligns.push(chain[i].style.getPropertyValue('align-self')); chain[i].style.setProperty('align-self', 'flex-start', 'important'); } else prevAligns.push(''); } try { syncCanvasSize(cv); } catch (e) {} var rect = host.getBoundingClientRect(); // natural = 子树最大 scrollHeight（宿主自身也在列——解拉伸后它就是内容高； // 不从 rect.height 取：那可能是被拉伸/固定的盒高，jsdom 桩也会误判） var natural = 0; var els = [host].concat([].slice.call(host.querySelectorAll('*'))); for (var j = 0; j < els.length; j++) { var el = els[j]; if (el.tagName === 'CANVAS') continue; // v2.9.26：先读 scrollHeight 刷不了最大值就跳过（不再对每个节点取计算样式）； // 只有「可能成为新最大值」的节点才做 absolute/fixed 过滤，结果与原逻辑等价 var sh = 0; try { sh = el.scrollHeight; } catch (e) { continue; } if (sh <= natural) continue; var cs = null; try { cs = getComputedStyle(el); } catch (e) {} if (cs && (cs.position === 'absolute' || cs.position === 'fixed')) continue; // 覆盖层不算 natural = sh; } var top = rect.top || 0; var vh = window.innerHeight || 0; var sc = scrollerOf(host); var isPage = !sc || sc === document.body || sc === document.documentElement; var avail = isPage ? Math.max(0, vh - Math.max(0, top)) : (sc.clientHeight || vh); for (var k = 0; k < chain.length; k++) { if (!chain[k].style) continue; if (prevAligns[k]) chain[k].style.setProperty('align-self', prevAligns[k]); else chain[k].style.removeProperty('align-self'); } host.style.zoom = prevZoom; // 宽度写回：有 zoom 时连补偿值一起还原；无 zoom 也保证不为空（空 → max-content 撑爆） host.style.width = prevWidth || '100%'; if (!natural || avail < 120) return null; return { natural: natural, avail: avail, width: Math.round(rect.width || host.clientWidth || 0) }; } // 应用适应结果：{s: 缩放比(1=不缩), w: 栏宽px(0=还原)} + 持久化 + 按钮文案 function cvFitApply(cv, r) { var host = cv.host; cvZoomApply(host, r.s); if (r.w) cvFitSetWidth(cv, r.w); else cvFitClearWidth(cv); if (r.s && r.s < 1) lsSet(CV_LS_PREFIX + 'zoom-' + cv.key, String(r.s)); else lsRemove(CV_LS_PREFIX + 'zoom-' + cv.key); if (r.w) lsSet(CV_LS_PREFIX + 'fitw-' + cv.key, String(r.w)); else lsRemove(CV_LS_PREFIX + 'fitw-' + cv.key); syncCanvasSize(cv); /* v2.9.25：按钮已改「分栏」入口，不再随缩放状态变文字 */ } // 还原：缩放 100% + 栏宽还原 +（展平由适应触发时）收回展平 function cvFitRestore(cv) { cvFitApply(cv, { s: 1, w: 0 }); if (cv.__fitOwned) { var group = cv.host && cv.host.closest ? cv.host.closest('.ti') : null; if (group) { try { unflattenGroup(group); } catch (e) {} delete fitGroups[groupKeyOf(group)]; } cv.__fitOwned = false; } } // 智能适应主流程：返回 {s, w, msg}；null = 量不出尺寸（布局未就绪） function cvSmartFit(cv) { var host = cv.host; var group = host && host.closest ? host.closest('.ti') : null; if (!group) return null; // 材料不在合理视口位置时先滚到顶：点「适应」= 要一屏看整块材料，滚动是预期行为 // （工具按钮就在材料顶部，正常点击时材料本就在视口里，不会触发滚动） try { var top0 = group.getBoundingClientRect().top || 0; if (top0 < -40 || top0 > (window.innerHeight || 0) - 120) group.scrollIntoView({ block: 'start' }); } catch (e) {} group = cvEnsureFlow(cv) || group; if (!group) return null; var m = cvMeasure(cv); if (!m) return null; // 本来就装得下：全部还原 if (m.natural <= m.avail + 2) { cvFitApply(cv, { s: 1, w: 0 }); return { s: 1, w: 0, msg: '材料已完整显示' }; } var s0 = m.avail / m.natural; // 被栏宽钳制的媒体(图片/表格)：渲染尺寸由栏宽决定，zoom 缩不动它（布局宽被钳在 // 栏宽/zoom 上，视觉宽恒为栏宽）——优先走 L2 收窄，媒体随栏变矮，往往能 100% // 完整装下且不用缩放 var mediaBound = cvHasWidthBoundMedia(host); // L1：缩放就够读 → 不动布局 if (s0 >= FIT_GOOD && !(mediaBound && s0 < 1)) { var s1 = Math.round(s0 * 1000) / 1000; cvFitApply(cv, { s: s1, w: 0 }); return { s: s1, w: 0, msg: '材料已缩放至 ' + Math.round(s1 * 100) + '%，一屏完整显示' }; } // L2：宽度自适应——逐档收窄，图表随栏变矮；争取 100% 完整显示，其次更高缩放比 // 注意去重方向：档位比值递减，只有「没有变得更窄」的档（被 FIT_MIN_W 钳住） // 才跳过；写反成 w<=lastW 会把第一档之后的所有档全部跳过（真机实测：高图 // 材料只量了 840 一档就收尾，最优的 467 档永远摸不到）。 var chosen = null, best = { w: 0, s: s0 }, lastW = 0; for (var i = 0; i < FIT_W_STEPS.length; i++) { var w = Math.max(FIT_MIN_W, Math.round(m.width * FIT_W_STEPS[i])); if (lastW > 0 && w >= lastW) continue; // 档位递减去重 lastW = w; cvFitSetWidth(cv, w); var mm = cvMeasure(cv); if (!mm) break; if (mm.natural <= mm.avail + 2) { chosen = { w: w, s: 1 }; break; } // 100% 装下！ var s = mm.avail / mm.natural; if (s > best.s) best = { w: w, s: s }; // 媒体钳制时不能因 s>=GOOD 就选缩放档——zoom 缩不动被钳制的媒体，白收窄；只认 100% 档 if (!mediaBound && s >= FIT_GOOD) { chosen = { w: w, s: Math.round(s * 1000) / 1000 }; break; } } if (!chosen) { if (mediaBound) { // 收窄也装不下：缩放兜底（缩得动文字部分；媒体部分随收窄后的栏宽， // 视觉尺寸已比原栏宽小，不会被裁——宽度恒 100%，无补偿溢出） chosen = { w: best.w || 0, s: Math.max(best.s, CV_ZOOM_MIN) }; } else { chosen = best; if (chosen.s < CV_ZOOM_MIN) chosen.s = CV_ZOOM_MIN; // L3：可读性下限 } chosen.s = Math.round(chosen.s * 1000) / 1000; } cvFitApply(cv, chosen); var msg = chosen.s >= 1 ? '材料栏收窄至 ' + chosen.w + 'px，材料 100% 完整显示' : (chosen.w ? '材料栏收窄至 ' + chosen.w + 'px + 缩放 ' + Math.round(chosen.s * 100) + '%，一屏完整显示' : '材料已缩放至 ' + Math.round(chosen.s * 100) + '%' + (chosen.s <= CV_ZOOM_MIN ? '（可读性下限），剩余部分滚动查看' : '，一屏完整显示')); return { s: chosen.s, w: chosen.w, msg: msg }; } // 恢复持久化的适应状态（切题重进 / Angular 重渲染后重新断言） // v2.7.5：用户要求「每个资料分析的适应按钮默认就是适应，而不是百分之百」—— // 打开资料分析题（含切题重渲染 / MutationObserver 全量重扫）一律以原始 100% 呈现， // 不再从 localStorage 恢复上次的缩放/收窄；要缩放用户自己点「适应」。 // 按钮文字只按当前 DOM 实际状态校正：已缩放态显「100%」（点了适应再被重扫时 // 文字不能错），未缩放态恒「适应」——这就是用户要的默认态。 // 顺手清掉旧版本遗留的持久化键（存在才删，避免无谓写）。 function cvFitRestoreState(cv) { /* v2.9.25：按钮已改「分栏」入口，不再随缩放状态变文字 */ try { lsRemove(CV_LS_PREFIX + 'zoom-' + cv.key); lsRemove(CV_LS_PREFIX + 'fitw-' + cv.key); } catch (e) {} } // 校准画布尺寸（布局变化 / 解析展开 / 窗宽变化时调用；幂等） // zoom 口径：宿主 zoom 会继承缩放子孙 px 长度（实测 computed 1751px 渲染成 1051px）， // 故视觉高 rh 对应的 CSS 高度要除以 zoom，缩放态下画布仍满覆盖材料。 function syncCanvasSize(cv) { var host = cv.host, canvas = cv.canvas; if (!host || !canvas) return; var w = 0, rh = 0; try { var r = host.getBoundingClientRect(); // 用 rect 口径：zoom 缩放下 clientWidth 不稳 w = r.width || 0; rh = r.height || 0; } catch (e) {} if (!w) w = host.clientWidth || 0; if (!w) return; // 高度：子题用「题干+选项+48」口径；取不到时退化为宿主全高，避免画布裸奔成 300×150 var h = cv.heightFn ? (cv.heightFn(host) || rh || host.clientHeight || 0) : (rh || host.clientHeight || 0); if (!h) return; var z = cvZoomOf(host) || 1; var cssH = z < 1 ? Math.round(h / z) : h; // CSS 高度（布局口径）= 视觉高 / zoom if (canvas.width !== Math.round(w) || canvas.height !== Math.round(h)) { canvas.width = Math.round(w); canvas.height = Math.round(h); penReplay(canvas, cv.strokes); // 归一化坐标 → 按新尺寸重放，笔迹不丢 } canvas.style.width = '100%'; canvas.style.height = cssH + 'px'; } // 在宿主上挂画布 + 工具按钮（幂等：CV_ATTR+CV_VER + 元素上的引用双保险） // heightFn(host) → 画布像素高度；传 null 表示覆盖整个宿主。 // opts.fpEligible（v2.7.7，仅资料分析组内子题）：不在宿主里建画布——「可书写」 // 时展开的是 body 级整页草稿层（fpOpen 把 cv.canvas 指向层内 canvas），宿主里 // 只留工具条。其他画布（材料/普通题）一律不走这条路径，行为零改动。 function ensureOverlayCanvas(host, key, heightFn, toolsPos, opts) { opts = opts || {}; var fpEligible = !!opts.fpEligible; if (!host) return null; var isMat = toolsPos === 'top'; // 材料画布（toolsPos=top）：工具条是顶部通栏 band，宿主打标记让 CSS 把 // .material-body 内容压到 band 下方——按钮不再悬浮遮住材料文字（v2.7.1）； // v2.7.8 起 band 里只有「适应」按钮，不再有画布 if (isMat && host.classList) host.classList.add('marvis-mat-host'); var existing = host.__marvisCv; // 不仅要属性/引用对得上，还要画布与工具仍在文档中：Angular 局部重渲染可能只销毁 // 子节点（canvas/tools 没了但宿主属性还在），此时必须自愈重建，否则用户看不到画布。 // fpEligible 画布收起态没有 canvas（整页层未展开），材料 cv（v2.7.8）本就无 canvas， // v2.8.0 起 fpEligible 也不再在宿主里挂工具条（改用右侧草稿竖条），都不能因此判定失效而反复重建。 if (existing && host.getAttribute(CV_ATTR) === CV_VER && (existing.fpEligible || (existing.tools && existing.tools.isConnected)) && (existing.canvas ? existing.canvas.isConnected : (!!existing.fpEligible || !!existing.matToolsOnly))) { if (!existing.fpEligible && !existing.matToolsOnly) syncCanvasSize(existing); return existing; } // v2.7.7：宿主被 Angular 重渲染/切题销毁 → 旧画布报废，它占用的整页层先收掉 if (fpOwner && fpOwner.host === host) fpClose(); host.setAttribute(CV_ATTR, CV_VER); // 重建前清掉残留的旧画布/旧工具（Angular 重渲染或版本升级换代）， // 否则旧工具的闭包绑在已销毁的 cv 上，会出现「双工具按钮、清空写错对象」 var stale = host.querySelectorAll('canvas.marvis-pen, .marvis-cv-tools'); [].slice.call(stale).forEach(function (el) { el.remove(); }); var saved = cvLoad(key); // v2.7.8：材料区（toolsPos=top）不再建草稿画布/切换/清空（用户要求删除—— // 整页草稿已覆盖材料书写，按钮无用）；「适应」是独立功能保留，工具条只剩它。 // 材料的 cv 只服务适应逻辑（zoomBtn/cvFit*），无笔迹无模式切换。 var cv = { key: key, host: host, canvas: null, tools: null, toggleBtn: null, clearBtn: null, zoomBtn: null, strokes: !isMat && saved ? cvSanitize(cvCap(saved.strokes)) : [], // 默认模式按画布类型，且不记忆（v2.7.6，用户要求）：子题画布恒「当前可触摸」 // （题目区常需要滚动/点选）；localStorage 里的 mode 只写不读——每次打开/刷新 // 都按类型重置。材料区 v2.7.8 起无画布无模式，此处仅占位。 mode: isMat ? 'draw' : 'pass', heightFn: heightFn, clearArmed: 0, // v2.7.7：资料分析子题标记——「可书写」展开整页草稿层而非题目框画布 fpEligible: fpEligible, // v2.7.8：坐标系版本（2=视口归一化，整页草稿层用）；saved.v>=2 说明旧笔迹 // 已迁移过，不能再迁（否则每次重开都把视口坐标当框坐标再变换一次） coordVer: fpEligible ? 2 : 1, __fpMigrated: !!(fpEligible && saved && saved.v >= 2), // v2.7.8：材料 cv 无画布标记（幂等检查用） matToolsOnly: isMat }; // v2.8.0：fpEligible（资料分析子题）宿主里不再挂任何悬浮按钮——「当前可触摸 / // 当前可书写」「清空」「退出」全部收进右侧草稿竖条（#marvis-fp-dock）， // 入口用题目右上角的原生草稿笔图标。材料 cv 只有「适应」。 var tools = null; if (!fpEligible) { tools = document.createElement('div'); tools.className = 'marvis-cv-tools ' + (toolsPos === 'bottom' ? 'marvis-cv-tools-bottom' : 'marvis-cv-tools-top'); } var toggle = null; if (!isMat && !fpEligible) { toggle = document.createElement('button'); toggle.type = 'button'; toggle.className = 'marvis-cvbtn'; toggle.addEventListener('click', function (ev) { ev.preventDefault(); ev.stopPropagation(); var idx = CV_MODES.indexOf(cv.mode); cv.mode = CV_MODES[(idx < 0 ? 0 : idx + 1) % CV_MODES.length]; applyCvMode(cv); cvSave(cv.key, cv.strokes, cv.mode, cv.coordVer); if (cv.mode === 'draw') cvToast(drawLabel(cv)); else cvToast(passLabel(cv)); }); } var clear = null; if (!isMat && !fpEligible) { clear = document.createElement('button'); clear.type = 'button'; clear.className = 'marvis-cvbtn'; clear.textContent = '清空'; clear.title = '清空本画布笔迹（两步确认）'; clear.addEventListener('click', function (ev) { ev.preventDefault(); ev.stopPropagation(); var now = Date.now(); if (now - cv.clearArmed < 3000) { cv.strokes.splice(0, cv.strokes.length); // 原地清空：canvas.__marvisStrokes 引用保持有效 if (cv.canvas) penReplay(cv.canvas, cv.strokes); // fp 收起态 canvas=null，跳过重放 cvSave(cv.key, cv.strokes, cv.mode, cv.coordVer); cv.clearArmed = 0; clear.textContent = '清空'; clear.classList.remove('marvis-cvbtn-warn'); } else { cv.clearArmed = now; clear.textContent = '确认清空'; clear.classList.add('marvis-cvbtn-warn'); setTimeout(function () { if (cv.clearArmed === now) { cv.clearArmed = 0; clear.textContent = '清空'; clear.classList.remove('marvis-cvbtn-warn'); } }, 3000); } }); } // 材料（toolsPos=top）挂「适应」：v2.9.25（用户定稿）改成「分栏」入口—— // 分栏模式里有更完整的材料一屏/选项一屏，老的智能缩放适应用不上了。 // 点击 = 该组进/出分栏（同题旁笔图标的 appToggle 语义）。 var zoomBtn = null; if (toolsPos === 'top') { zoomBtn = document.createElement('button'); zoomBtn.type = 'button'; zoomBtn.className = 'marvis-cvbtn'; zoomBtn.textContent = '打开资料分析草稿'; zoomBtn.title = '打开资料分析草稿：左右分栏 + 材料/选项各自一屏'; zoomBtn.addEventListener('click', function (ev) { ev.preventDefault(); ev.stopPropagation(); // v2.9.25 修复：cv 是普通对象没有 closest，按钮永远弹「结构不支持」—— // 要从宿主元素（材料容器）往上找组 var group = cv && cv.host && cv.host.closest ? cv.host.closest('.ti') : null; if (group && isGroupTi(group)) { appToggle(group); return; } cvToast('这题的结构不支持分栏草稿'); }); cv.zoomBtn = zoomBtn; } if (tools && toggle) tools.appendChild(toggle); if (tools && zoomBtn) tools.appendChild(zoomBtn); if (tools && clear) tools.appendChild(clear); if (tools) host.appendChild(tools); cv.tools = tools; cv.toggleBtn = toggle; cv.clearBtn = clear; host.__marvisCv = cv; cvRegistry.push(cv); if (fpEligible) { // v2.7.7：子题画布 = 整页草稿层（展开时 cv.canvas 才指向层内 canvas）， // 宿主里不建 canvas、不挂框内笔事件；默认「可触摸」即收起态。 applyCvMode(cv); return cv; } if (isMat) { // v2.7.8：材料区无画布无笔事件——cv 只服务「适应」按钮 return cv; } var canvas = document.createElement('canvas'); canvas.className = 'marvis-pen pen'; // pen → ⑤笔刷 hook 生效 canvas.setAttribute('data-marvis-cvkey', key); canvas.__marvisStrokes = cv.strokes; // 测试/排障挂钩 host.appendChild(canvas); cv.canvas = canvas; syncCanvasSize(cv); applyCvMode(cv); attachPen(canvas, cv); penReplay(canvas, cv.strokes); // 宿主尺寸变化（材料栏拖拽 / 窗口缩放 / 解析展开）时按归一化坐标重放 if (typeof window.ResizeObserver === 'function') { try { var ro = new window.ResizeObserver(function () { syncCanvasSize(cv); }); ro.observe(host); cv.ro = ro; } catch (e) {} } return cv; } function ensureMaterialCanvas(group) { var host = group.querySelector('.materials-container'); if (!host) return null; var cv = ensureOverlayCanvas(host, 'mat-' + groupKeyOf(group), null, 'top'); // 画布已存在（重渲染/切题重扫）时也校正按钮文字：v2.7.5 起默认不恢复持久化 // 缩放（用户要求每个资料分析组默认就是「适应」），只按 DOM 实际状态校正文字 if (cv) cvFitRestoreState(cv); return cv; } // fpEligible：仅资料分析组内子题传 true（v2.7.7，用户明确要求别的题型不变）—— // 普通题走粉笔原生草稿、材料画布本就通栏，都不碰整页层。 function ensureSubCanvas(sub, fpEligible) { // v2.8.1：整页草稿只给「一拖五」组内子题；其它宿主一律不建（防止 v2.8.0 那种 // 把普通题当子题的误建，普通题继续走粉笔原生草稿） if (fpEligible && !fpGroupOfSub(sub)) return null; var qkey = sub.getAttribute('data-question-key'); var key = qkey ? 'sub-' + qkey : 'sub-h' + hashText((sub.querySelector('.title-index') || { textContent: '' }).textContent || ''); // 高度口径与普通题一致：题干+选项区 + 48；工具按钮放下方留白区，避开题目工具条 return ensureOverlayCanvas(sub, key, draftTargetHeight, 'bottom', { fpEligible: fpEligible }); } /* ---------- 单题 / 组处理 ---------- */ // opts.force：用户主动触发（下一题 / 强制全开），无视视口门控； // opts.sync：是否同步回填；缺省时随视口门控（滚动扫描只同步视口附近的题）。 function processTi(ti, opts) { opts = opts || {}; /* v2.9.29：opts.near 允许调用方直接声明视口判定结果（IO 进场事件 / nearSet 已知远近），免去每题一次 getBoundingClientRect；未声明时维持原有就地量测口径。 */ var near = opts.force || (opts.near !== undefined ? !!opts.near : nearViewport(ti)); var doSync = opts.sync === undefined ? near : opts.sync; if (isGroupTi(ti)) { // v2.8.2：右下角胶囊面板可「部分关闭」——资料分析（1拖5）板块整体不介入， // 完全交还粉笔原生：不隐藏组级草稿、不展平、不加字母盒、不建材料画布、 // 没有整页草稿与草稿竖条。普通题照常。 if (!groupEnabled()) return; neutralizeGroupDraft(ti); // 组级原生草稿：覆盖全组、吃掉指针事件，持续压制 try { // 展平门控：全局开或该组有进行中的适应（适应会自己展平锁态组） if (flattenEnabled() || fitGroups[groupKeyOf(ti)]) flattenGroup(ti); else unflattenGroup(ti); } catch (e) { // 展开失败不静默：控制台给原因（胶囊已改为脚本总开关，不再承载展开状态） if (window.console && console.warn) console.warn('[marvis] 展开失败：', e && e.message); } var subs = subsOf(ti); subs.forEach(function (sub) { buildBox(sub); if (doSync) syncFeedback(sub); }); if (near) { ensureMaterialCanvas(ti); // 解锁盒子后材料仍可见（整宽排在题目上方），共享画布保留 // v2.7.7：组内子题 = 资料分析专属整页草稿（fpEligible）；材料画布与 // 普通题的原生草稿都不走这条路径 subs.forEach(function (s) { ensureSubCanvas(s, true); }); /* v2.9.16：不再自动进分栏（v2.9.14 的 appMaybeAutoOpen 已删） */ } return; } buildBox(ti); if (doSync) syncFeedback(ti); // 页面重进 / 元素复用后按既有作答状态回填按钮颜色 if (near) { autoOpenDraft(ti); lockDraft(ti); } } /* ---------- v2.7.4 答题卡折叠把手透明化 ---------- */ // 页面左下角「答题卡 13/130」小白卡（.answer-card-tag）挡题面文字，用户要求全透明。 // 三个事实决定实现方式：① 白卡是 SVG path 的 fill/stroke（不是背景色），只能 CSS 褪； // ② 折叠/展开是 fixed 容器的 transform 位移——不增删节点、不挂类， // MutationObserver 完全无声，且三态容器类名一模一样、没有状态类可钩； // ③ 展开态下这个 tag 就是答题卡面板的头部，一概全透会让面板头部穿帮。 // 故按容器位置判定（rect.top >= 视口高 = 已缩到视口外 = 折叠态）打 .marvis-ac-clear 类， // 只透折叠态。scan() 内调一次（DOM 变化即同步）+ 400ms 轮询兜底（位移无事件）。 // 该把手是全页唯一答题卡入口：只褪色、不隐藏、不拦点击。 var AC_CLEAR_CLS = 'marvis-ac-clear'; var acIo = null, acIoEl = null; function acSetCls(c, collapsed) { if (c.classList.contains(AC_CLEAR_CLS) !== collapsed) c.classList.toggle(AC_CLEAR_CLS, collapsed); } var acEl = null; // v2.9.34：容器缓存——省掉每轮扫描/2s 兜底一次全文档 querySelector function acWatch() { // 整体 try/catch：这是装饰性同步，任何环境缺桩（如单测的极简 document）都只能静默跳过， // 绝不能把 scan() 带崩（brush-test 的 document 桩就没有 querySelector） try { var c = (acEl && acEl.isConnected) ? acEl : (acEl = document.querySelector('.answer-card-container')); if (!c || !c.classList) return; /* v2.9.29：优先用 IntersectionObserver 盯容器——折叠/展开是 transform 位移， IO 与 getBoundingClientRect 口径一致（都含 transform），位移即触发回调，省掉常驻 400ms 轮询的强制布局；容器被 Angular 换新时自动改挂新节点。回调内仍按 gBCR 判定（含 -2px 容差），与旧口径完全一致。 */ if (typeof IntersectionObserver === 'function') { if (!acIo) { acIo = new IntersectionObserver(function (entries) { for (var i = 0; i < entries.length; i++) { var el = entries[i].target; if (!el.isConnected) continue; try { var vh = (window && window.innerHeight) || 0; acSetCls(el, el.getBoundingClientRect().top >= vh - 2); } catch (e) {} } }, { threshold: 0 }); } if (acIoEl !== c) { if (acIoEl) { try { acIo.unobserve(acIoEl); } catch (e) {} } acIo.observe(c); acIoEl = c; } } // 每轮 scan 仍按 gBCR 幂等校准一次（覆盖 IO 首个回调前与边缘口径），代价可忽略 acSetCls(c, c.getBoundingClientRect().top >= ((window && window.innerHeight) || 0) - 2); } catch (e) {} } /* ---------- 全量扫描 ---------- */ // v2.9.26：顺带回收死画布——Angular 重渲染销毁题目后 cv 对象（含 strokes）若留在 // cvRegistry 里会一直占内存、pagehide 还会白写一遍。扫到已断开的条目就地丢弃。 var cvPurgeAt = 0; function cvPurgeDead() { var now = Date.now(); if (now - cvPurgeAt < 2000) return; // 2s 一次足够，不必每帧都过滤数组 cvPurgeAt = now; for (var i = cvRegistry.length - 1; i >= 0; i--) { var cv = cvRegistry[i]; if (!cv || !cv.host || !cv.host.isConnected) { if (cv && cvSaveTimers[cv.key]) { clearTimeout(cvSaveTimers[cv.key]); cvSaveTimers[cv.key] = 0; } cvRegistry.splice(i, 1); } } // flatAncestors 同理：元素被拆掉后别拖着引用阻止 GC for (var j = flatAncestors.length - 1; j >= 0; j--) { if (!flatAncestors[j] || !flatAncestors[j].isConnected) flatAncestors.splice(j, 1); } } function scan(force) { /* v2.9.27：@match 放宽到整个 fenbi.com 之后，非做题页（官网首页 / 课程页）一律不注入 UI、不跑扫描。清理类动作放到守卫之前 —— 从做题页退回首页时，挂着的整页草稿层和孤儿画布要能照常收回。 */ fpCloseIfStale(); // v2.7.7：切题/重渲染后旧画布报废，它占的整页层随之收回 cvPurgeStrayFp(); // v2.8.1：清掉误建在普通题上的整页草稿画布（旧版本残留） cvPurgeDead(); // v2.9.26：回收断开的画布/祖先引用 if (!quizPage()) return; masterChip(); // v2.9.27：SPA 从首页进到做题页时才挂胶囊（首次 scan 可能早于渲染） ensureBrushPanel(); placeBrushPanel(); acWatch(); // v2.7.9：只有「可书写」态才需要补锁滚动；可触摸态是真·滚动状态，不能锁 if (fpOwner && fpOwner.mode === 'draw') fpLockScroll(); ioSetup(); // 首次 scan 可能早于 startMO，这里兜底装上 IO var list = tis(); var ioOn = !!ioNear; for (var i = 0; i < list.length; i++) { if (ioOn) ioWatch(list[i]); // 交给 IO 跟踪「接近视口」，滚动时只补集合内的 /* v2.9.29：IO 环境下远近直接查 nearSet（进出场时已判定），不再对全部 .ti 逐个 getBoundingClientRect——110 题每轮全扫省下 110+ 次强制布局读取；无 IO 的旧环境退化回 nearViewport 就地量测，行为不变。 */ processTi(list[i], force ? { force: true, sync: true } : (ioOn ? { near: !!(nearSet && nearSet.has(list[i])) } : null)); } } /* ---------- v2.9.26 视口门控（IntersectionObserver） ---------- 旧实现：每次 scroll（rAF 节流）都跑全量 scan()——110 题逐个 processTi，每帧一遍 getBoundingClientRect + 幂等检查，滚动是主线程卡顿的大头。现在 IO 用 rootMargin 对齐 nearViewport 的 ±0.6/1.6 vh 口径： · 进入扩展视口 → 立刻 processTi（开草稿/建画布的重活只发生在真正靠近时） · 离开 → 从 nearSet 摘掉，滚动 tick 只处理集合内的题没有 IO 的旧环境自动退化为 nearViewport() 逐个判断，行为不变。 */ var nearSet = (typeof WeakSet === 'function') ? new WeakSet() : null; var nearArr = []; // v2.9.29：同一集合的可迭代副本（WeakSet 不可枚举）——滚动补扫只走它 var ioNear = null; function ioSetup() { if (ioNear || typeof IntersectionObserver !== 'function') return; var rootMargin = (NEAR_MARGIN_BELOW * 100) + '% 0px ' + (NEAR_MARGIN_ABOVE * 100) + '% 0px'; ioNear = new IntersectionObserver(function (entries) { for (var i = 0; i < entries.length; i++) { var en = entries[i], ti = en.target; if (en.isIntersecting) { if (nearSet) nearSet.add(ti); if (nearArr.indexOf(ti) === -1) nearArr.push(ti); /* v2.9.29：near:true——IO 已判定在扩展视口内，不再重复 getBoundingClientRect */ try { processTi(ti, { sync: true, near: true }); } catch (e) {} } else { if (nearSet) nearSet.delete(ti); var ix = nearArr.indexOf(ti); if (ix > -1) nearArr.splice(ix, 1); } } }, { rootMargin: rootMargin, threshold: 0 }); } function ioWatch(ti) { if (!ioNear || ti.__marvisIO) return; ti.__marvisIO = 1; ioNear.observe(ti); } /* ---------- SPA 增量渲染适配 ---------- */ // 除 childList 外必须监听属性级变化：粉笔重进恢复作答时可能只写 checked 属性 / 切 class， // 不增删节点，childList-only 观察者完全无声（做题模式 ABCD 按钮不回填的根因之一）。 var MO_ATTRS = ['checked', 'class', 'aria-checked', 'aria-selected', 'aria-pressed']; var pending = false; var lastFullScan = 0; var fullScanTimer = 0; /* v2.9.35：自有 UI 白名单——竖条/toast/笔刷面板/分栏顶栏/草稿纸/滑块都挂在 body 上，不在白名单里的话，它们每次挂载或改文字都会被 MO 当成「.ti 外的结构变化」触发一次无谓的全量 scan。 */ var MO_OWN_SEL = '#marvis-flat-chip, #marvis-fp-dock, #marvis-fp-layer, #marvis-cv-toast, ' + '.marvis-brush-panel, #marvis-app-bar, #marvis-app-sheet, .marvis-app-thumb, .marvis-pen-diag-box, ' + '#marvis-app-fontmenu'; function moSelfMutation(t) { if (t && t.nodeType !== 1) t = t.parentElement; // v2.9.34：characterData 的目标是文本节点 if (!t || typeof t.closest !== 'function') return false; if (t.classList && t.classList.contains('answer-card-container')) return true; if (t.hasAttribute && (t.hasAttribute('data-marvis-snap-veil') || t.hasAttribute('data-marvis-cvkey'))) return true; try { return !!t.closest(MO_OWN_SEL); } catch (e) { return false; } } /* v2.9.34：DOM 代际号 —— MO 每处理一批 records 就 domEpoch++（滚动补扫据此跳过「没有任何变化的纯滚动」）；结构代际 structEpoch 只在出现 childList 时++， isGroupTi 的记忆化据此失效重查。 */ var domEpoch = 1; var nearEpoch = 0; // 上次滚动补扫处理到的 domEpoch var lastNearRun = 0; // 2s 兜底：即使没有 mutation，也保证最多 2s 补扫一次 var mo = new MutationObserver(function (records) { if (pending) return; pending = true; requestAnimationFrame(function () { pending = false; domEpoch++; var hasChild = false; for (var r = 0; r < records.length; r++) { if (records[r].type === 'childList') { hasChild = true; break; } } if (hasChild) structEpoch++; // 属性/文本变化只影响按钮回填：按 mutation 目标向上找 .ti 精准同步，避免全量重扫； // 目标不在任何 .ti 内（如题目列表容器新增子节点）说明结构变了，走完整 scan。 var targets = []; var needFull = false; for (var i = 0; i < records.length; i++) { var t = records[i].target; if (t && t.nodeType !== 1) t = t.parentElement; // v2.9.34：文本节点 → 其父元素 if (moSelfMutation(t)) continue; var ti = t && typeof t.closest === 'function' ? t.closest('.ti') : null; if (ti) { if (targets.indexOf(ti) === -1) targets.push(ti); } else { needFull = true; } } if (needFull || !targets.length) { // v2.9.26：连发 mutation（Angular 批量重渲染）只补一次全量 scan—— // 尾随定时器全局只挂一个，突发不会叠出一串 scan var now = Date.now(); if (now - lastFullScan >= MO_FULLSCAN_GAP) { lastFullScan = now; scan(); } else if (!fullScanTimer) { fullScanTimer = setTimeout(function () { fullScanTimer = 0; lastFullScan = Date.now(); scan(); }, MO_FULLSCAN_GAP - (now - lastFullScan)); } } else { // 属性变化只影响按钮回填：按 mutation 目标向上找 .ti 精准同步（组会展开到子题）， // 避免全量重扫；sync 显式开启，不随视口门控（交互刚发生，必须立即上色）。 for (var j = 0; j < targets.length; j++) processTi(targets[j], { sync: true }); } }); }); function startMO() { mo.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: MO_ATTRS, characterData: true /* v2.9.34：文本节点更新（Angular 就地改绑定文本）也要驱动补扫代际——否则字体/文本重排后 lockDraft 高度会陈旧 */ }); ioSetup(); } // ⑨ 滚动只补「接近视口」的题（rAF 节流；passive 不拦滚动）—— // v2.9.26：不再每次滚动都全量 scan（面板/答题卡/全表遍历），重活交给 IO 进场事件。 // v2.9.34：再加一道 DOM 代际闸——滚动本身不产生 mutation，近视口集在两次 mutation // 之间根本不会变（进场/离场由 IO 事件即时处理），纯滚动时整段补扫直接跳过： // 旧版每滚动帧仍要对每道近视口题做 buildBox+lockDraft（~90 次 querySelector + // 30 次 gBCR/帧）。窗口 load 捕获（图片晚到改变布局但无 MO 事件）与 2s 兜底 // 保证任何无信号的布局变化最迟 2s 被补上。 var scrollPending = false; function scanNear() { if (fpOwner && fpOwner.mode === 'draw') fpLockScroll(); var now = Date.now(); if (domEpoch === nearEpoch && now - lastNearRun < 2000) return; nearEpoch = domEpoch; lastNearRun = now; /* v2.9.29：IO 环境下滚动补扫只处理 nearArr 里的题（IO 进出场时已登记），不再每帧全表 querySelectorAll('.ti') + 逐题成员判定；同步一并跳过—— 回填在 IO 进场那次 processTi 已做过，滚动本身不改变作答状态（作答变化自有 MO 属性监听 / setter hook / change 捕获三条路兜底）。 */ if (ioNear && nearSet) { for (var i = nearArr.length - 1; i >= 0; i--) { var ti = nearArr[i]; if (!ti || !ti.isConnected) { nearArr.splice(i, 1); continue; } processTi(ti, { near: true, sync: false }); } return; } var list = tis(); // 没有 IO 的环境退化为 nearViewport 逐个判断（行为不变） for (var j = 0; j < list.length; j++) { if (nearViewport(list[j])) processTi(list[j], null); } } window.addEventListener('scroll', function () { if (scrollPending) return; scrollPending = true; requestAnimationFrame(function () { scrollPending = false; scanNear(); }); }, { passive: true }); // v2.9.34：图片/iframe 晚到会改布局但不产生 MO 事件 → 推一次补扫代际， // 让下一次滚动帧（或 2s 兜底）能重新校准 lockDraft 高度 try { document.addEventListener('load', function () { domEpoch++; }, true); } catch (e0) {} // v2.8.0：资料分析子题的原生草稿笔图标 = 整页草稿开关。 // 文档捕获层注册得比 fpPassClick 早 → 锁定态下也能先被我们接管（不会被白名单以外吃掉） // v2.9.0（真机实测）：粉笔自己在 **window 捕获层** 就把 click 截停了（探针：win-cap 有、 // doc-cap 没有），挂在 document 上根本收不到 → 改挂 window 捕获层（比 document 更早）， // document 那份保留作兜底，用 WeakSet 给同一事件去重，防止一次点击触发两回。 window.addEventListener('click', fpPenEntry, true); document.addEventListener('click', fpPenEntry, true); // v2.9.36：启动时应用记忆的题目字号（scan 前，首轮渲染就按档位排版） try { document.documentElement.style.setProperty('--marvis-font-zoom', String(fontZoomGet())); } catch (eFz) {} if (document.body) { scan(); startMO(); } else { document.addEventListener('DOMContentLoaded', function () { scan(); startMO(); }); } // 草稿层动态插入后补偿锁定一次 setTimeout(function () { scan(); }, 800); // v2.7.4：答题卡折叠/展开是 transform 位移（无 MutationObserver 事件可搭）。 // v2.9.29：有 IO 时改由 IO 位移事件驱动（acWatch 内自动挂观察），轮询降为 2s 低频兜底 // （覆盖 IO 口径偏差/回调丢失）；无 IO 的旧环境维持 400ms 原频。 setInterval(acWatch, typeof IntersectionObserver === 'function' ? 2000 : 400); window.__MARVIS_FENBI_SCAN__ = scan; // 逃生门：强制全开所有题的草稿与画布（视口门控只影响「自动」打开） window.__MARVIS_FENBI_OPEN_ALL__ = function () { scan(true); }; // 一拖五展开开关：__MARVIS_FENBI_FLATTEN__() 无参切换；传 true/false 显式设置；返回新状态 window.__MARVIS_FENBI_FLATTEN__ = function (on) { if (on === undefined) on = !flattenEnabled(); lsSet(FLAT_LS, on ? '1' : '0'); lsRemove(FLAT_LS_OLD); // 清掉旧 key，避免旧状态继续误导 scan(true); return on; }; // 结构自检：返回每组的层级/内联样式/计算样式/滚动尺寸，排查「没生效」时先跑这个 window.__MARVIS_FENBI_DIAG__ = function () { var groups = tis().filter(isGroupTi); var out = { version: SCRIPT_VER, flattenEnabled: flattenEnabled(), groups: groups.length, detail: [] }; groups.forEach(function (g) { var rc = g.querySelector('.resizable-container'); var left = g.querySelector('.nz-resizable.left'); var qc = g.querySelector('.questions-container'); var cs = function (el, k) { try { return el ? getComputedStyle(el)[k] : null; } catch (e) { return null; } }; // 祖先滚动壳链（排查「没延伸」先看这里：谁在 overflow auto/scroll/hidden 且内容超高） var ancestors = []; var anc = g.parentElement; while (anc && anc !== document.body && anc !== document.documentElement) { ancestors.push({ el: anc.tagName.toLowerCase() + (anc.className && typeof anc.className === 'string' ? '.' + anc.className.split(' ').slice(0, 2).join('.') : ''), pos: cs(anc, 'position'), oy: cs(anc, 'overflowY'), h: cs(anc, 'height'), sh: anc.scrollHeight, ch: anc.clientHeight }); anc = anc.parentElement; } out.detail.push({ flat: g.getAttribute(FLAT_ATTR), rcInlineH: rc ? rc.style.height : null, rcComputedH: cs(rc, 'height'), leftInlineW: left ? left.style.width : null, leftComputedW: cs(left, 'width'), qcInlineOverflow: qc ? qc.style.overflow : null, qcComputedOverflowY: cs(qc, 'overflowY'), qcScrollH: qc ? qc.scrollHeight : null, qcClientH: qc ? qc.clientHeight : null, subs: g.querySelectorAll('app-ti.question-multiple').length, ancestors: ancestors }); }); if (window.console && console.log) console.log('[marvis] diag', out); return out; }; })(); 18:["$","$L31",null,{"script":{"script":{"id":39210,"user_id":0,"username":"","avatar":"","is_admin":0,"meta_json":{"description":["// @match *://spa.fenbi.com/*"],"grant":["none"],"match":["*://*.fenbi.com/*","*://fenbi.com/*"],"name":["Mutex草稿纸"],"namespace":["marvis.fenbi.enhance"],"run-at":["document-idle"],"version":["0.7"]},"script_id":9023,"version":"0.7","changelog":"","is_pre_release":2,"status":1,"createtime":1794317592,"code":"$32"},"id":9023,"user_id":219816,"username":"Mutex","avatar":"/api/v2/users/219816/avatar","is_admin":0,"post_id":0,"name":"Mutex草稿纸","description":"// @match *://spa.fenbi.com/*","category":null,"tags":[{"id":2923,"name":"粉笔","num":0,"sort":0,"type":3,"createtime":0,"updatetime":0},{"id":3579,"name":"手写草稿","num":0,"sort":0,"type":3,"createtime":0,"updatetime":0},{"id":3056,"name":"草稿保存","num":0,"sort":0,"type":3,"createtime":0,"updatetime":0}],"status":1,"score":20,"score_num":1,"type":1,"public":1,"unwell":2,"archive":2,"danger":0,"enable_pre_release":2,"today_install":6,"total_install":6,"summary":{"zh":"在粉笔网页提供手写草稿纸，并在本地保存画布内容。","en":"Adds a handwriting scratchpad to Fenbi and saves drawings lo"},"createtime":1794317592,"updatetime":1794317592,"content":"Mutex草稿纸"}}]