// ==UserScript==
// @name         公众号排版助手（微信后台富文本增强）
// @namespace    https://mp.weixin.qq.com/
// @version      2.6.34
// @description  在微信公众号后台编辑器注入可拖拽浮动工具栏：行内样式/高亮/徽标/标签/引用/列表/换行一次点选，产出全部走微信白名单内联样式。
// @author       小公瑾
// @match        *://mp.weixin.qq.com/*
// @noframes
// @grant        GM_addStyle
// @grant        GM_getValue
// @grant        GM_setValue
// @grant        GM_registerMenuCommand
// @run-at       document-idle
// ==/UserScript==

/*
 * ── 能力说明与设计依据（仅供查阅，油猴面板只显示上方 @description 一句话）──
 *
 * 【一、为什么全部用内联 style + section/span】
 *   微信后台对白名单外的 CSS 处置：剥离 <style>/class/id、剔除 position/transform/float/clear/
 *   z-index/animation/transition、丢弃 border-image/overflow-x、剥掉自定义 data-* 属性；且 <table>
 *   自带 border:1px solid(currentColor)，需要显式清零。语义标签（blockquote/ul/ol/li/figure…）会被
 *   宿主接管样式，后台与手机端表现不一致 —— 故本脚本产出物统一只用 section/span/a/br 四种标签
 *   + 内联 style。（结论来自本机既有工程「微众号HTML源码内联.user.js」v0.19~v0.23 的实测。）
 *
 * 【二、为什么高亮走 background-color 而不走 linear-gradient】
 *   同上工程 v0.20 实测：微信会剥掉 background 简写/渐变，元素退化为透明 ⇒ 白字变「白看」。
 *   故本脚本一律用 background-color 实色。渐变仅作为可选项（CFG.hlGradient），默认关闭。
 *
 * 【三、行内小件为什么"不写 vertical-align、垂直 margin 归零、自身行高压到正文行高之下"】
 *   实测两条硬结论：
 *   ① vertical-align:middle 的语义是"盒中点对齐父基线 + 父 x-height/2"，而 CJK 墨迹视觉中心在
 *      父基线 −0.28em 附近 ⇒ 徽标/标签会整体下沉 0.55~1.14px；
 *   ② display:inline-block 的垂直 margin 参与行盒高度计算（纯 inline 元素则完全不受影响）⇒
 *      会给所在段落凭空加 3.4~10.2px 行距，同一篇里"有的段松、有的段紧"。
 *   对策：小件一律不写 vertical-align（默认 baseline）、垂直 margin:0，且把自身 line-height 设到
 *   比正文行高更小（正文 1.6em = 25.6px，小件 1.5 × 0.86~0.95em ≈ 19.8~21.9px），从根上不撑行盒。
 *
 * 【五、图片圆角（v2.1）为什么走「内联 border-radius + 节点固化」】
 *   规则来源见 p5.js 文件头。要点：微信图文的图片本来就在内联 style 上带 width 等
 *   声明，圆角写进同一条内联 style 是最短的路径（不改文件、不损画质）；
 *   但正文编辑器是受控编辑器（ProseMirror），属性级改动会被回滚，只有「换节点」被接纳，
 *   所以写入后必须**同步**调 solidPM 固化 —— 与其它按钮走同一条时序规律。
 *
 * 【四、色值与几何来源】
 *   全部由参考图「程序化取色 + 逐行/逐列 RLE 定标」得出（非肉眼估色），实测值见 STYLES 内注释。
 */

(function () {
  'use strict';

  /*
   * 只在顶层窗口运行。
   *   微信后台的编辑器本身就住在 iframe 里，脚本再被注入进那个 iframe 一份，
   *   就会出现两个面板 + 两套 document 监听，点击被另一份先吃掉 ——
   *   表现同样是「点了没反应」。@noframes 各脚本管理器支持不一，不押在它身上，
   *   这里主动判一次，确定性地只留一份。
   */
  if (window.top !== window.self) return;

  /* ══════════════════════════════════════════════════════════════════
   * 0. 运行环境适配（脚本猫 / 油猴 / 控制台粘贴 三种方式都能跑）
   * ══════════════════════════════════════════════════════════════════ */
  var GMX = {
    style: function (css) {
      if (typeof GM_addStyle === 'function') return GM_addStyle(css);
      var s = document.createElement('style');
      s.textContent = css;
      (document.head || document.documentElement).appendChild(s);
      return s;
    },
    get: function (k, d) {
      try {
        if (typeof GM_getValue === 'function') { var v = GM_getValue(k, d); return v === undefined ? d : v; }
        var raw = localStorage.getItem('mptb_' + k);
        return raw === null ? d : JSON.parse(raw);
      } catch (e) { return d; }
    },
    set: function (k, v) {
      try {
        if (typeof GM_setValue === 'function') { GM_setValue(k, v); return; }
        localStorage.setItem('mptb_' + k, JSON.stringify(v));
      } catch (e) { /* 权限受限时只丢持久化，不影响功能 */ }
    },
    menu: function (name, fn) {
      try { if (typeof GM_registerMenuCommand === 'function') GM_registerMenuCommand(name, fn); } catch (e) {}
    }
  };

  var NS = 'mptb';
  // 版本号（诊断报告里会带上 —— 报障时一眼知道是哪一版）。
  // 必须与文件头的 @version 一致，_build.py 会做一致性校验，改一处漏一处会直接构建失败。
  var VER = '2.6.34';
  var CONFIRM_GLOBAL = true;   // 全局类破坏性操作是否二次确认
  var UNDO_MAX = 20;
  /*
   * 降级模式（默认开）：新版微信编辑器（ProseMirror）只保留它 schema 里有的样式，
   * 内边距 / 圆角 / 边框 / 字体族 这类声明它一条都不吃。
   *   开 = 按「它能承载的部分」写（例如徽标退化成「底色 + 字色 + 加粗」的扁平标签），
   *        并在提示里说明丢了什么；
   *   关 = 一条都承载不了就不写，只告知。
   * 脚本菜单里有开关。
   */
  var DEGRADE_DEFAULT = true;

  /* ══════════════════════════════════════════════════════════════════
   * 1. 样式表 —— 全部为参考图实测定标值
   * ══════════════════════════════════════════════════════════════════ */
  /*
   * 字体族名一律加单引号。
   * 「带空格的字体名不加引号」在标准 CSS 里虽然合法，但写进 style 属性、再经
   * 微信编辑器 copy 一遍之后，各家解析器（尤其 WPS / 老版内核）会出现歧义。
   * 用单引号而不是双引号：内联 style 属性本身用双引号包裹，单引号无需转义，
   * 序列化回来最干净。
   */
  var SANS = "-apple-system, BlinkMacSystemFont, 'PingFang SC', 'Microsoft YaHei', sans-serif";
  var MONO = "'Consolas', 'Menlo', 'Monaco', 'Courier New', monospace";

  /*
   * 正文基准 —— 全局默认按钮的出厂值，也就是 v2.6.11 起的「最佳阅读参数」。
   *   字号与段间距一律**绝对 px**，行距用**无单位倍数** —— 微信用 em 会随两端基准字号
   *   漂移（后台与手机端基准不同），这条是跨端富文本搬运的老坑。
   *
   * ★ v2.6.11 出厂值改造（依据《排版体检_字号行距_2026-09-21》实测，375px 真渲染）：
   *
   *   字号 16 → 17：与微信原生正文同号。安卓端微信正文原生就是 `font-size:17px`，
   *     写 16 等于「比读者已经在看的那一档更小」——白给的劣势，没有任何补偿。
   *
   *   行后 0 → 14：体检里唯一的「零呼吸」项。行高已经 1.8（17 × 1.8 = 30.6px），
   *     段间再不给 margin，段落边界就彻底消失 —— 松行距 + 零段距这两个因子叠
   *     在一起，长文反而「一片到底」，扫读时找不到段落头。14px ≈ 0.46 × 行高，
   *     落在 0.4–0.6 倍行高的建议区间中段。
   *     只写行后、不写行前：相邻两段只吃一侧间距，行为确定；两侧都写要靠
   *     margin 折叠，跨端（后台 / 手机端）折叠规则未必一致。
   */
  var BASE = { size: 16, lh: 1.8, mt: 0, mb: 13, color: '#2C2C2C', font: SANS };

  /*
   * ══ 表格配色（v2.6.13 · 粘贴增强）══════════════════════════════════════
   *
   * 【它解决什么】用户从 Excel / Markdown / 第三方编辑器复制一张表格粘进后台，
   *   旧流程会把它按 TAG_MAP 拍平成 section/p/span 的散架结构（TABLE->section、
   *   TR->p、TD->span），没有任何列对齐与边线。本版改成**重建成圆角表格**。
   *
   * 【依据：一次线上实证】抓了一篇已发布的公众号文章原始 HTML 逐属性统计：
   *   它那张"表格"里 <table> / <tr> / <td> 计数**全为 0** —— 是 section +
   *   display:flex 拼出来的。圆角靠**包裹式两件套**：
   *     ① 外层 border-radius   ② 外层 overflow:hidden
   *   缺 ① 没圆角；缺 ② 子元素的矩形背景会把四角盖回直角。这正是该文正文里
   *   `overflow: hidden` **只出现 1 次**的原因 —— 专为这个圆角容器加的。
   *
   * 【为什么敢用 flex —— 一条旧笔记的订正】先前把"清洗禁区"记成 flex，**记错了**。
   *   被微信剔除的是 float（见本文件头部第一节，原文是 position/transform/float/…）。
   *   线上该文正文实证：display:flex 存活 8 处、flex-shrink 5、gap 5、
   *   box-sizing 156、overflow:hidden 1 —— 全部活着。而且它们挂在**块级 section** 上，
   *   根本不受「行内只有 7 个属性」那条约束（那 7 个管的是 span / textstyle）。
   *
   * 【配色单一来源】用户只选一个主色，其余三色由它派生 —— 该文的实际配色也是这一族。
   *   ⚠️ 派生是**近似**的：实测该文分隔线的 G/B 通道在"主色 20% 混白"时精确吻合、
   *   R 差 8。所以预设色板**直接给成对的搭配值**（不硬算），
   *   只有用户自选主色时才退回公式派生兜底。
   */
  var TBL = {
    color: '#D5281E',
    radius: 10,
    head: 1,
    zebra: 1,
    /* 预设色板：hex = 主色；zebra / line = 与之成对的搭配值（实测配色习惯，不靠公式） */
    presets: [
      { k: 'brick', label: '砖红', hex: '#D5281E', zebra: 'rgb(251, 241, 239)', line: 'rgb(239, 216, 212)' },
      { k: 'navy',  label: '藏青', hex: '#1F3A63', zebra: 'rgb(240, 243, 248)', line: 'rgb(214, 222, 235)' },
      { k: 'green', label: '墨绿', hex: '#1E5B45', zebra: 'rgb(240, 246, 243)', line: 'rgb(214, 231, 224)' },
      { k: 'slate', label: '灰蓝', hex: '#3E5C76', zebra: 'rgb(241, 244, 247)', line: 'rgb(216, 225, 233)' },
      /* 浅灰：唯一一套「浅底深字」——主色即表头底色，headFg 指定表头字色 */
      { k: 'gray', label: '浅灰', hex: '#E5E7EB', headFg: '#374151', zebra: 'rgb(249, 250, 251)', line: 'rgb(226, 229, 234)' }
    ]
  };

  /*
   * ══ 段落字体清单（v2.6 恢复 · A+C）══════════════════════════════════════
   *
   * ⚠️【v2.4 的删除结论已被 v2.6 推翻，此处保留失败路径以免后人重走】
   *   v2.4 的判据：「font-family 不在 textstyle 的 7 属性内，行内无载体能带它，
   *                 ⇒ 行内换字体物理上不可能」。**这个判据只对「行内标记」成立。**
   *
   * v2.6 的订正依据（两个独立旁证）：
   *   ① 对照组成立 —— 工作空间 `工具集门户_2026-09-16/wechat-md` 能设置思源宋体。
   *      读它的产物：字体写在整个排版容器上（`container: `font-family:${n};…``），
   *      交付走 ClipboardItem（text/html）交给微信自己解析 ⇒ 容器 style 被放行。
   *   ② 自家旁证 —— 本脚本「衬线一/二/三级」标题的宋体一直是好的，
   *      因为它们写在块级 `<section>` 上（走 STYLES.hSerif.css），从未走过行内。
   *
   * ⇒ **同一句 font-family，写容器上就活，写行内标记上就死。**
   *   行内白名单只有 7 个属性（fontSize / letterSpacing / backgroundColor /
   *   color / fontWeight / fontStyle / textDecoration），字体、字号、行高**一条都不在**。
   *
   * 本轮实现：
   *   C = 全篇字体 —— 并进 applyGlobalPref 的白名单通道（与字号 / 行距同一个循环）；
   *   A = 选中段落 —— 只给「选区覆盖到的段落」写 font-family，不碰行内标记。
   *
   * 诚实边界（写进面板提示，不藏）：
   *   · 粒度是**整个段落**，不是"选中的那几个字" —— 微信行内剥 font-family，
   *     「只换选中的字」在这条通道上做不到；
   *   · 字体靠**阅读端本机是否装了该字体** —— 思源宋体在 Apple 设备 / 装了
   *     Source Han Serif 的机器上显示为思源，否则回退到宋体（字体栈已备回退链）。
   */
  /* v2.7：字体清单收敛到 3 项（用户 2026-09-20 指定）。
   *
   * ★ 字体栈写法铁律（_probe_quote3 实测，2026-09-20）：
   *   多词字体名**必须**用引号包住。写成 `Alibaba PuHuiTi 3.0`（裸空格）
   *   会被 CSSOM 判定为非法值 ⇒ `style.setProperty` **整条静默丢弃**
   *   （实测：读回空串 / getAttribute('style') === null）。
   *   引号哪个都行：单引号会被浏览器归一成双引号，两种都活。
   *
   * ★ 回退链必须走「跨平台 + 有衬线/无衬线同族」：
   *   普惠体是**无衬线**（黑体风），回退到 PingFang SC / 系统无衬线；
   *   思源宋体是**衬线**，回退到 Songti / SimSun / serif。
   */
  var FONTS = [
    { k: 'none', label: '跟默认(不写)', css: '', tip: '不写 font-family，交给微信默认字体' },
    { k: 'source-han', label: '思源宋体', tip: '思源宋体书卷气（衬线 · 回退：宋体）',
      css: '"Source Han Serif SC","Source Han Serif CN","Noto Serif SC","Songti SC","STSong","SimSun",serif' },
    { k: 'alibaba', label: '阿里巴巴普惠体', tip: '阿里巴巴普惠体（黑体风 · 回退：苹方/系统无衬线）',
      css: '"Alibaba PuHuiTi","Alibaba PuHuiTi 2.0","Alibaba PuHuiTi 3.0","PingFang SC","Hiragino Sans GB","Microsoft YaHei",sans-serif' }
  ];

  // 键名 → 字体栈（写样式时用；'none' 取空串 = 不写）
  function fontCssOf(k) {
    for (var i = 0; i < FONTS.length; i++) { if (FONTS[i].k === k) return FONTS[i].css; }
    return '';
  }

  var SMALL = 'margin:0 1px;';   // 行内小件公共约束：不写 vertical-align、垂直 margin 归零

  /*
   * ══ 徽标 / 标签（v2.0 重做 · 按「宽载体」写全）═════════════════════
   *
   * ⚠️ 判断修正（用户指出后订正）：我曾把「编辑器 schema 的承载范围」当成
   *    「公众号的支持范围」，于是判徽标的外框线「做不出来」——**这是错的**。
   *    真实情况是**两层**，作用点完全不同：
   *
   *    ① 编辑器 schema 层：在编辑器里改 DOM / 换节点时必须过这一关，
   *       行内只接纳 7 个属性（现场读回的 textstyle.attrs）：
   *       fontSize / letterSpacing / backgroundColor / color /
   *       fontWeight / fontStyle / textDecoration。
   *    ② 投放白名单层（脚本里的 KEEP_STYLE）：微信**最终支持**的范围，
   *       border / border-width / border-style / border-color / border-radius /
   *       padding / display / width / height / vertical-align / box-shadow … 都在里面。
   *       别的公众号能做出圆角矩形徽标，靠的就是这一层。
   *
   *    所以配方**按②的真实目标写全**（外框线、圆角、内边距一个不少），
   *    由注入层负责「怎么活着穿过①」；而不是在配方层就自我阉割。
   *
   *    ★ v2.6.22：高亮族退成「底色 + 字色」两声明后**差集为空** ⇒ 不进宽载体，
   *    走配方节点替换（落点由本脚本选区决定）。`fb` 字段保留以兼容既有配方结构。
   *
   *    面板按钮与产出物同形：高亮三件的按钮底色与字色 = 它产出的色块。
   *    （★ v2.6.22：徽标 / 标签两族整体下线 ⇒ 面板 CSS 见 p4 的 .c-hlO / .c-hlY / .c-hlW）。
   * ══════════════════════════════════════════════════════════════════ */
  /*
   * ★ v2.6.22：**徽标 / 标签两族整体下线**（承接 v2.6.21 的瘦身，本轮收尾）。
   *
   *   面板里的行内小件自此只剩「高亮三件」：朱红高亮 / 绿高亮 / 黄高亮。
   *   连带走掉的东西：
   *     · 徽标唯一残党「警告」—— 按用户要求**移到「绿高亮」之后、改名「黄高亮」**，
   *       并且效果由「徽标形状」改成「高亮」：只写底色 + 字色（见下面高亮段）。
   *       它的黄配方（底 #FEF3C7 / 字 #92400E）原样保留，只是不再套 1px 外框 + 圆角。
   *     · 载体函数 `badge()` 自此无调用者，一并删除（v2.6.21 已删 `tag()`）。
   *       ⇒ 产物里不再有任何「行内小件形状」配方，`wideDecls()` 对高亮族恒为空。
   *   面板 CSS 见 p4 的 `.c-hlO` / `.c-hlY` / `.c-hlW`（按钮底色 = 它产出的色块）。
   */
  /*
   * ★ v2.6.30：一级标题**统一字体栈**（单一来源，四款共用一份）。
   *   用户 2026-09-22：「所有的标题，标题文字都要为加粗的黑色思源宋体」。
   *   栈序 = 思源宋体（本名 / 带空格名 / Google 同名 Noto）→ 系统宋体
   *   （SimSun / Songti SC / STSong）→ 通用衬线。
   *   **为什么必须带后三级**：思源宋体不是任何手机系统的预装字体，只写它
   *   等于把选择权交给「系统默认」（多半是黑体）；带上系统宋体名，才能保证
   *   「看到的确实是宋体」。安卓的 serif 常映射到 Noto Serif CJK（正是思源
   *   宋体的 Google 版），所以各端观感一致。
   *   为什么写在**块级**：font-family 不在编辑器行内 textstyle 的 7 属性里
   *   （行内必被剥），而块级 section 的 style 能活过保存 —— 衬线款自 v2 起
   *   就是这么写的（旁证：「写容器上就活，写行内标记上就死」）。
   *   ⚠️ 动了它必须同步 p3 的 `sigCss`（识别要剥 font-family）与 `_build.py`
   *      片段守卫；`_mkverify.py` 的 T58 族按**真实计算样式**看守。
   */
  var HEAD_SERIF = "'SourceHanSerifSC','Source Han Serif SC','Noto Serif SC','SimSun','Songti SC','STSong',serif;";
  var STYLES = {
    /* ── 行内基础 ── */
    /*
     * 加粗只写 font-weight，**必须落到内联 style 上**。
     * 安卓端（微信手机端渲染）不认自定义属性，只认内联 style ——
     * 若写法里只有 textstyle 属性而 style 被宿主丢掉，桌面预览看着正常、
     * 手机端就是「一点加粗效果都没有」。配方梯子已把「补 style」提到第一级。
     */
    /*
     * 加粗 —— 字重写 bold 关键字，不写 700（v2.3 改）
     *   现场诊断的两条硬证据：
     *     · 编辑器自身体系里「粗」是 font-weight:500（h1/h2/h3 加 8 个 span），
     *       正文 p 是 400 —— 我们把 700 写进去，被它归一成了 500；
     *     · 原生 B 按钮产出的 <li style="font-weight:bold"> 却**原样存活**。
     *   ⇒ 写 bold，与微信自己的加粗按钮同一方言；700 会被归一掉，安卓端
     *     看不出区别（500 在多数安卓机型上没有对应字重，直接回退常规体）。
     */
    bd: { g: 'inline', label: '加粗', tip: '字重 bold（与微信原生加粗同方言，安卓端才认）', css: 'font-weight:bold;' },
    /*
     * 朱红加粗：一条「颜色 + 字重」的组合样式，一键把选中文字强调成品牌朱红粗体。
     * 用组合而非只改颜色：单改 color 在正文里视觉分量不够，单加粗又拉不出层次，
     * 两者一起才是参考图里那种「一眼看到」的强调位。
     */
    rb: { g: 'inline', label: '朱红加粗', tip: '朱红 #9F312A + bold 字重（一键强调）',
      css: 'color:#9F312A;font-weight:bold;' },
    /*
     * 朱红加粗下划线（★ v2.6.23 由「朱红下划线」升格为三件一体）
     *   用户 2026-09-21 指定：这个按钮要「朱红 + 加粗 + 下划线」，
     *   单下划线在正文里分量不够，与「朱红加粗」并排时明显偏弱。
     *   刻意不写 border-bottom：行内元素的 border 不被承载（v1.9 实测），
     *   改用 text-decoration —— 它在 textstyle 的属性表里，且字色与线条同色。
     *   ★ 三条声明（color / font-weight / text-decoration）**全部**在 textstyle 的
     *     7 属性表内 ⇒ 差集为空 ⇒ 走配方 span，零降级、保存后仍生效。
     *     （这也是本轮「加粗不再走 <strong>」之后才成立的前提：font-weight 若走语义
     *      标签，会被编辑器剥掉，这个按钮就只剩朱红下划线，等于没改。）
     */
    rbU: { g: 'inline', label: '朱红加粗下划线', tip: '朱红 #9F312A + 加粗 + 下划线（三件一体 · ★ v2.6.23）',
      css: 'color:#9F312A;font-weight:bold;text-decoration:underline;',
      fb: 'color:#9F312A;'
    },

    /*
     * ── 高亮（色块）──
     * ★ v2.6.12：橙高亮 → **朱红高亮**、黄高亮 → **绿高亮**（按钮 key 仍沿用 hlO / hlY，
     *   避免牵动面板存档与既有装置断言的引用面）。
     * ★ v2.6.22：**三件高亮一律用 v2.6.19 版朱红高亮的技术规则**（用户拍板）。
     *
     *   ★ v2.6.23：在这两条之外**再加一条 font-weight:bold**（用户指定）。
     *     三条都在 textstyle 的 7 属性表内 ⇒ 差集依然为空 ⇒ 规则不变（仍走配方
     *     span、不进宽载体），只是把「加粗」也搭上 —— 这是本轮修好加粗载体之后
     *     才敢做的事（旧版 font-weight 走 <strong>，跟着标签一起被剥）。
     *
     *   ★ v2.6.23：在这两条之外**再加一条 font-weight:bold**（用户指定）。
     *     三条都在 textstyle 的 7 属性表内 ⇒ 差集依然为空 ⇒ 规则不变（仍走配方
     *     span、不进宽载体），只是把「加粗」也搭上 —— 这是本轮修好加粗载体之后
     *     才敢做的事（旧版 font-weight 走 <strong>，跟着标签一起被剥）。
     *
     *   v2.6.19 的规则一句话：**只写「底色 + 字色」两条，不写任何形状声明**。
     *     理由（当时逐条验证过，本版复核仍成立）：
     *       · `background-color` / `color` 都在微信 textstyle 的 7 属性表内 ⇒ 保存链路必留；
     *       · `padding` / `border-radius` / `font-size` **都不在**那 7 条里 ⇒ 只能靠
     *         「宽载体（合成 paste / <a>）」硬送，而真机三次验证 `<a>` 载体的 style
     *         在保存链路上活不下来（见 p3 §7.9 / v2.6.5 的三次失败记录）。
     *     ⇒ v2.6.20 为了圆角改回长式 + 宽载体，代价是**保存后可能丢形状**；
     *       本轮用户明确「高亮效果都改回适用本身底色」⇒ 退回短式，形状让位给稳定性。
     *     ⇒ 差集为空 ⇒ `wideDecls(st.css)` 返回空 ⇒ 走**配方节点替换**，
     *       不进宽载体（落点由本脚本选区决定，不会再出现「点一次、开头多一份」）。
     *
     *   配色：三件同一套规矩 —— 底色是它自己的底色，字色是同色系深色。
     *     · 朱红高亮 = md-wechat mark2 底 #FBEAEA ＋ 品牌朱红 #9F312A（重点）
     *     · 绿高亮   = md-wechat mark2 原式 #D1F4E0 / #0F7A3D（增量 / 利好）
     *     · 黄高亮   = 原「警告徽标」的黄 #FEF3C7 / #92400E（提示 / 注意）
     */
    /*
     * ★ v2.6.23：三件高亮统一**加字重 bold**（用户 2026-09-21 指定，字号不变）。
     *   「加粗」本身的载体问题本轮已修（见 p2 的 semTagForCtx）—— 修好之后，
     *   font-weight 才敢跟底色 / 字色写在同一份配方里：三条都落在 textstyle 的
     *   7 属性表内（backgroundColor / color / fontWeight）⇒ 差集仍为空 ⇒
     *   仍走配方 span，不因此退回宽载体、不改变落点规则。
     *   字号一律不写：高亮的语义是「标记重点」，不是「改层级」，
     *   沿用正文的字号（用户明确「字号不变」）。
     */
    hlO: {
      g: 'inline', label: '朱红高亮',
      tip: '底 #FBEAEA / 字 #9F312A / 加粗（字号继承正文 · ★ v2.6.23：+字重 bold）',
      css: 'background-color:#FBEAEA;color:#9F312A;font-weight:bold;',
      fb: 'background-color:#FBEAEA;color:#9F312A;'
    },
    hlY: {
      g: 'inline', label: '绿高亮',
      tip: '底 #D1F4E0 / 字 #0F7A3D / 加粗（字号继承正文 · ★ v2.6.23：+字重 bold）',
      css: 'background-color:#D1F4E0;color:#0F7A3D;font-weight:bold;',
      fb: 'background-color:#D1F4E0;color:#0F7A3D;'
    },
    hlW: {
      g: 'inline', label: '黄高亮',
      tip: '底 #FEF3C7 / 字 #92400E / 加粗（字号继承正文 · ★ v2.6.23：+字重 bold）',
      css: 'background-color:#FEF3C7;color:#92400E;font-weight:bold;',
      fb: 'background-color:#FEF3C7;color:#92400E;'
    },

    /* ── 代码 / 键盘 ── */
    code: {
      g: 'inline', label: '行内代码', tip: '底 #F5F5F5 / 字 #9F312A / 等宽 / 圆角 4px（★ v2.6.20：形状已恢复）',
      css: 'display:inline-block;' + SMALL + 'padding:0 6px;border-radius:4px;background-color:#F5F5F5;color:#9F312A;'
        + 'font-family:' + MONO + ';font-size:0.92em;line-height:1.5;',
      /* 降级：承载不了 padding / 圆角 / 等宽字体 */
      fb: 'background-color:#F5F5F5;color:#9F312A;'
    },
    kbd: {
      g: 'inline', label: '键盘键', tip: '底 #F3F3F3 / 描边 #DDDDDD / 下缘加厚 2px（键帽感 · ★ v2.6.20：形状已恢复）',
      css: 'display:inline-block;' + SMALL + 'padding:0 6px;border:1px solid #DDDDDD;border-bottom-width:2px;'
        + 'border-radius:4px;background-color:#F3F3F3;color:#2C2C2C;font-family:' + MONO + ';font-size:0.9em;line-height:1.4;',
      /* 降级：键帽的描边 / 圆角承载不了，加重字重补一点分量 */
      fb: 'background-color:#F3F3F3;color:#2C2C2C;font-weight:600;'
    },

    /* ── 链接（实测：字 #456CAA + 1px #C3D6EB 底边） ── */
    a: { g: 'inline', label: '链接', tip: '字 #456CAA / 底边 #C3D6EB', css: 'color:#456CAA;text-decoration:none;border-bottom:1px solid #C3D6EB;',
      /* 降级：只保留字色（下划线由「链接」按钮自己加） */
      fb: 'color:#456CAA;'
    },

    /* ── 块级：引用（参考图实测直角、无圆角） ── */
    q1: { g: 'block', label: '引用', tip: '底 #F4F4F5 / 左 4px #1A1A1A / 直角', css: 'margin:0 0 16px;padding:14px 18px;background-color:#F4F4F5;border-left:4px solid #1A1A1A;color:#555555;border-top-right-radius:10px;border-bottom-right-radius:10px;' },
    q2: { g: 'block', label: '嵌套引用', tip: '自动退一级：左内缩 + 边框变浅', css: 'margin:10px 0 0;padding:10px 14px;background-color:#F4F4F5;border-left:4px solid #4A4A4A;color:#6B6B6B;border-top-right-radius:10px;border-bottom-right-radius:10px;' },
    q3: { g: 'block', label: '强调引用', tip: '底 #FBF3F2 / 左 4px #AC4333 / 字 #8F4E43',
      css: 'margin:0 0 16px;padding:12px 16px;background-color:#FBF3F2;border-left:4px solid #AC4333;color:#8F4E43;border-top-right-radius:10px;border-bottom-right-radius:10px;' },
    /*
     * 嵌套强调引用 —— 与「嵌套引用之于引用」同一逻辑：在强调引用里再分一层。
     * 左内缩 + 竖条更深一档 (#8F2B1E) + 底色更浅 (#F7E9E7)，靠**深浅差**而不是
     * 加粗竖条来分层：块级竖条宽度本来就能承载，但加宽会让内层抢走外层分量。
     */
    q4: { g: 'block', label: '嵌套强调引用', tip: '强调引用的嵌套版：左内缩 + 朱红更深 #8F2B1E / 底色更浅 #F7E9E7',
      css: 'margin:10px 0 0;padding:10px 14px;background-color:#F7E9E7;border-left:4px solid #8F2B1E;color:#7A3F35;border-top-right-radius:10px;border-bottom-right-radius:10px;' },

    /* ── 块级：列表（section + 悬挂缩进，不用 ul/li 语义标签，引用内同样可用） ── */
    li: { g: 'block', label: '列表', tip: '悬挂缩进圆点列表', css: 'margin:0 0 6px;padding-left:1.4em;text-indent:-1.4em;' },
    oli: { g: 'block', label: '数字列表', tip: '悬挂缩进数字列表', css: 'margin:0 0 6px;padding-left:1.6em;text-indent:-1.6em;' },

    /* ══ 块级：杂志风标题 ══════════════════════════════════════════════
     *   设计上刻意避开「渐变 / 阴影 / 伪元素 / transform」——微信一条都不放行。
     *   杂志感全靠四件事做出来：字号对比、字距(letter-spacing)、实色块面、细线分隔。
     *   字号一律写绝对 px（不用 em）：块级元素一旦被外部 CSS 改掉基准字号，
     *   em 会跟着塌，而微信后台、手机端、编辑器预览三处的基准并不一致。
     * ══════════════════════════════════════════════════════════════════ */
    /* ── 多级序号（v2.3 下线 / v2.6.25 以新形回归）────────────────────────
     *   v2.3：用户反馈「一、 / 1. / 1.1」那一行三个按钮用不上，整行移除，
     *   序号自动递增一并撤掉（headNumState / nextNumText / applyHeadNum 与
     *   CN_NUM / CN_DIGIT 已删净，不留死代码）。
     *   ★ v2.6.25：用户要求一级标题**自动从 01 编号** ⇒ 重新引入 —— 但那是
     *   一套**全新实现**（HEAD_NUM_COLOR / HEAD_NUM_SIZE / HEAD_NUM_STYLE，
     *   见下方「列表前缀标记」常量区），与 v2.3 那套「一、 / 1.1」多级序号
     *   无关：旧的 CN_NUM / CN_DIGIT 仍是删净状态，本版没有复活它们。
     *   标题改由下面四款一级承担：竖条 / 下划 / 衬线 / 双线。
     */

    /*
     * ══ 一级标题 · 四款（★ v2.6.25 重构）══════════════════════════════════
     *   用户 2026-09-21 指定：面板只留**一级标题**，二 / 三级标题整批下线。
     *   ⇒ 三系列原有的「24 / 20 / 18」三档压成**同一条一级档位（24px）**，
     *     六条二三级配方（hBar2/3、hUnder2/3、hSerif2/3）删净，不留死代码。
     *     代价（用户已明确接受）：已发布 / 存草稿的文章里，二级 / 三级标题
     *     会失去样式退回普通段落。
     *
     *   为什么一级参数定在 24 / 1.4 / 30 / 12（正文 16px 时）：
     *     · 字号 24 = 正文的 1.50 倍，落在移动端「层级清晰」健康区（1.3~1.6）中段；
     *     · 行高 1.4 —— 标题宜紧不宜松，24 × 1.4 = 33.6px 行盒，读成一个整体；
     *     · 行前 30px —— 与上文拉开（连上文段后 13px 共 43px 白）；
     *     · 行后 12px —— 比正文段后 13px **略紧**，标题与它统领的正文「抱团」；
     *       行前 : 行后 = 2.5 : 1。层级只剩两级时标题要独自承担全部结构分隔，
     *       块感必须比九档时代更强（旧体系 1.86 : 1）。
     *
     *   四款的装饰形状各自保留（这是系列的识别签名），只把**排版参数**统一：
     *     竖条（品牌红左竖条）/ 下划（底部粗实线）/ 衬线（细线 + 砖红短段）/
     *     双线（深色竖条 + 底部虚线）。
     */
    /*
     * 竖条标题：左侧 4px 品牌红竖条。
     */
    hBar: {
      g: 'head', label: '竖条一级', tip: '左侧 4px 品牌红竖条 + 24px 粗体',
      css: 'margin:30px 0 12px;padding:2px 0 2px 12px;border-left:4px solid #9F312A;'
        + 'font-family:' + HEAD_SERIF
        + 'font-size:24px;font-weight:700;line-height:1.4;color:#1A1A1A;'
    },
    /*
     * 下划标题：底部 3px 粗实线。
     *   ★ v2.6.28：线**只到标题文字宽度**（`width:fit-content`），不再是通栏 ——
     *     用户要求「适配标题文字宽度」，与双线同改（竖条 / 衬线的形状不动）。
     *     为什么不换 `display:inline-block`：换 display 会**取消外边距合并**，
     *     段前 30px 与上文段后 13px 会相加成 43px 白，纵向节奏被悄悄改坏。
     *     老文章里没有这条声明 ⇒ 识别标题时按 sigCss() 剔掉 width 再比，
     *     否则老标题会被判成「不是标题」、编号被静默吞掉。
     */
    hUnder: {
      g: 'head', label: '下划一级', tip: '底部 3px 粗实线 + 24px 粗体',
      css: 'margin:30px 0 12px;padding:0 0 8px;border-bottom:3px solid #1A1A1A;width:fit-content;'
        + 'font-family:' + HEAD_SERIF
        + 'font-size:24px;font-weight:700;line-height:1.4;color:#1A1A1A;'
    },
    /* 衬线标题 —— 定标来源：参考图 1920×1272 / DPR=2，程序化取色 + 逐行 RLE。
     *   标题墨迹 61px 高、573px 宽 / 9 字 → 单字 63.7 ≈ 字号 64（→32 CSS px）
     *   黑线 y494..495（2px → 1px），x169..1720 通栏，色 #1A1A1A
     *   砖红段 y496..501（6px → 3px），x169..288 宽 120（≈1.9 字宽），色 #B0463F
     *   文字底 y455 → 黑线顶 y494，间距 39（→20px 视觉，收敛到 16px）
     *   无额外字距：573 / 9 = 63.7 ≈ 字号本身，故不写 letter-spacing。
     *
     * 字号为什么是 24（v2.6.25：原 26 → 24，并入一级统档）：
     *   参考图是桌面示例页（正文容器 815 CSS px），微信正文只有 375~414 px 宽；
     *   按容器等比缩会小到读不清，按绝对可读性缩又该取 32 —— 折中取 24，
     *   与其余三款同一个字号，一行约 14 字，长标题不过两行。
     *
     * 结构为什么是两块：微信剥 position / ::before / 伪元素，「细线下方压红段」
     * 用 CSS 摆不出来，只能用真实节点 —— 文字块自带 border-bottom（通栏细线），
     * 紧随其后一个零行高的 section 装 48×3 的砖红实色块。
     */
    hSerif: {
      g: 'head', label: '衬线一级',
      tip: '24px 宋体衬线大字 + 底部 1px 通栏细线，线下方左端压 3px 砖红短段',
      mark: 'serif',
      css: 'margin:30px 0 0;padding:0 0 15px;border-bottom:1px solid #1A1A1A;'
        + 'font-family:' + HEAD_SERIF
        + 'font-size:24px;font-weight:700;line-height:1.4;color:#1A1A1A;',
      /*
       * ★ v2.6.31：砖红短段从**内层 span** 挪到**装饰块自身**（保存后红线不再消失）。
       *   现场取证（用户 2026-09-22）：装饰块自己完好 ——
       *     `section[margin:0 0 12px;height:3px;font-size:0;line-height:0;]`（四条声明全在），
       *   而它内层那个 span 的 display / width / height / background-color **全被剥**。
       *   根因与载体实验（_verify/carrier.html）同族：**行内元素只扛文字属性，盒子属性必丢**。
       *   而这块砖红本来就是一个**有尺寸的实色矩形**，天生该由**块级 section 自己**承担
       *   —— 块级 style 现场已被证明完整存活。
       *   `decoMark` 一个字没删：老文章里的旧装饰块（section + 内层 span）还要靠它认出来，
       *   否则换款式 / 取消标题会在文里留下**一条孤儿红线**。
       */
      deco: 'margin:0 0 12px;width:48px;height:3px;background-color:#B0463F;font-size:0;line-height:0;',
      decoMark: 'display:inline-block;width:48px;height:3px;font-size:0;background-color:#B0463F;'
    },
    /*
     * 双线标题（★ v2.6.25 新增）—— 复刻自用户指定的参考文章
     *   https://mp.weixin.qq.com/s/7ox6ioOtGI2TNyFs4UpL4Q 的次级标题样式。
     *
     *   从文章 HTML **程序化读出**的原样式（不是凭肉眼估色）：
     *     border-left:4px solid #333333;  border-bottom:1px dashed #333333;
     *     font-size:19.2px;  font-weight:bold;  line-height:1.2;  color:#3f3f3f;
     *     margin:2em 8px 0.75em 0;
     *   照抄的是**结构**：两条同色线 —— 左竖线 + 底部虚线，这是它的识别点。
     *   颜色收进本项目标题色系（#1A1A1A），两条线同色；
     *   字号 / 行高 / 间距一律并入上面那套 24 / 1.4 / 30 / 12。
     */
    hTwo: {
      g: 'head', label: '双线一级',
      tip: '左侧 4px 深色竖条 + 底部 1px 虚线下划线 + 24px 粗体',
      css: 'margin:30px 0 12px;padding:4px 0 8px 12px;'
        + 'border-left:4px solid #1A1A1A;border-bottom:1px dashed #1A1A1A;width:fit-content;'
        + 'font-family:' + HEAD_SERIF
        + 'font-size:24px;font-weight:700;line-height:1.4;color:#1A1A1A;'
    }

    /* 空行 / 软换行 / 硬换行由操作层直接生成 DOM，不在此登记样式 */
  };

  // 标题键名速查（「套用全局默认排版」「清除格式」「全篇重编号」都要遍历它）
  // ★ v2.6.25：只剩一级四款 —— 顺序即面板按钮顺序：竖条 → 下划 → 衬线 → 双线。
  var HEAD_KEYS = ['hBar', 'hUnder', 'hSerif', 'hTwo'];

  /*
   * 衬线系列的键。装饰块（那条压在细线下的砖红短段）识别时**必须遍历这一组**：
   * 只认 STYLES.hSerif.decoMark 的话，形状一变就找不到自己的装饰块，
   * 会在文档里留下一条孤儿红线。
   * ★ v2.6.25：二 / 三级下线后只剩一款，数组仍保留 —— 它守的是「按族识别」
   *   这条纪律，不是「必须有三个键」这件事。
   */
  var SERIF_KEYS = ['hSerif'];

  /*
   * ══ 编辑器 schema 层能承载的行内属性（现场读回的 textstyle.attrs）══════
   *   只有这 7 个。凡是落在这 7 个之外的声明（border / border-radius / padding /
   *   display / width / vertical-align …），**在编辑器里改 DOM 是留不住的**。
   *   但它们**并不等于微信公众号不支持** —— 投放白名单（KEEP_STYLE）里都有。
   *   这两层的差集，就是「桌面预览正常、手机端丢样式」的真相所在。
   *   脚本据此判断（v2.2 已改口径）：配方里若含差集声明，**优先换一个能整条承载
   *   style 的载体**（行内是 <a href>，见 carryLinkOn）；换不到才退回「按子集写」
   *   的降级式。宽载体通道（合成 paste）现在只作为最后一道备用。
   */
  var SCHEMA_ATTR_CSS = ['font-size', 'letter-spacing', 'background-color', 'color',
                         'font-weight', 'font-style', 'text-decoration'];

  // 列表前缀标记（• / 1.）的识别特征：品牌红色 + 半粗以上 + 纯样式 span
  var MARK_COLOR = '#9F312A';
  var MARK_WEIGHT = 600;

  /*
   * ★ v2.6.25：一级标题的自动编号（01 / 02 / …）
   *   为什么颜色用中灰 #8A8A8A 而不是品牌红：
   *     列表前缀（• / 1.）的识别签名是 isPrefixSpan 里的
   *     「color === #9F312A 且 font-weight ≥ 600」。编号若也用品牌红 + 粗体，
   *     两种「段落里的第一个 span」就会互相被当成对方删掉 —— 编号删了列表标记，
   *     或取消标题时把列表标记当编号留着。中灰天然隔开，两套判据各认各的。
   *   为什么字重是 700 而列表用 600：颜色已经够区分，这是用户指定的视觉要求
   *     —— 编号要与标题同级分量，偏细会被 24px 粗体的标题压没。
   *   三条声明（font-size / font-weight / color）全部落在 textstyle 的 7 属性表内
   *     ⇒ 保存链路必留，与列表前缀走的是同一条存活路径。
   */
  var HEAD_NUM_COLOR = '#8A8A8A';
  // 字号 = 一级标题字号 × 0.85 —— 从配方反算，改标题字号时不必回来改这里
  var HEAD_NUM_SIZE = (function () {
    var f = parseFloat(declsOf(STYLES.hBar.css)['font-size']);
    return isNaN(f) ? 20 : Math.round(f * 0.85);
  })();
  /*
   * ★ v2.6.31：编号**不吃标题的宋体**。
   *   用户现场（2026-09-22）：「标题序号里的 01、02…… 都改为使用默认字体，不用思源宋体」。
   *   为什么非要在这里写一条：编号的字体只能靠**继承**，而它祖先链上最近一个带
   *   font-family 的就是标题块 section（四款一级统一挂 HEAD_SERIF）⇒ 不自己带一条
   *   就一定是宋体。
   *   为什么这条能活（而装饰块那个内层 span 的盒子属性活不了）：编辑器剥的是**盒子属性**
   *   —— 现场取证 `section[...width:fit-content;font-family:源宋体栈...]` 完好，
   *   而 `span[display/width/height/background-color]` 全丢；编号自己的
   *   color / font-weight / font-size 也全留。`font-family` 属**文字属性**，走的正是
   *   编辑器自己那条路：它给每个正文文字 span 都补了
   *   `font-family:"mp-quote",…`（现场样本 span[...font-family:mp-quote…] ×61）。
   *   最坏情况：万一这条也被剥 ⇒ 编号退回宋体（观感问题，不丢内容、不掉行）。
   */
  var HEAD_NUM_FONT = "-apple-system,BlinkMacSystemFont,'PingFang SC',"
    + "'Hiragino Sans GB','Microsoft YaHei',sans-serif;";
  var HEAD_NUM_STYLE = 'color:' + HEAD_NUM_COLOR + ';font-weight:700;font-size:'
    + HEAD_NUM_SIZE + 'px;font-family:' + HEAD_NUM_FONT;
  var HEAD_NUM_GAP = '\u00a0\u00a0';   // 编号与标题文字之间：两个不换行空格 ≈ 10px

  /*
   * ══ 行内小件的载体开关（v2.2）══════════════════════════════════════════
   * 为什么需要它 —— 载体实验实测（_verify/carrier.html，9 条用例全绿）：
   *   · span[textstyle] 只能承载 7 个属性（fontSize / letterSpacing /
   *     backgroundColor / color / fontWeight / fontStyle / textDecoration）；
   *     徽标骨架的 8 条声明只活 4 条 —— display / padding / border /
   *     border-radius **全丢**。这就是「徽标点了没反应、看着不像徽标」的根。
   *   · <a href> 带的是**完整 style**：8 条全活
   *     （href 为空串或 '#' 都行；**没有 href 会被整体丢弃**）。
   * 所以小件改由 <a> 承载。代价：节点语义从「纯装饰 span」变成「无跳转链接」，
   * 且**手机端的最终表现只能真机验收** —— 万一微信在投放环节对 <a> 另有处置，
   * 关掉这个开关即可整体退回 span 扁平版（底色 + 字色 + 字重 + 字距）。
   */
  var CARRY_LINK_DEFAULT = true;
  function carryLinkOn() {
    try { return GMX.get('carryLink', CARRY_LINK_DEFAULT) !== false; }
    catch (e) { return CARRY_LINK_DEFAULT; }
  }

  /*
   * ══ 宽载体（合成 paste）开关 · v2.5.1 ═════════════════════════════════
   * 默认**关**。理由不是「它不好用」，而是它**落点不由我们决定**：
   *   合成 paste 插到哪里，取决于宿主编辑器自己的 selection。而 ProseMirror 的
   *   onSelectionChange 头一句就是
   *       if (!hasFocusAndSelection(view)) return;
   *   它的 hasFocus() 要求 document.activeElement 在编辑器内 —— 用户刚点过面板按钮，
   *   焦点正落在面板上 ⇒ 它整段跳过同步 ⇒ 粘贴落到它**上一次记得的位置**（常见是文首）。
   *   现场表现正是：样式能设置，但正文开头总多出一份「设置的内容和样式」；
   *   点「预览」后正文里的又全没了（预览读的是宿主的 doc，而只有那份错位的内容进了 doc）。
   * 关掉之后，行内小件一律走「直连载体（<a href> + 整条 style）」或配方节点替换 ——
   * 落点完全由本脚本的选区决定，写哪儿是哪儿。
   * 需要它时（例如将来直连载体被平台封掉）在脚本菜单里打开；打开后
   * widePasteRuns 还会做两步保险：先交还焦点 + 补一次 selectionchange，
   * 再对落点做自检（正文变长即判错位、如实告知，不谎报已送达）。
   */
  /*
   * ★ v2.6.5：宽载体默认**开启**（v2.5.1 曾默认关闭）。
   *   关闭它的理由当时是「落点由宿主决定、出现过插到文首」——落点防护（焦点回交 +
   *   selectionchange 对齐 + 正文长度自检 + 失败提示撤销）此后已补齐。
   *   重开它的理由是真机证据：保存链路上 <a> 载体的 style 活不下来三次
   *   （href=";" 被清洗归并 → 本域链接被校验拦 → 外域链接保存后外框仍消失），
   *   而宽载体产出的「span / strong + 整条 style」有真机样本背书（外部排版工具
   *   走同一条宿主导入链，保存后存活）。失败会原样退回直连路径，不静默失败。
   */
  var WIDE_CARRIER_DEFAULT = true;
  function wideCarrierOn() {
    try { return GMX.get('wideCarrier', WIDE_CARRIER_DEFAULT) === true; }
    catch (e) { return WIDE_CARRIER_DEFAULT; }
  }
  /* ══════════════════════════════════════════════════════════════════
   * 2. 通用 DOM / 样式小工具
   *    —— 本节的 valEq / elHasCss 是「二次点击取消」的核心：
   *       不做任何 data-* 标记（微信会剥），而是直接比对内联 style 声明本身，
   *       因此手动加的样式、脚本加的样式，识别逻辑完全一致。
   * ══════════════════════════════════════════════════════════════════ */

  function norm(css) {
    if (!css) return '';
    return String(css)
      .replace(/\s*:\s*/g, ':')
      .replace(/\s*;\s*/g, ';')
      .replace(/;+$/, '')
      .replace(/\s+/g, ' ')
      .trim();
  }

  function declsOf(css) {
    var out = {}, s = norm(css);
    if (!s) return out;
    s.split(';').forEach(function (d) {
      if (!d) return;
      var i = d.indexOf(':');
      if (i < 0) return;
      out[d.slice(0, i).trim().toLowerCase()] = d.slice(i + 1).trim();
    });
    return out;
  }

  function hexToRgbStr(hex) {
    var h = 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 hex;
    return 'rgb(' + ((n >> 16) & 255) + ', ' + ((n >> 8) & 255) + ', ' + (n & 255) + ')';
  }

  /*
   * 值等价比较：把 #RRGGBB 归一成 rgb()、剥掉引号差异、去空格差异、归一零值单位。
   *
   * 【为什么必须剥引号】字体族名的引号是「写进去一个样、读回来另一个样」：
   *   写： font-family:'SimSun','Songti SC','STSong',serif
   *   读： SimSun, "Songti SC", STSong, serif   ← 单引号变双引号，
   *                                              连不带空格的 SimSun 都被加了引号规则
   * 不归一这一层，elHasCss 就永远认不出「自己刚写进去的样式」——后果是
   * ① 再点一次取消不掉（toggle 判定失败）② 块级标题被全局默认当成普通段落压平。
   * 值里会出现引号的地方只有 font-family，全局剥掉是安全的。
   */
  /*
   * 「能承载样式」的属性名 —— 不止字面的 style。
   * 微信新版编辑器的 textstyle 标记把样式拆成了具体属性名
   * （fontSize / color / fontWeight / backgroundColor …），
   * 它同样能承载样式；v1.8 只认字面 style，于是把 textstyle 判成「不能上色」，
   * 在报告里给出「19 个按钮全不支持」的错误结论。
   */
  var STYLE_ATTR_NAMES = [
    'style', 'fontSize', 'fontFamily', 'fontWeight', 'fontStyle', 'color', 'backgroundColor',
    'textDecoration', 'textAlign', 'textIndent', 'letterSpacing', 'lineHeight', 'verticalAlign'
  ];
  function styleAttrsOf(keys) {
    var out = [];
    for (var i = 0; i < keys.length; i++) { if (STYLE_ATTR_NAMES.indexOf(keys[i]) >= 0) out.push(keys[i]); }
    return out;
  }

  function valEq(a, b) {
    function f(v) {
      v = String(v == null ? '' : v).trim().toLowerCase();
      v = v.replace(/#([0-9a-f]{6}|[0-9a-f]{3})\b/g, function (m) { return hexToRgbStr(m); });
      v = v.replace(/["']/g, '');
      v = v.replace(/\s*,\s*/g, ',').replace(/\s+/g, ' ');
      v = v.replace(/(^|\s)0(px|em|rem|%|pt)\b/g, '$10');
      /*
       * 字重归一（v2.3）：bold / bolder 与 700 视为同一个值。
       *   加粗的写法从 700 换成了 bold（微信编辑器会把 700 归一成 500，
       *   却原样保留 bold），但**旧内容里写的是 700** —— 不归一的话，
       *   「取消加粗」会因为读到 700、期待 bold 而判不成立，变成再包一层。
       *   归一之后新旧两种写法互相都认。
       */
      v = v.replace(/^bolder$/, 'bold').replace(/^bold$/, '700');
      return v;
    }
    return f(a) === f(b);
  }

  // 元素内联样式是否已完整覆盖 css 的每一条声明
  function elHasCss(el, css) {
    if (!el || !el.style) return false;
    var want = declsOf(css), any = false;
    for (var p in want) {
      any = true;
      if (!valEq(el.style.getPropertyValue(p), want[p])) return false;
    }
    return any;
  }

  function mergeStyle(el, css) {
    var d = declsOf(css);
    for (var p in d) { try { el.style.setProperty(p, d[p]); } catch (e) {} }
    return el;
  }

  function stripStyle(el, css) {
    var d = declsOf(css);
    for (var p in d) { try { el.style.removeProperty(p); } catch (e) {} }
    return el;
  }

  function unwrap(el) {
    if (!el || !el.parentNode) return;
    var p = el.parentNode;
    while (el.firstChild) p.insertBefore(el.firstChild, el);
    p.removeChild(el);
    try { p.normalize(); } catch (e) {}
    return p;
  }

  /*
   * 「纯样式 span」＝只挂我们自己那套属性、没有 class/id 的 <span>。
   *
   * v1.8 起从「只有 style」放宽为「style / textstyle」：
   * 微信 ProseMirror 的 textstyle 标记要求选择器 span[textstyle] 命中，
   * 产出物必须多带这一个属性，否则写法不在方言里。
   * 放宽是安全的 —— 只要出现 class / id / href 之类的外来属性仍判假，
   * 用户原有的带 class 的 span 不会被我们误当产出物合并或拆掉。
   */
  /*
   * ══ 语义载体白名单（v2.5）════════════════════════════════════════════
   * <strong>/<b>/<em>/<i>/<u>/<s>/<del>/<ins> 这一类「不带属性也能表达含义」的标签。
   * 它们出现在本脚本的产出里，是「加粗」这条链路的载体（见 semWrapFor 注释）。
   *
   * 判「是不是产出物」只认**属性只有 style 的**：
   *   · 我们写的 <strong style="font-weight:bold">                     ✅
   *   · 微信自己产的 <strong style="font-weight: 700;color: rgb(26,26,26);"> ✅
   *     （它确实就是「加粗」，加粗按钮点第二次理应能撤掉它）
   *   · 裸 <strong>（用户自己敲的语义标签）、带 class/id/data-* 的（别处粘来的富文本）❌
   */
  var SEM_CARRIER = { STRONG: 1, B: 1, EM: 1, I: 1, U: 1, S: 1, DEL: 1, INS: 1 };
  function isSemanticCarrier(el) {
    return !!(el && el.nodeType === 1 && SEM_CARRIER[el.tagName]);
  }

  function isPureStyleSpan(el) {
    if (!el || el.nodeType !== 1) return false;
    /*
     * v2.2：行内小件（徽标 / 标签 / 行内代码 / 键盘键）现在由 <a> 承载 ——
     * 只有 <a> 能在行内保住 border / padding / border-radius。
     * 但 <a> 同时也是「链接」的载体，两者必须分得开：
     *   小件 = href 为空串或 '#'，且除 style / href 外没有别的属性；
     *   链接 = 带真实 href（http(s)://…），或带 textvalue / class 等链接专用属性。
     * 分不开的后果是具体的：点「取消链接」会把徽标拆掉，
     * 清除格式时的处置也会串味。判据与 removeLink 共用这一份，避免口径漂移。
     */
    if (el.tagName === 'A') {
      var href = String(el.getAttribute('href') || '');
      /* ★ v2.6.3：小件的 href 已从 '#' 换成真链接形状 safeHref() ⇒
       *   「非 '#'」不能再当「链接」的判据（否则取消/幂等链路认不出自己的载体）。
       *   新判据：以 safeHref() 开头 ⇒ 我们的小件；其余非空 ⇒ 真链接。
       *   ★ 为什么引用 safeHref() 函数而不是常量：抽函数注入的装置世界只带
       *   function 不带 var ⇒ 直接引用 var 会 ReferenceError ⇒ 配方静默变 null
       *   （环境残缺装成业务失败，v2.6.3 首轮回归 50 条 FAIL 的教训）。 */
      if (href && href !== '#' && String(href).indexOf(safeHref()) !== 0) return false;
      var asA = el.attributes;
      for (var iA = 0; iA < asA.length; iA++) {
        var nmA = asA[iA].name;
        if (nmA !== 'style' && nmA !== 'href') return false;
      }
      return true;
    }
    /*
     * v2.5：语义载体（<strong> 一类）也是「我们产出的行内样式节点」——
     * 加粗现在由 <strong> 承载（线上公众号文章的加粗就是这个形态，见 semWrapFor）。
     * 不认它，下游三处会一起坏：
     *   · hostOf 找不到宿主 ⇒「再点一次取消」永远不成立；
     *   · 复用宿主判定失败 ⇒ 在同一段字上叠第二种样式时会套娃；
     *   · 清除格式不会拆掉它 ⇒ 清完还剩一层加粗。
     */
    if (isSemanticCarrier(el)) {
      var asS = el.attributes;
      if (!asS.length) return false;          // 裸语义标签不是我们的产出物
      for (var iS = 0; iS < asS.length; iS++) {
        if (asS[iS].name !== 'style') return false;
      }
      return true;
    }
    if (el.tagName !== 'SPAN') return false;
    var as = el.attributes;
    for (var i = 0; i < as.length; i++) {
      var nm = as[i].name;
      if (nm !== 'style' && nm !== 'textstyle') return false;
    }
    return true;
  }

  /* ══════════════════════════════════════════════════════════════════
   * 3. 编辑器上下文（UEditor iframe / 主文档 contenteditable 双路兼容）
   * ══════════════════════════════════════════════════════════════════ */

  /*
   * 【v1.4 关键修复】「选区优先」还不够 —— 必须比可信度，并且要能淘汰假候选
   *
   *   v1.1 把定位改成「从选区反推容器」，方向是对的，但漏了两个前提：
   *     ① 选区必须落在**真正可编辑**的容器里；
   *     ② 必须在**所有候选之间比可信度**，而不是「第一个返回非 null 的就用它」。
   *
   *   旧实现踩的正是这个坑（本机已用 iframe 复现页钉死，见 _mkverify2.py）：
   *     微信后台新建图文时**标题输入框是自动聚焦的** —— 主文档里始终有一个塌陷光标。
   *     旧 ctxFromMainDoc() 一看主文档有选区就立刻抢答，而 editableRootOf() 在找不到
   *     可编辑祖先时兜底返回 document.body，于是「主文档 body」成了永远有效的假编辑器：
   *       · pickEditor() 永远返回它 —— iframe 里的真编辑器永远轮不到；
   *       · collectRuns() 拿它当 TreeWalker 根，跨文档遍历不到 iframe 里的文字，
   *         runs 为空 → 所有行内样式一律提示「请先选中文字」；
   *       · firstBlock() 从 iframe 节点往上爬，永远爬不到主文档 body，
   *         所有块级操作一律提示「没找到可用的段落」；
   *       · 「一键全局默认」把字号写进了**标题框**，正文纹丝不动。
   *     合起来就是：左侧面板所有按钮点了都没效果。
   *
   *   本版改成「候选池 + 打分 + 淘汰」：
   *     ① 候选必须真的可编辑（isContentEditable）—— 冒充的 body 直接淘汰；
   *     ② 有非折叠选区 +100，只有光标 +30；
   *     ③ iframe 的 id/class 带 ueditor / edui / editor +200（公众号正文最确定的特征）；
   *     ④ 块级子元素 ≥3 个 +40；可视面积按「占视口比例」加分（正文一定比标题框大）。
   *   于是「正文在 iframe 的 UEditor」与「正文在主文档的新版编辑器」两种形态都能选对，
   *   标题框 / 作者框 / 摘要框再也抢不走。
   */

  var ECTX = null;
  var LAST_SCAN = [];          // 最近一次候选扫描结果（有效候选），供诊断入口回显
  var LAST_ALL = [];           // 连被淘汰的一起留档 —— 「为什么没选它」必须能回答
  var EDITABLE_SEL = '[contenteditable="true"],[contenteditable=""],[contenteditable="plaintext-only"]';

  // 工具栏/对话框自己的节点：选区若落在里面，一律不认
  function isOurNode(el) {
    return !!(el && el.closest
      && (el.closest('#mptb-bar') || el.closest('#mptb-dlg') || el.closest('#mptb-toast')));
  }

  function nodeOf(n) { return n && (n.nodeType === 1 ? n : n.parentNode); }

  function aliveCtx(c) {
    if (!c) return false;
    if (c.frame) return !!(c.frame.isConnected && c.doc && c.doc.body);
    return !!(c.root && c.root.isConnected);
  }

  // 一句人话描述某个上下文 —— 诊断与日志都用它，避免再出现「到底认了哪个」的扯皮
  function ctxDesc(c) {
    if (!c) return '未找到';
    var r = c.root || {};
    var tag = '<' + String(r.tagName || '?').toLowerCase() + '>';
    var id = r.id ? ('#' + r.id) : '';
    return (c.frame ? ('iframe#' + (c.frame.id || '(无id)') + ' 内') : '主文档') + ' ' + tag + id;
  }

  /*
   * 收集所有「读得到的同域文档」：主文档 + 每个 iframe，再往下探一层
   * （有些后台会把编辑器再套一层 iframe）。跨域 iframe 直接跳过。
   */
  function collectDocs() {
    var docs = [{ doc: document, win: window, frame: null }];
    var frames;
    try { frames = document.querySelectorAll('iframe'); } catch (e) { frames = []; }
    for (var i = 0; i < frames.length; i++) {
      var f = frames[i], d = null, w = null;
      try { d = f.contentDocument; w = f.contentWindow; } catch (e) { continue; }
      if (!d || !d.body) continue;
      docs.push({ doc: d, win: w, frame: f });
      var subs = null;
      try { subs = d.querySelectorAll('iframe'); } catch (e) { subs = null; }
      if (!subs) continue;
      for (var j = 0; j < subs.length; j++) {
        var g = subs[j], gd = null;
        try { gd = g.contentDocument; } catch (e) { continue; }
        if (gd && gd.body) docs.push({ doc: gd, win: g.contentWindow, frame: g });
      }
    }
    return docs;
  }

  function vpArea(doc) {
    var de = doc.documentElement || {};
    return Math.max((de.clientWidth || 0) * (de.clientHeight || 0), 1);
  }

  function boxArea(el) {
    try {
      var r = el.getBoundingClientRect();
      return Math.max(r.width, 0) * Math.max(r.height, 0);
    } catch (e) { return 0; }
  }

  /*
   * 候选打分。<0 = 直接淘汰，不参与竞争。
   * 「淘汰」这一环是本次修复的核心 —— 上一版没有淘汰，任何能返回非 null 的节点
   * 都能抢答，document.body 就是这么混进来并把真编辑器挡在门外的。
   *
   * 2026-09-19 补：**单行框不给「有光标」加分**（见下方 field）。
   *   光标的 +30 本是最高权重项，但页面刚载入时光标常在标题框里 ⇒ 标题框以
   *   33:31 反超正文，ECTX 被定错、自动链路全哑（装置实测，详见那条注释）。
   */
  function scoreCandidate(c) {
    var r = c.root;
    if (!r || r.nodeType !== 1) { c.why = '不是元素节点'; return -1; }
    if (isOurNode(r)) { c.why = '是本脚本自己的面板'; return -1; }
    if (!r.isContentEditable) { c.why = '不可编辑（非 contenteditable）'; return -1; }  // 假候选在这里出局
    try {
      var st = c.win.getComputedStyle(r);
      if (st.display === 'none' || st.visibility === 'hidden') { c.why = '不可见'; return -1; }
    } catch (e) {}

    var s = 0, notes = [];
    /*
     * 块级子元素要先数出来 —— 「有光标该不该加分」要用它。
     *   正文一定带块级段落（ProseMirror 的空文档也带一个空段落；UEditor 正文是
     *   <p> 序列），而标题 / 作者 / 摘要这类**单行框**一个块级子元素都没有。
     */
    var blocks = 0, kids = r.children || [];
    for (var i = 0; i < kids.length; i++) { if (BLOCK_TAGS[kids[i].tagName]) blocks++; }

    /*
     * ★ 单行框（标题 / 作者 / 摘要）：无块级子元素，且高度不到视口的 12%。
     *   为什么必须单独认出来（v2.1 装置实测，自动链路全哑的真凶）：
     *   「有光标 +30」表达的是「用户正在这里工作」，可页面刚载入时光标往往落在
     *   **标题框**里。实测分数：标题框 30+0+3 = 33，正文 0+5+26 = 31 ——
     *   标题框仅凭这 30 分反超，于是 pickEditor 把编辑器认成了标题框，
     *   之后所有「不重扫候选」的后台路径（如图片上传后自动加圆角）都对着
     *   标题框干活：找不到图 → 静默返回 → 不报错、不提示、流水里空空如也。
     *   正文不会命中这条（它一定有块级子元素），所以不会误伤。
     */
    var field = blocks === 0 && boxArea(r) < vpArea(c.doc) * 0.12;

    var lr = liveRange(c);
    if (lr && !lr.collapsed) { s += 100; notes.push('有选中+100'); }
    else if (lr && !field) { s += 30; notes.push('有光标+30'); }
    else if (lr) { notes.push('有光标但在单行框里+0'); }
    else { notes.push('无选区+0'); }

    if (c.frame) {
      var fid = String(c.frame.id || '') + ' ' + String(c.frame.className || '');
      if (/ueditor|edui|editor/i.test(fid)) { s += 200; notes.push('iframe名像编辑器+200'); }
      else { s += 5; notes.push('在iframe内+5'); }
    } else {
      notes.push('在主文档+0');
    }

    if (blocks >= 3) { s += 40; notes.push('块级子元素' + blocks + '个+40'); }
    else if (blocks >= 1) { s += 5; notes.push('块级子元素' + blocks + '个+5'); }
    else { notes.push('无块级子元素+0'); }

    var ra = boxArea(r);
    var geo = '';
    if (ra > 0) {
      var add = Math.min(60, Math.round(ra / vpArea(c.doc) * 60));
      s += add;
      geo = '占视口' + Math.round(ra / vpArea(c.doc) * 100) + '%+ ' + add;
    } else { geo = '零尺寸+0'; }
    notes.push(geo);

    c.why = notes.join(' / ');
    return s;
  }

  /*
   * 定位编辑器：扫全部候选 → 打分 → 取最高分。
   * 只有「一个候选都没有」时才退回上一次认定的上下文 / 按 id-class 兜底。
   * 每次重扫的成本只有几次 querySelectorAll + getBoundingClientRect，可以忽略。
   */
  function pickEditor() {
    var docs = collectDocs(), all = [], every = [], best = null;
    for (var i = 0; i < docs.length; i++) {
      var d = docs[i], roots = [], list = null;
      try { list = d.doc.querySelectorAll(EDITABLE_SEL); } catch (e) { list = null; }
      if (list) { for (var j = 0; j < list.length; j++) roots.push(list[j]); }
      var b = d.doc.body;
      if (b && b.isContentEditable && roots.indexOf(b) < 0) roots.push(b);

      for (var k = 0; k < roots.length; k++) {
        var c = { doc: d.doc, win: d.win, root: roots[k], frame: d.frame };
        c.score = scoreCandidate(c);
        c.why = c.why || '';
        every.push(c);                                 // 淘汰的也留档，诊断里要显示「为什么不是它」
        if (c.score < 0) continue;
        all.push(c);
        /*
         * 同分时取**面积更大**的那个。
         *   「正文比标题框大」是物理事实，可正文刚载入、还没内容时两者会咬得很紧，
         *   只认「先出现的」会把正文挡在门外（v2.1 装置实测：33 : 31 输给标题框）。
         */
        if (!best || c.score > best.score
          || (c.score === best.score && boxArea(c.root) > boxArea(best.root))) best = c;
      }
    }
    LAST_SCAN = all;
    LAST_ALL = every;
    if (best) { ECTX = best; return best; }
    if (ECTX && aliveCtx(ECTX)) return ECTX;
    ECTX = ctxBySelector();
    return ECTX;
  }

  // 兜底老路：按 id/class 猜（只在「一个可编辑候选都没有」时才会走到）
  function ctxBySelector() {
    var ifr = document.querySelector('iframe#ueditor_0')
      || document.querySelector('iframe[id^="ueditor_"]')
      || document.querySelector('.edui-body-container iframe')
      || document.querySelector('iframe.ueditor_0');
    if (ifr) {
      try {
        var d = ifr.contentDocument;
        if (d && d.body) {
          var ce = d.querySelector(EDITABLE_SEL);
          return { doc: d, win: ifr.contentWindow, root: ce || d.body, frame: ifr };
        }
      } catch (e) { /* 未就绪 / 跨域 */ }
    }
    var list = document.querySelectorAll(EDITABLE_SEL);
    for (var i = 0; i < list.length; i++) {
      if (isOurNode(list[i])) continue;
      return { doc: document, win: window, root: list[i], frame: null };
    }
    var fb = document.querySelector('#js_editor') || document.querySelector('.edui-body-container');
    if (fb) return { doc: document, win: window, root: fb, frame: null };
    return null;
  }

  /* ══════════════════════════════════════════════════════════════════
   * 3d. 现场事实采集（envReport）
   *
   *   「点了没反应」这类反馈，最贵的成本是**来回猜**。这一节的全部目的
   *   就是把「现场到底长什么样」一次取全 —— 窗口层级、每个 iframe 能不能读、
   *   里面有几个可编辑节点、UEditor 实例长在哪 —— 全部只读采集、不改 DOM、
   *   不抛异常，让用户复制一次报告就能定位到具体哪一环断了。
   * ══════════════════════════════════════════════════════════════════ */

  /* ══════════════════════════════════════════════════════════════════
   * 3d2. 受控编辑器（ProseMirror）适配  ★ v1.6 新增
   *
   *   微信后台的正文编辑器已从 UEditor（iframe）迁到 ProseMirror。PM 是
   *   **受控编辑器**：自己维护一份 doc，并盯着 DOM。实测结论（真 PM 库）：
   *     · 外部改「属性」（style/class）→ 它判为非法，整块重渲染回去；
   *     · 换成「节点」（一个新插入的节点）→ 它交给自己的 parser 重新解析并接纳；
   *     · 派发 paste 事件 → 走宿主自己的 HTML 导入链路，样式完整保留。
   *   所以本节只干一件事：**把属性级改动翻译成节点级替换**。
   *
   *   另一个致命细节是**时序**：PM 用 MutationObserver 盯着 DOM，回调跑在
   *   微任务里 —— 任何 setTimeout 都排在它后面。所以固化必须与改动处于
   *   **同一个同步任务**（见 p4 的 runAct），晚一拍就等于对着回滚后的 DOM 干活。
   * ══════════════════════════════════════════════════════════════════ */

  // 这个编辑器是不是「由 ProseMirror 托管」
  function pmHostOf(ctx) {
    var r = ctx && ctx.root;
    if (!r || r.nodeType !== 1) return null;
    try {
      if (r.pmViewDesc && String(r.className || '').indexOf('ProseMirror') >= 0) return r;
      if (r.pmViewDesc) return r;
      var inner = r.querySelector ? r.querySelector('.ProseMirror') : null;
      if (inner && inner.pmViewDesc) return inner;
    } catch (e) {}
    return null;
  }

  /*
   * 受控编辑器的「内容指纹」—— 判回滚用它，别用 innerHTML。
   *
   *   innerHTML 是**序列化**结果：受控编辑器每次重渲染都可能换写法
   *   （属性顺序、布尔属性、零值单位、转义），拿它做全等比较必然假阴性 ——
   *   装置实测到过「样式确实被编辑器摘掉了，探针却一声不吭」。
   *   doc 的 JSON 是编辑器自己的结构化事实，稳定得多；拿不到 doc 才退回 innerHTML。
   */
  function pmSigOf(ctx) {
    var host = pmHostOf(ctx);
    if (!host) return null;
    /*
     * ★ v2.5.1：改成**结构摘要**，不再 `JSON.stringify(doc.toJSON())`。
     *   旧写法每次调用都要把整篇 doc 变成长字符串（doc 的 JSON 比 HTML 冗长好几倍），
     *   而回滚探针一次点击要调它 2~3 遍（runAct 一次 + 探针两次采样）——
     *   长文下这是「点一下卡半天」的最大单项。
     *   摘要覆盖的东西与旧写法等价：节点类型 / 文本长度 / 标记名 / **标记的属性值**
     *   （样式就住在标记属性里，所以「样式被编辑器抹掉」照样会让摘要变）。
     *   判据只有一处用途 —— 「现在是不是等于改动前」—— 摘要与全文串在这里等价。
     */
    try {
      var vd = host.pmViewDesc, d = vd && vd.node;
      if (!d || typeof d.descendants !== 'function') return null;
      var h = 2166136261, n = 0;
      d.descendants(function (node) {
        var s = node.type.name;
        if (node.isText) s += '#' + node.text.length;
        var ms = node.marks;
        for (var i = 0; i < ms.length; i++) {
          var m = ms[i];
          s += '+' + m.type.name + ':' + (m.attrs ? m.attrs.join(',') : '');
        }
        n++;
        for (var j = 0; j < s.length; j++) {
          h ^= s.charCodeAt(j);
          h = (h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24))) >>> 0;
        }
      });
      return n + ':' + h.toString(36);
    } catch (e) {}
    return null;
  }

  /*
   * 从 pmViewDesc 反查 schema —— 不需要 EditorView 实例。
   *   实测：desc 上没有 view 字段（PM 1.39 的 ViewDesc 不持有 view），
   *   但 desc.node 是 doc，doc.type.schema 就是 schema。这一条极其重要：
   *   schema 决定了「哪些样式会被编辑器保留」，是诊断报告里最该给用户的答案。
   */
  function pmSchemaOf(host) {
    try {
      var d = host && host.pmViewDesc;
      if (d && d.node && d.node.type && d.node.type.schema) return d.node.type.schema;
    } catch (e) {}
    return null;
  }

  // schema 清单 —— 「我的样式为什么没留下」的最终裁判
  function pmSchemaLines(host) {
    var sc = pmSchemaOf(host), L = [];
    if (!sc) { L.push('   schema：读不到（不是 PM，或版本不兼容）'); return L; }
    var nodes = [], marks = [];
    try { sc.spec.nodes.forEach(function (n) { nodes.push(n); }); } catch (e) {}
    try { sc.spec.marks.forEach(function (m) { marks.push(m); }); } catch (e) {}
    L.push('   块级节点（' + nodes.length + '）：' + (nodes.join(' ') || '（无）'));
    L.push('   行内标记（' + marks.length + '）：' + (marks.join(' ') || '（无）'));
    // ProseMirror 的 OrderedMap.forEach 回调签名是 (key, value) —— 别写反
    var styled = [], scan = function (nm, spec) {
      try { if (spec && spec.attrs && Object.prototype.hasOwnProperty.call(spec.attrs, 'style')) styled.push(nm); } catch (e) {}
    };
    try { sc.spec.nodes.forEach(scan); } catch (e) {}
    try { sc.spec.marks.forEach(scan); } catch (e) {}
    L.push('   明确声明 style 属性的：' + (styled.length ? styled.join(' ') : '无'));
    // ⚠️ 这一行曾被误读成「只有列在这里的标记能带样式」，于是 textstyle 被漏掉、
    //    报告给出「19 个按钮全不支持」的错结论。补上「具体样式属性」这一路。
    var proped = [], scan2 = function (nm, spec) {
      try {
        var ks = [];
        if (spec && spec.attrs) { for (var k in spec.attrs) ks.push(k); }
        if (styleAttrsOf(ks).length > 1) proped.push(nm);
      } catch (e) {}
    };
    try { sc.spec.marks.forEach(scan2); } catch (e) {}
    try { sc.spec.nodes.forEach(scan2); } catch (e) {}
    L.push('   把样式拆成具体属性名的（同样能承载样式）：' + (proped.length ? proped.join(' ') : '无'));
    return L;
  }

  /*
   * PM 固化：把「属性级改动」转成「节点级替换」。
   *   比对改动前后的顶层子节点快照，凡内容变了的，就 clone 一份替换回去。
   *   对 PM 来说这是「用户换了节点」，它会 parse 新节点并接纳。
   *   只动变过的节点 → 范围最小、撤销粒度最细。
   * 返回：被固化的节点数；-1 = 不是受控编辑器（交回原有路径）。
   */
  /* ══════════════════════════════════════════════════════════════════
   * 3b·前置：固化后的「选区搬家」
   *
   *   节点级固化 = clone + replace。替换一执行，选区、SNAP、CUR 指向的
   *   就全是**已经被摘下来的旧节点** ⇒ 全部脱线。表现是：
   *   点一次样式生效，**再点一次同一个按钮却提示「请先选中文字」**，取消不掉。
   *   这里在替换前记下「旧节点 → 克隆体」，替换后按**子节点索引路径**
   *   把每个位置搬到克隆树的对应节点，再恢复选区与快照。
   * ══════════════════════════════════════════════════════════════════ */

  // 从 oldRoot 到 n 的子节点索引路径（n 必须真在 oldRoot 里）
  function nodePathTo(oldRoot, n) {
    var path = [], cur = n;
    while (cur && cur !== oldRoot) {
      var p = cur.parentNode;
      if (!p) return null;
      path.unshift(Array.prototype.indexOf.call(p.childNodes, cur));
      cur = p;
    }
    return cur === oldRoot ? path : null;
  }

  // 按索引路径取回节点
  function nodeAtPath(root, path) {
    var t = root;
    for (var i = 0; i < path.length; i++) {
      if (!t || !t.childNodes) return null;
      t = t.childNodes[path[i]];
      if (!t) return null;
    }
    return t;
  }

  // 把一个位置（节点 + 偏移）从旧树搬到克隆树；搬不了返回 null
  function remapPt(pairs, n, o) {
    if (!n) return null;
    for (var i = 0; i < pairs.length; i++) {
      var oldN = pairs[i][0], newN = pairs[i][1];
      if (oldN === n) return { n: newN, o: o };
      if (oldN.contains && oldN.contains(n)) {
        var path = nodePathTo(oldN, n);
        if (!path) continue;
        var t = nodeAtPath(newN, path);
        if (t) return { n: t, o: o };
      }
    }
    return null;
  }

  // 固化后：把 SNAP / CUR / 浏览器实时选区一起搬到新节点上
  function resyncPts(ctx, pairs) {
    if (!ctx || !pairs || !pairs.length) return;
    try {
      var a = remapPt(pairs, SNAP.sc, SNAP.so);
      if (a) { SNAP.sc = a.n; SNAP.so = a.o; }
      var b = remapPt(pairs, SNAP.ec, SNAP.eo);
      if (b) { SNAP.ec = b.n; SNAP.eo = b.o; }
      var c = remapPt(pairs, CUR.c, CUR.o);
      if (c) { CUR.c = c.n; CUR.o = c.o; }
    } catch (e) {}
    try {
      var sel = ctx.win.getSelection();
      if (!sel || sel.rangeCount === 0) return;
      var r = sel.getRangeAt(0);
      var s2 = remapPt(pairs, r.startContainer, r.startOffset);
      var e2 = remapPt(pairs, r.endContainer, r.endOffset);
      if (!s2 || !e2) return;         // 选区不在被替换的节点里 → 不动它
      var nr = ctx.doc.createRange();
      nr.setStart(s2.n, s2.o);
      nr.setEnd(e2.n, e2.o);
      applySel(ctx, nr);              // 顺带刷新快照，供下一次点击使用
    } catch (e) {}
  }

  /*
   * 顶层子节点的 HTML 清单（一次序列化）。
   *   用途见 solidPM：拿它代替「把整篇 HTML 反解成 DOM 再自取清单」。
   */
  function kidsHTML(root) {
    var out = [];
    try {
      var k = root && root.children;
      if (!k) return null;
      for (var i = 0; i < k.length; i++) out.push(String(k[i].outerHTML));
    } catch (e) { return null; }
    return out;
  }

  function solidPM(ctx, before, beforeKids) {
    var host = pmHostOf(ctx);
    if (!host || before == null) return -1;
    var kids;
    try { kids = Array.prototype.slice.call(host.children); } catch (e) { return -1; }

    /*
     * ★ v2.5.1：优先用调用方在**改动之前**就抓好的顶层清单（beforeKids）。
     *   旧写法 `tmp.innerHTML = before` 等于每次点击都让浏览器把整篇 HTML
     *   **反向解析成一整棵文档树**，而这份树只用来取 children 的 outerHTML —— 纯属白花，
     *   正文越长代价越大。传得进清单就用清单；传不进（老调用方）才退回反解，行为一致。
     */
    var beforeList = null;
    if (beforeKids && beforeKids.length != null) {
      beforeList = beforeKids;
    } else {
      try {
        var tmp = document.createElement('div');
        tmp.innerHTML = before;
        beforeList = [];
        for (var i = 0; i < tmp.children.length; i++) beforeList.push(String(tmp.children[i].outerHTML));
      } catch (e) { beforeList = null; }
    }

    var done = 0;
    var pairs = [];
    for (var j = 0; j < kids.length; j++) {
      var node = kids[j], html = '';
      try { html = String(node.outerHTML); } catch (e) { continue; }
      // 节点数对不上（有增删）时无法按索引比对 → 该节点一律固化
      var same = beforeList && beforeList.length === kids.length && beforeList[j] === html;
      if (same) continue;
      try {
        // 记下「旧 → 新」，固化完要把选区/快照搬过去（见 resyncPts）
        var clone = node.cloneNode(true);
        pairs.push([node, clone]);
        node.parentNode.replaceChild(clone, node);
        done++;
      } catch (e) {}
    }
    if (pairs.length) resyncPts(ctx, pairs);
    return done;
  }

  /* ══════════════════════════════════════════════════════════════════
   * 6b. 编辑器「方言」探测 —— 回答「为什么样式设置完没效果」
   *
   * v1.7 新增。受控编辑器只认自己 schema 里的标签：
   *   · 它往 DOM 里写什么标签，就只能读回什么标签；
   *   · 我们写 <section style>，而它 schema 里根本没有 section ——
   *     于是被当「未知元素」拆掉：内容留下、样式丢光。
   *   用户看到的现象正好是「点了按钮没反应」。
   *
   * 唯一的出路是**照抄它的写法**。这一节把方言原样读出来：
   *   ① 正文里真实存在什么标签（它自己写出来的，最硬的证据）；
   *   ② 这些标签归哪个节点管、带什么属性、它读入什么、写出什么；
   *   ③ 行内标记全表 —— attrs 里有 style 的才是可用的；
   *   ④ 结论：可带 style 的块级节点 / 行内标记各是哪些。
   * 全部只读 —— 不改一个 DOM、不碰选区。
   * ══════════════════════════════════════════════════════════════════ */

  // 把 toDOM 的返回值描述成 <para[style,indent]> 这种一眼能读的形式
  function domSpecDesc(d) {
    try {
      if (!d) return '（无）';
      if (typeof d === 'string') return d;
      if (d.nodeType === 1) return '<' + String(d.tagName).toLowerCase() + '>';
      if (Object.prototype.toString.call(d) === '[object Array]') {
        var head = d[0];
        var tag = (typeof head === 'string') ? head
          : (head && head.nodeType === 1) ? String(head.tagName).toLowerCase() : '?';
        var at = '';
        var a = d[1];
        if (a && typeof a === 'object' && !a.nodeType && a.length == null) {
          var ks = [];
          for (var k in a) ks.push(k);
          at = '[' + ks.join(',') + ']';
        }
        return '<' + tag + at + '>';
      }
    } catch (e) {}
    return '?';
  }

  /*
   * 收集 attrs 键名。走两条路，任一条有盲区都还有另一条兜住：
   *   ① 编译后的 type.attrs —— 权威（PM 自己就是用 for...in 建的）；
   *   ② 原始 spec.attrs —— 连原型链上的属性一起收
   *      （v1.6 只用 hasOwnProperty 查，若属性挂在原型上就会漏报 —— 这是本次的疑似盲区）。
   */
  function attrKeysOf(type, spec) {
    var ks = [];
    try { if (type && type.attrs) { for (var a in type.attrs) { if (ks.indexOf(a) < 0) ks.push(a); } } } catch (e) {}
    try { if (spec && spec.attrs) { for (var b in spec.attrs) { if (ks.indexOf(b) < 0) ks.push(b); } } } catch (e) {}
    return ks;
  }

  // parseDOM 的标签规则 —— 「编辑器从 HTML 里认得什么」
  function readTagsOf(spec) {
    var out = [];
    try {
      var pd = spec && spec.parseDOM;
      if (!pd || !pd.length) return out;
      for (var i = 0; i < pd.length && i < 10; i++) {
        var r = pd[i];
        if (!r) continue;
        if (r.tag) out.push(String(r.tag));
        else if (r.style) out.push('{css:' + r.style + '}');
      }
    } catch (e) {}
    return out;
  }

  // toDOM 的写出标签 —— 「编辑器往 HTML 里写什么」。用安全假节点调用，异常一律吞掉。
  function readDomOf(type, spec) {
    try {
      var fnToDom = spec && spec.toDOM;
      if (typeof fnToDom === 'function') {
        var fake = {
          attrs: (type && type.defaultAttrs) || {},
          type: type,
          isBlock: !!(type && type.isBlock),
          isInline: !!(type && type.isInline),
          isLeaf: !!(type && type.isLeaf),
          nodeSize: 0, childCount: 0, marks: [], textContent: ''
        };
        return domSpecDesc(fnToDom(fake));
      }
      if (fnToDom) return domSpecDesc(fnToDom);
    } catch (e) {}
    return '（读不到）';
  }

  // 从行表里按名字取一行
  function rowPick(rows, name) {
    for (var i = 0; i < rows.length; i++) { if (rows[i].name === name) return rows[i]; }
    return null;
  }

  // 从写出描述 "<para[style]>" 里抠出标签名
  function tagOfDom(dom) {
    var m = /^<([a-z0-9_\-]+)/.exec(String(dom || ''));
    return m ? m[1] : '';
  }

  /*
   * 从 parseDOM 的选择器里抠出基础标签名 —— 「编辑器从 HTML 里认得什么」。
   *   'span[textstyle]'      → 'span'
   *   'a.wx_poi_link[data-x]'→ 'a'
   *   '{css:…}'              → ''（样式规则，没有标签）
   * 这个函数是把「读入」纳入匹配的关键：v1.7 只认「写出」标签，
   * 于是 <p>/<h2>/<ol> 被误判成「不在 schema 里」。
   */
  function tagBaseOf(sel) {
    var s = String(sel || '');
    if (!s || s.charAt(0) === '{') return '';
    var m = /^([a-zA-Z][a-zA-Z0-9]*)/.exec(s);
    return m ? m[1].toLowerCase() : '';
  }

  function dialectLines(host) {
    var sc = pmSchemaOf(host), L = [];
    if (!sc || !sc.spec) { L.push('   方言读不到（schema.spec 不可用）'); return L; }

    var rows = [], tag2node = {}, tagVia = {};
    try {
      sc.spec.nodes.forEach(function (name, spec) {
        var type = null;
        try { type = sc.nodes[name]; } catch (e) {}
        var r = {
          name: name,
          attrs: attrKeysOf(type, spec),
          tags: readTagsOf(spec),
          dom: readDomOf(type, spec),
          block: !!(type && type.isBlock)
        };
        rows.push(r);
      });
    } catch (e) {}

    /*
     * 【v1.8 修复的误报】映射表分两轮建。
     * v1.7 只用「写出标签」建映射，于是 <p>／<h2>／<ol> 全被判成「不在 schema 里」，
     * 而真相是它们的节点名不同：
     *     <p>  → para    （读入含 p，写出统一成 section）
     *     <h2> → heading （读入 h1–h6，写出默认 h1）
     *     <ol> → list    （读入 ul ol，写出 ul）
     * 「读入」才是「写了会不会被拆掉」的判据；「写出」只表示它会被改写成什么。
     * 所以：先按读入建（权威），再补写出（兜底），并记住每条映射的来源。
     */
    for (var r1 = 0; r1 < rows.length; r1++) {
      var tgL = rows[r1].tags || [];
      for (var r2 = 0; r2 < tgL.length; r2++) {
        var base = tagBaseOf(tgL[r2]);
        if (base && !tag2node[base]) { tag2node[base] = rows[r1].name; tagVia[base] = '读入'; }
      }
    }
    for (var r3 = 0; r3 < rows.length; r3++) {
      var tgW = tagOfDom(rows[r3].dom);
      if (tgW && !tag2node[tgW]) { tag2node[tgW] = rows[r3].name; tagVia[tgW] = '写出'; }
    }

    // ① 正文真实标签 —— 编辑器自己写出来的 DOM，最硬的证据
    var count = {}, order = [];
    try {
      var kids = host.children;
      for (var i = 0; i < kids.length; i++) {
        var tg2 = String(kids[i].tagName).toLowerCase();
        if (count[tg2] == null) { count[tg2] = 0; order.push(tg2); }
        count[tg2]++;
      }
    } catch (e) {}
    var brief = [];
    for (var o = 0; o < order.length; o++) brief.push('<' + order[o] + '>×' + count[order[o]]);
    L.push('【正文真实标签】' + (brief.join(' ') || '（空）'));

    // ② 这些真实标签归哪个节点管 —— 直接指出该照抄谁
    L.push('【正文标签 → 由哪个节点负责（照抄它）】');
    if (!order.length) L.push('   （正文是空的）');
    for (var u = 0; u < order.length && u < 10; u++) {
      var nm = tag2node[order[u]];
      if (!nm) { L.push('   <' + order[u] + '> → ※ 不在 schema 里（写了会被拆掉）'); continue; }
      var rr = rowPick(rows, nm) || { attrs: [], tags: [], dom: '' };
      var wTag = tagOfDom(rr.dom);
      var rw = (wTag && wTag !== order[u]) ? '（读入保留，写出改成 <' + wTag + '>）' : '';
      L.push('   <' + order[u] + '> → ' + nm + '　[' + (tagVia[order[u]] || '?') + ']'
        + '　attrs=[' + rr.attrs.join(',') + ']'
        + '　读入=' + (rr.tags.join(' ') || '—')
        + '　写出=' + rr.dom + rw);
    }

    // ③ 正文首块原文 —— 「编辑器自己写的 HTML 长什么样」
    try {
      var k0 = host.children[0];
      if (k0) {
        var html = String(k0.outerHTML || '');
        if (html.length > 240) html = html.slice(0, 240) + '…（截断）';
        L.push('【正文首块原文】' + html);
      }
    } catch (e) {}

    // ③b 正文里所有「带 style 的元素」—— 编辑器自己写的样式长什么样
    //     用户手动用微信工具栏做一次样式后，这里就会列出它的确切写法。
    //     这一行与流水里的「脚本写入：」对照，差异就是答案。
    try {
      var allEl = host.querySelectorAll('*'), bucket = {}, bOrder = [];
      for (var q = 0; q < allEl.length; q++) {
        var el2 = allEl[q], st2 = '';
        try { st2 = String(el2.getAttribute('style') || ''); } catch (e) {}
        if (!st2) continue;
        var key2 = String(el2.tagName).toLowerCase() + '[' + st2.replace(/\s+/g, '') + ']';
        if (bucket[key2] == null) { bucket[key2] = 0; bOrder.push(key2); }
        bucket[key2]++;
      }
      if (!bOrder.length) {
        L.push('【正文样式元素样本】（正文里没有任何带 style 的元素 —— 说明编辑器自己不写 style）');
      } else {
        L.push('【正文样式元素样本】（★ 这就是编辑器自己写出来的写法，脚本该照抄它）');
        for (var w = 0; w < bOrder.length && w < 12; w++) {
          L.push('   ' + bOrder[w] + ' ×' + bucket[bOrder[w]]);
        }
      }
    } catch (e) {}

    // ④ 行内标记全表 —— 「能不能带 style」就看 attrs 里有没有 style
    var markCount = 0;
    try { sc.spec.marks.forEach(function () { markCount++; }); } catch (e) {}
    L.push('【行内标记 ' + markCount + ' 个 · ★ = 能承载样式（含把样式拆成具体属性名的实现），只有 ★ 才能给文字上色】');
    try {
      sc.spec.marks.forEach(function (name, spec) {
        var type = null;
        try { type = sc.marks[name]; } catch (e) {}
        var ak = attrKeysOf(type, spec);
        L.push('   ' + (styleAttrsOf(ak).length ? '★ ' : '  ') + name
          + '　attrs=[' + ak.join(',') + ']'
          + '　读入=' + (readTagsOf(spec).join(' ') || '—')
          + '　写出=' + readDomOf(type, spec));
      });
    } catch (e) {}

    // ⑤ 结论：可带 style 的容器与标记各是哪些
    var bCand = [];
    for (var b = 0; b < rows.length; b++) {
      if (rows[b].block && rows[b].attrs.indexOf('style') >= 0 && tagOfDom(rows[b].dom)) {
        bCand.push('<' + tagOfDom(rows[b].dom) + '>(' + rows[b].name + ')');
      }
    }
    L.push('【可带 style 的块级节点】' + (bCand.join(' ') || '无 —— 块级样式基本没救'));
    var iCand = [];
    try {
      sc.spec.marks.forEach(function (name, spec) {
        var type = null;
        try { type = sc.marks[name]; } catch (e) {}
        var kk = attrKeysOf(type, spec);
        if (!styleAttrsOf(kk).length) return;
        var tg3 = tagOfDom(readDomOf(type, spec));
        if (tg3) iCand.push('<' + tg3 + '>(' + name + ')');
      });
    } catch (e) {}
    L.push('【可带 style 的行内标记】' + (iCand.join(' ') || '无 —— 行内上色基本没救'));

    /*
     * ⑥ 语义标记 —— 加粗 / 斜体这类**没有属性**的标记。
     *   它们不带 attrs，所以上面两张「能承载样式」的表里看不到它们，
     *   但它们是**手机端最稳的加粗载体**：语义标签由终端原生渲染，
     *   不依赖内联属性有没有被透传。
     *   这一行是「加粗在安卓端看不到」的唯一判据 —— 报障时先看它。
     */
    var sem = [];
    try {
      sc.spec.marks.forEach(function (name, spec) {
        var tgs = [];
        try { tgs = readTagsOf(spec) || []; } catch (e0) { tgs = []; }
        for (var s3 = 0; s3 < tgs.length; s3++) {
          var tg = String(tgs[s3] || '').toLowerCase();
          if (tg === 'strong' || tg === 'b' || tg === 'em' || tg === 'i' ||
              tg === 'u' || tg === 's' || tg === 'del' || tg === 'ins') {
            sem.push(name + ' ← ' + tg);
            break;
          }
        }
      });
    } catch (e1) {}
    L.push('【语义标记（无属性 · 终端原生渲染）】' + (sem.join('　') || '无'));
    if (!sem.length) {
      L.push('   ※ 一个都没有 ⇒ 加粗 / 斜体只能靠 textstyle 的字重与字饰属性承载。');
    }
    L.push('   ※ 安卓端只认**内联 style**：写法里只有自定义属性（textstyle）而 style 被');
    L.push('     宿主丢掉时，桌面预览看着正常、手机端会「只剩颜色、不见加粗」。');
    L.push('     配方梯子已把「补 style」提到第一级 —— 写出来的一律带内联 style。');
    L.push('   ※ 判决书（v1.9 口径）：脚本**不再自己编写法**，而是照抄编辑器自己的写法。');
    L.push('     每一条样式该写成什么样，由下面二·D 的「配方」直接问它的 toDOM 得到；');
    L.push('     判据用的是**它自己的 parser**，所以「配方读得回」就等于「写进去它认」。');
    L.push('     · 完整配方成立   → 写，样式全保留；');
    L.push('     · 只有部分能承载 → 按它支持的子集写，并明确告知丢了什么（降级）；');
    L.push('     · 一条都承载不了 → 不写、只告知（不会留「闪一下又变回」的假象）。');
    L.push('     换句话说：「设置完没效果」这件事，现在要么不会发生，要么报告里会说清原因。');
    return L;
  }

  /* ══════════════════════════════════════════════════════════════════
   * 6d. 样式配方 —— 直接问编辑器「这段样式到底该写成什么」
   *
   *   6b 只回答了「我写的它不认」。这一节更进一步：
   *   **调用编辑器自己的序列化函数，让它把正确写法交出来** —— 照抄，不猜。
   *
   *   schema 里每个标记都带一对函数：
   *     · spec.toDOM(mark)             → 它「写出」时生成的 DOM 规格
   *     · spec.parseDOM[].getAttrs(el) → 它「读入」时怎么从元素取属性
   *   于是三步：构造目标样式 → 调 toDOM → 拿它自己的写法喂 getAttrs 验证。
   *   只有「它自己写得出、又自己读得回」的写法才允许进 DOM。
   *
   *   为什么必须这样（v1.7 现场）：脚本写 <span style>，而 textstyle 标记的
   *   选择器是 span[textstyle] —— 属性不在，选择器不命中，样式必被拆掉。
   *   写法不是「像」，必须「就是」。
   * ══════════════════════════════════════════════════════════════════ */

  var RECIPES = {}, RECIPE_HOST = null;

  /*
   * 在**宿主文档**里造探针元素（不碰 PM 管辖的 DOM）。
   *   attach=true 时把它临时挂到页面 body 末尾、读完立刻摘掉（同步完成，不闪）。
   *   为什么要有这一档：有些实现的 getAttrs 依赖 CSSOM 或 isConnected，
   *   游离元素它读不到 —— v1.8 只试游离，这是现场「全部读不回」的疑似断点之一。
   */
  function probeOf(shell, ctx, attach) {
    try {
      if (!shell || !shell.tag) return null;
      var d = (ctx && ctx.doc) || document;
      var el = d.createElement(shell.tag);
      for (var k in shell.attrs) { try { el.setAttribute(k, shell.attrs[k]); } catch (e) {} }
      if (attach) {
        var b = d.body || document.body;
        if (!b) return el;
        var box = d.createElement('span');
        box.setAttribute('style', 'position:absolute;left:-99999px;top:0;width:0;height:0;overflow:hidden;');
        box.appendChild(el);
        b.appendChild(box);
        el.__mptbBox = box;
      }
      return el;
    } catch (e) { return null; }
  }

  function probeOff(el) {
    try {
      var box = el && el.__mptbBox;
      if (box && box.parentNode) box.parentNode.removeChild(box);
    } catch (e) {}
  }

  function anyAttr(o) {
    if (!o || typeof o !== 'object') return false;
    for (var k in o) { if (o[k] != null && o[k] !== '') return true; }
    return false;
  }

  // 拿一个元素逐个试该标记的 parseDOM 规则，返回第一条读得回的 attrs
  function recipeReadEl(pd, el) {
    for (var i = 0; i < pd.length; i++) {
      var r = pd[i];
      if (!r || typeof r.getAttrs !== 'function') continue;
      try {
        if (r.tag && el.matches && !el.matches(r.tag)) continue;
        var v = r.getAttrs(el);
        if (anyAttr(v)) return v;
      } catch (e) {}
    }
    return null;
  }

  // 回读值键名归一：小写 + 去横线（它的 font-weight ↔ 我们的 fontWeight）
  function normKeyMap(o) {
    var m = {};
    for (var k in o) {
      if (o[k] == null || o[k] === '') continue;
      m[String(k).toLowerCase().replace(/-/g, '')] = o[k];
    }
    return m;
  }

  // 回读值是否与目标逐条等价（走 valEq：颜色 hex↔rgb、引号、零值单位都归一）
  function readMatchesTarget(read, target) {
    var got = normKeyMap(read);
    for (var k in target) {
      var key = String(k).toLowerCase().replace(/-/g, '');
      if (!(key in got)) return false;
      if (!valEq(got[key], target[k])) return false;
    }
    return true;
  }

  /*
   * 判定一份「写法」编辑器认不认。
   *   认账标准 = **它自己的 parseDOM.getAttrs 能读回非空 attrs**。
   *   这不是近似 —— ProseMirror 的 DOMParser 决定「一个 DOM 变成哪个标记」用的就是
   *   这把尺子（tag 选择器命中 → 调 getAttrs → 真值即建标记）。所以
   *   「读得回」＝「写进去会被接纳」，是同一判据，而不是我们的猜测。
   *   返回 null = 不认；否则 { read, attach, strict }。
   */
  function judgeShell(ctx, type, shell, target) {
    var pd = [];
    try { pd = (type.spec && type.spec.parseDOM) || []; } catch (e) {}
    var el = probeOf(shell, ctx, false), read = null, attach = false;
    if (el) { read = recipeReadEl(pd, el); probeOff(el); }
    if (!read) {
      var el2 = probeOf(shell, ctx, true);
      if (el2) { read = recipeReadEl(pd, el2); probeOff(el2); if (read) attach = true; }
    }
    if (!read) return null;
    return { read: read, attach: attach, strict: readMatchesTarget(read, target) };
  }

  /*
   * 选择器 → { tag, reqs:[必需属性名] }
   *   'span[textstyle]'        → { tag:'span', reqs:['textstyle'] }
   *   'a.wx_poi_link[data-x]'  → { tag:'a',    reqs:['data-x'] }
   * 这是「选择器推导」策略的入口：选择器要什么属性，我们就给它补什么属性。
   */
  function selParts(sel) {
    var s = String(sel || '').trim(), out = { tag: '', reqs: [] };
    var m = /^([a-zA-Z][a-zA-Z0-9]*)/.exec(s);
    if (m) out.tag = m[1].toLowerCase();
    var re = /\[([a-zA-Z][-a-zA-Z0-9_]*)(?:[~^$*|]?=\s*["']?[^\]"']*["']?)?\]/g, mm;
    while ((mm = re.exec(s))) out.reqs.push(mm[1]);
    return out;
  }

  /*
   * 目标 attrs → 若干种候选编码。
   * **我们无法预知它在自定义属性里用什么格式序列化样式**（CSS 串？JSON？camel？），
   * 所以把常见的几种都编出来，交给它自己的 getAttrs 当裁判去挑。
   */
  function encodings(attrs) {
    var kebab = [], camel = [], obj = {};
    for (var k in attrs) {
      /*
       * ★ v2.6.2 修正：**跳过 `style` 键**。
       *
       *   现场（用户症状 4 · 保存后外框全丢）：
       *     S2 选择器推导里的候选是 `var at = { style: norm(css) }; at[req] = enc[q].v;`
       *     —— target **自带 `style` 键**。而本函数遍历 target 的**所有键**做 kebab
       *     拼接 ⇒ 把 **`style` 这个键名**也拼了进去，开头就是 `style:`：
       *         style:display:inline-block;margin:0 1px;padding:2px 9px;…
       *     这个脏串被塞给 `href`（现场原文：
       *         href="style:display:inline-block;margin:0 1px;padding:2px 9px;…"）
       *     `judgeShell` 校验=宽松，照样放行 ⇒ 写出一条 href 全脏的 <a>
       *     ⇒ 保存后它不是「无意义链接」被归并 ⇒ 外框 / 胶囊全丢。
       *
       *   为什么必须跳过：`style` 是**内联样式容器**，它不是「一段要写进某个自有属性
       *   的值」。把它当普通键参与序列化，等于把「样式容器」误当成「样式内容」——
       *   而 S2 的语义是「给 `at[req]` 补一个它能读回的值」，`href` 需要的是链接地址，
       *   不是样式串。
       *   注意：`at` 对象里**仍然保留** style 键（由调用方另设），只是它不参与编码。
       */
      if (String(k).toLowerCase() === 'style') continue;
      kebab.push(k.replace(/([A-Z])/g, function (_, c) { return '-' + c.toLowerCase(); }) + ':' + attrs[k]);
      camel.push(k + ':' + attrs[k]);
      obj[k] = attrs[k];
    }
    return [
      { n: 'kebab', v: kebab.join(';') + ';' },
      { n: 'camel', v: camel.join(';') + ';' },
      { n: 'json', v: JSON.stringify(obj) },
      { n: 'kebab无分号', v: kebab.join(';') },
      { n: 'camel无分号', v: camel.join(';') }
    ];
  }

  // 若选择器要求的属性名本身就是我们要设的样式属性（如 [color]），直接给裸值
  function bareFor(target, req) {
    var r = String(req).toLowerCase();
    for (var k in target) {
      if (String(k).toLowerCase() === r && target[k] != null) return target[k];
    }
    return null;
  }

  // DOMOutputSpec → { tag, attrs }，只取外壳，内容由我们自己填
  function specShell(spec) {
    try {
      if (!spec) return null;
      if (typeof spec === 'string') return { tag: spec, attrs: {} };
      if (spec.nodeType === 1) {
        var a0 = {};
        for (var i0 = 0; i0 < spec.attributes.length; i0++) {
          a0[spec.attributes[i0].name] = spec.attributes[i0].value;
        }
        return { tag: String(spec.tagName).toLowerCase(), attrs: a0 };
      }
      if (Object.prototype.toString.call(spec) !== '[object Array]') return null;
      var head = spec[0];
      if (typeof head !== 'string') {
        if (head && head.nodeType === 1) return specShell(head);
        if (Object.prototype.toString.call(head) === '[object Array]') return specShell(head);
        return null;
      }
      var at = {}, a = spec[1];
      if (a && typeof a === 'object' && !a.nodeType && a.length == null) {
        for (var k in a) { if (a[k] != null && a[k] !== '') at[k] = String(a[k]); }
      }
      return { tag: head, attrs: at };
    } catch (e) { return null; }
  }

  function cssOf(map) {
    var a = [];
    for (var k in map) a.push(k + ':' + map[k]);
    return a.length ? (a.join(';') + ';') : '';
  }

  // css 文本 → 目标标记 attrs 的键值（camelCase）；接不住的声明记进 miss
  function cssToAttrSet(css, keys) {
    var out = {}, miss = [], ds = declsOf(css);
    /*
     * ★ 整条 style 兜底（v2.2）
     *   有些标记的 attrs 里带的是一个**整条 style**（link 的 a[href]、listitem、
     *   blockquote…），它不像 textstyle 那样把 CSS 拆成 7 个具名属性，而是原样收下整串。
     *   对这种标记，任何声明都接得住 —— 不能按「属性名逐个对号」去判：那样
     *   schema 外的声明（border / padding / display / border-radius…）一律记 miss，
     *   它当场被淘汰，配方永远退到 textstyle ⇒「徽标没有外框、没有内边距」。
     *   本函数只回答「这个标记接不接得住」；**要不要真用它**由 bestMarkFor 分档决定
     *   （否则加粗这类纯文字样式会被同分抢走给 link，做成无谓的链接）。
     */
    if (keys && keys.indexOf('style') >= 0) {
      var all = [];
      for (var k0 in ds) all.push(k0 + ':' + ds[k0]);
      if (all.length) { out.style = all.join(';') + ';'; return { attrs: out, miss: [] }; }
    }
    for (var k in ds) {
      var camel = k.replace(/-([a-z])/g, function (_, ch) { return ch.toUpperCase(); });
      if (keys && keys.indexOf(camel) >= 0) out[camel] = ds[k];
      else miss.push(k);
    }
    return { attrs: out, miss: miss };
  }

  /*
   * ══ 策略梯子 ══
   * 为「一个标记 + 一段样式」找出编辑器认账的写法。每级都产出候选外壳，交给
   * judgeShell 判定，第一个通过的就是答案。级别按「可信度」从高到低排：
   *   S1b 它的 toDOM + 补 style —— 【v2.0 提到第一级】既要编辑器认，又要终端认
   *   S1  它的 toDOM            —— 编辑器自己写 HTML 时就是这么写的，最权威
   *   S2  选择器推导            —— 照 parseDOM 的选择器补必需属性，编码逐个试
   *   S3  整段 style 属性       —— 标记把整段样式放一个属性里的（link / blockquote 一类）
   *
   * 为什么 S1b 必须排在 S1 之前（v2.0 修正）：
   *   现场反馈「加粗在安卓端完全看不到、朱红加粗只剩朱红没有加粗」。
   *   机理是**两个终端认的东西不一样**：
   *     · 编辑器（受控编辑器）认的是它自己 schema 里的**自定义属性**（如 textstyle）；
   *     · 安卓端渲染只认**内联 style**。
   *   有些实现的 toDOM 只写自定义属性、**不写 style**；若它的 getAttrs 又正好读那个
   *   自定义属性，S1 就会回读通过并胜出 —— 写出来的元素没有内联 style，桌面浏览器
   *   认得自定义属性所以看着正常，手机端却什么都看不到（颜色有时靠别的链路活下来，
   *   于是表现成「只剩颜色、不见加粗」）。
   *   所以「读得回」只是第一道门槛，还有第二道：**写出来必须带内联 style**。
   *   S1b 同时满足两条（自定义属性 + style 双写），因此排在最前。
   *
   * 为什么要梯子：真机上 toDOM 与 getAttrs 是否自洽、自定义属性的序列化格式是什么，
   * 脚本**无法预知**。唯一可靠的办法就是拿它自己的 getAttrs 当裁判，把候选逐个试。
   */
  /*
   * ★ v2.6.2 新增：`coverSelfStyle(selfStyle, css)` —— 对方自带的 style 是否
   *   「已把我们整套声明都覆盖进去」。
   *
   *   场景：`ladderFor` 的 S1 走「它的 toDOM」，而真机的 toDOM 产出**自带 style**
   *   （内容是它自己的，如 color / text-decoration / border-bottom）。
   *   老判据只问「**有没有** style 键」⇒ 看到自带就**不补**我们的配方 ⇒ 外框声明全丢。
   *
   *   判据（与 `readMatchesTarget` 同源，只是作用在「写」侧）：
   *     逐条比 —— 我方每一条声明，在它的 style 里都要**等值**存在；
   *     全都在 ⇒ true（不必补）；缺任何一条 ⇒ false（必须补）。
   *
   *   为什么用「逐条等值」而不是「有 style 就够」：
   *     它们都能接住 `color`（两边都有），差别恰恰在 display / padding / border /
   *     border-radius 这几条 —— 只有逐条比才分得出来。
   *   为什么不用 `decls` 的键数比：
   *     键数相同不代表内容相同（它有 border-bottom，我们要 border）。
   *     比的是**我方每一条**是否都被覆盖，语义与被度量的事情对齐。
   */
  function coverSelfStyle(selfStyle, css) {
    var want = declsOf(css), got = declsOf(selfStyle || ''), k;
    var any = false;
    for (k in want) {
      any = true;
      if (got[k] == null || got[k] === '') return false;   // 它没有这一条 ⇒ 覆盖不足
      if (!valEq(got[k], want[k])) return false;           // 有但不等值 ⇒ 覆盖不足
    }
    return any;
  }

  /* ══ ★ v2.6.3：href 必须是「真链接形状」════════════════════════════
   *
   * 现场（用户 2026-09-20 14:27 报告 · ver 2.6.2 真机）：配方取胜写法仍是
   *   「选择器推导 href=kebab」而非 S1b，写出物 href=";"，保存后外框又丢。
   *
   * 两条根因：
   *   ① 真机 link.toDOM 在 node.attrs.href 为空时【不输出 href 属性】
   *      （`href: node.attrs.href || undefined` 的常见写法）
   *      ⇒ S1b 全量复制 toDOM 属性 ⇒ 写出物没有 href
   *      ⇒ parseDOM 的 a[href] 选择器不匹配 ⇒ judgeShell 判死
   *      ⇒ 轮到 S2，而 S2 的 href 只是「过选择器的门票」（';' / '' / '#'）。
   *      （rep257 装置的 toDOM 无条件输出 href='#'，把这条真机规则漏了。）
   *   ② 门票 href 在微信保存清洗层眼里是「无意义链接」⇒ 连壳带 style 归并。
   *
   * 修法：所有 <a> 候选在 judgeShell 评审之前洗 href ——
   *   /^https?:\/\// 通过的保留原值（尊重真链接），其余统一给 SAFE_HREF。
   *   为什么必须赶在 judgeShell 之前：S1b 要靠 href 过 a[href] 选择器
   *   才能被读到；href 洗干净后 S1b 稳定胜出，S2 的脏值只是备份。
   *   ★ v2.6.4 教训：不能用 mp.weixin.qq.com —— 微信保存校验弹
   *   「请勿插入mp.weixin.qq.com域名下的非图文消息链接，请删除后重试」
   *   （本域只放行 /s/ 图文消息形状）。改用外域真实链接 www.qq.com：
   *   不触发该校验，编辑器「插入链接」本就允许任意外域。
   */
  function safeHref() {
    return 'https://www.qq.com/';
  }
  function saneHref(v) {
    var s = String(v == null ? '' : v);
    return /^https?:\/\//i.test(s) ? s : safeHref();
  }

  function ladderFor(ctx, type, css, target, trace) {
    var list = [], tried = [];

    // S1 / S1b
    var s1 = null;
    try {
      var full = {}, dk;
      var dft = (type && type.defaultAttrs) || {};
      for (dk in dft) full[dk] = dft[dk];
      for (dk in target) full[dk] = target[dk];
      s1 = specShell(type.spec.toDOM(type.create(full), false));
    } catch (e1) {
      try { s1 = specShell(type.spec.toDOM(type.create(target), false)); }
      catch (e2) { trace.push('· S1 它的 toDOM 抛错：' + String((e2 && e2.message) || e2)); }
    }
    if (s1 && s1.tag) {
      /*
       * ★ 双写优先：先给「自定义属性 + 内联 style」的版本，读得回就用它。
       *   这样写出的元素两个终端都认（编辑器认属性、安卓端认 style）。
       *   只有双写失败时，才退到编辑器原样的写法。
       */
      /*
       * ★ v2.6.2 修正：判据从「**有没有** style 键」改成「它那串 style **是否已覆盖
       *   我们的声明**」。
       *
       *   现场（用户症状 4 · 保存后徽标 / 标签外框全丢）：
       *     真机 link 的 toDOM **自带 style 键**，内容是它自己的
       *         color:#456CAA;text-decoration:none;border-bottom:1px solid #C3D6EB;
       *     里面**没有** display / padding / border / border-radius —— 而徽标的外框
       *     全靠这几条。老判据只问「有没有 style 键」⇒ 看到它自带 style 就**不补**
       *     ⇒ S1b 从不被 push ⇒ S1（它自己的 style）直接胜出
       *     ⇒ 我们的整条配方**一条都没进去** ⇒ 保存后外框全丢。
       *     rep257 实测：readVia=它的 toDOM，声明存活 **0/11**（徽标）/ **0/10**（标签）。
       *
       *   新判据与 `readMatchesTarget` 同源（那个用在「读」侧，这里用在「写」侧）：
       *     它自带的 style 已把我们整套声明都含进去 ⇒ 尊重它，不补；
       *     否则 ⇒ 必须补 S1b，用我们配方的 style 覆盖掉它那串。
       *   为什么不是「无脑总补」：真机若已正确写好整套声明，重写会丢掉它附带的
       *     其它属性语义（如它给自己的 color/decoration）。只在「覆盖不足」时才接管。
       */
      var s1Style = (s1.attrs && s1.attrs.style) || '';
      if (!s1.attrs || !s1Style || !coverSelfStyle(s1Style, css)) {
        var sh = { tag: s1.tag, attrs: {} }, k1;
        for (k1 in s1.attrs) sh.attrs[k1] = s1.attrs[k1];
        sh.attrs.style = norm(css);
        list.push({ via: '它的 toDOM + 补 style（内联优先）', shell: sh });
      }
      list.push({ via: '它的 toDOM', shell: s1 });
    } else if (s1) {
      trace.push('· S1 它的 toDOM 只给出 <' + s1.tag + '>，没有可用属性');
    }

    // S2 选择器推导
    var pd = [];
    try { pd = (type.spec && type.spec.parseDOM) || []; } catch (e3) {}
    var enc = encodings(target);
    enc.push({ n: '原样式串', v: norm(css) });
    for (var i = 0; i < pd.length; i++) {
      var sel = selParts(pd[i] && pd[i].tag);
      if (!sel.tag || !sel.reqs.length) continue;
      for (var j = 0; j < sel.reqs.length; j++) {
        var req = sel.reqs[j], q;
        for (q = 0; q < enc.length; q++) {
          var at = { style: norm(css) };
          at[req] = enc[q].v;
          list.push({ via: '选择器推导 ' + req + '=' + enc[q].n, shell: { tag: sel.tag, attrs: at } });
        }
        var bare = bareFor(target, req);
        if (bare != null) {
          var at2 = { style: norm(css) };
          at2[req] = bare;
          list.push({ via: '选择器推导 ' + req + '=裸值', shell: { tag: sel.tag, attrs: at2 } });
        }
      }
    }

    // S3 整段 style 属性
    var keys = attrKeysOf(type, type.spec);
    if (keys.indexOf('style') >= 0) {
      var tg = tagOfDom(readDomOf(type, type.spec)) || 'span';
      list.push({ via: '整段 style 属性', shell: { tag: tg, attrs: { style: norm(css) } } });
    }

    /* ★ v2.6.3：所有 <a> 候选在评审之前洗 href（必须在 judgeShell 之前 ——
     *   S1b 靠 href 过 a[href] 选择器才能被读到）。候选里的 href 只是
     *   「过选择器的门票」（';' / '' / '#'），保存清洗层会把无意义链接
     *   连壳带 style 归并 ⇒ 统一洗成真链接形状。 */
    for (var hz = 0; hz < list.length; hz++) {
      var hc = list[hz];
      if (hc && hc.shell && hc.shell.tag === 'a' && hc.shell.attrs) {
        hc.shell.attrs.href = saneHref(hc.shell.attrs.href);
      }
    }

    for (var z = 0; z < list.length; z++) {
      var cand = list[z];
      if (!cand.shell || !cand.shell.tag) continue;
      var jd = judgeShell(ctx, type, cand.shell, target);
      if (!jd) { if (tried.indexOf(cand.via) < 0) tried.push(cand.via); continue; }
      return { shell: cand.shell, via: cand.via, read: jd.read, strict: jd.strict, attach: jd.attach };
    }
    trace.push('· 共试 ' + list.length + ' 种写法，它的 getAttrs 一种都没认'
      + (tried.length ? '（' + tried.slice(0, 5).join('／') + (tried.length > 5 ? ' 等' : '') + '）' : ''));
    return null;
  }

  /*
   * ══ 配方搜索必须**跳过语义标签型标记**（v2.5 补丁 2）════════════════
   *
   * 现场（装置实测）：忠实地把真编辑器的语义标记（strong / b / em / i / u / s / del）
   *   加进 schema 之后，**徽标 / 标签 / 橙高亮全被塞进了 <strong>**：
   *       <strong style="display:inline-block;padding:0 5px;border-radius:5px;background-color:#FCF2E9;…">
   *   根因不是 semWrapFor（它的 SEM_DECL_OK 白名单拦得住），而是 bestMarkPick /
   *   bestPartialFor 会遍历**所有**标记。语义标记带一个 style 属性 ⇒ 在「整条档」里
   *   与 link 同分，而 tagOfDom 给出 'strong' ⇒ 配方把徽标判给了 <strong>。
   *
   * 为什么必须排除：语义标签表达的是「这段字是粗的 / 斜的 / 带下划线的」，
   *   不是「这块是徽标」。真编辑器自己也是这么分的 ——
   *   线上文章里徽标 / 标签一律是 <span style="display:inline-block;…">，
   *   只有加粗正文才是 <strong style="font-weight:700;color:#1a1a1a;">。
   *   把外框 / 底色塞进 <strong> 等于把「语义」当「样式容器」用，是把标签用错地方。
   *
   * 保守判定：只排除「读入标签与写出标签**全是**语义标签」的标记。
   *   混合标记（例如 parseDOM 同时含 strong 与 span[textstyle]）照旧参与候选，不误伤。
   */
  function isSemanticTagName(tag) {
    return !!(tag && SEM_CARRIER[String(tag).toUpperCase()]);
  }
  function markIsSemanticOnly(type, spec) {
    var tags = [], i;
    try { tags = readTagsOf(spec) || []; } catch (e) { tags = []; }
    if (!tags.length) return false;                       // 读入标签读不到 ⇒ 不敢判，放行
    for (i = 0; i < tags.length; i++) {
      if (!isSemanticTagName(tagBaseOf(tags[i]))) return false;
    }
    var domTag = '';
    try { domTag = tagOfDom(readDomOf(type, spec)); } catch (e) { domTag = ''; }
    if (domTag && !isSemanticTagName(domTag)) return false;
    return true;
  }

  // 精确档：找一个能接住**全部**声明的标记
  /*
   * 选标记，**分两档**（v2.2）：
   *   ① 精确档（allowStyle=false）：按「属性名逐个对号」找 —— textstyle 这类把
   *      CSS 拆成具名属性的标记在这里胜出。加粗 / 字色 / 下划线等纯文字样式走这条。
   *   ② 整条档（allowStyle=true）：只有精确档全军覆没时，才轮到「带整条 style 的
   *      标记」（link 的 <a href>）。徽标 / 标签 / 行内代码 / 键盘键这类含 schema
   *      外声明的配方走这条。
   *
   * 为什么**必须**分档，而不能只给 cssToAttrSet 加兜底：
   *   `font-weight:700` 在整条档里，link（n=1，只有一个 style 键）与 textstyle
   *   （n=1，fontWeight）**同分**；而标记顺序里 link 在 textstyle 之前，同分时先
   *   遍历到的赢 ⇒ 加粗会被做成一枚无意义的链接。分档后精确档先命中，加粗不走 link。
   */
  /*
   * 「整条 style 型标记」的载体优先级（v2.5.3）。
   *
   * 【为什么需要】三个能带整条 style 的行内标记（poi_link / weapp_link / link）
   *   在我们的写法（`<a href="#" style="整条配方">`）下 cover 完全相同，
   *   tie-break 取先到者 ⇒ 排第一的 poi_link 胜出。可它的读入选择器是
   *   `a.wx_poi_link[data-poiid][data-districtid]` —— **带一堆必需限定符**，
   *   我们造不出那些属性，它当然一种写法都读不回来。
   *   而 `link` 的读入是裸的 `a[href]`：我们写什么，它就读回什么。
   *
   *   区分不出来，整条档就永远押在一个注定读不回来的标记上
   *   ⇒ 静默落到降级档 ⇒ 只带 7 属性子集 ⇒ **保存后外框全丢**（现场症状）。
   *
   * 【判据】读入选择器里，除基础标签外还有没有**额外的必需限定符**：
   *     a[href]                        → 只有属性名，且属性是 href（我们自己会写）→ 2
   *     a.wx_poi_link[data-poiid]      → 有 class / 别的 data-* 必需项           → 1
   *     span[textstyle]                → 同上（但我们不会把它当整条载体）        → 1
   *   为什么把 `href` 单独放行：它是我们要写的那一个属性，不算「造不出的限定符」。
   */
  function wideRankOf(type, spec) {
    var keys = attrKeysOf(type, spec);
    if (keys.indexOf('style') < 0) return 0;
    var sels = readTagsOf(spec);          // parseDOM 里的选择器原文
    var i, best = 0;
    for (i = 0; i < sels.length; i++) {
      var sel = String(sels[i] || '');
      if (!sel || sel.charAt(0) === '{') continue;
      // 基础标签名之后的部分 = 限定符串（如 ".wx_poi_link[data-poiid]" 或 "[href]"）
      var m = /^[a-zA-Z][a-zA-Z0-9]*((?:\.[\w\-]+|\[[^\]]*\])*)$/.exec(sel);
      if (!m) continue;
      var quals = m[1] || '';
      // 把 [href] 这一种「我们会写」的属性名摘掉，再看还剩什么限定符
      var rest = quals.replace(/\[\s*href\s*\]/gi, '');
      if (!rest) { if (best < 2) best = 2; }
      else if (best < 1) best = 1;
    }
    return best;
  }

  function bestMarkPick(sc, css, allowStyle) {
    var best = null;
    try {
      sc.spec.marks.forEach(function (name, spec) {
        var type = null;
        try { type = sc.marks[name]; } catch (e) { return; }
        if (!type || !type.spec) return;
        if (markIsSemanticOnly(type, spec)) return;      // ★ v2.5：语义标签不参与配方搜索
        var keys = attrKeysOf(type, spec);
        var hasStyle = keys.indexOf('style') >= 0;
        // 整条 style 型标记：精确档不参与；用户关掉载体开关时也不参与
        if (hasStyle && (!allowStyle || !carryLinkOn())) return;
        var got = cssToAttrSet(css, keys);
        var n = 0, q;
        for (q in got.attrs) n++;
        if (!n || got.miss.length) return;
        /*
         * ★ cover = 这个标记**实际覆盖了几条声明**（v2.5.2）。
         *   为什么不能用 n：`cssToAttrSet` 的**整条 style 兜底支路**返回
         *   `{ attrs: { style: 整串 }, miss: [] }` —— 只有一个键，n 恒为 1。
         *   于是「整条档能接住全部声明」这件事**在 n 上完全看不出来**：
         *   三段式的第②段若拿 n 当判据，就永远进不去（死代码）。
         *   装置 rep252（真机 link 口径）一上手就把这条戳穿了：
         *       A2 FAIL  pick.n=5  wide.n=1  gotAll=11
         *   cover 的算法与 cssToAttrSet 的语义对齐：
         *     · 走了整条兜底（有 style 键、miss 为空）⇒ 整条收下 ⇒ 覆盖全部声明；
         *     · 走逐属性对号             ⇒ 接住几个键，就是覆盖了几条声明。
         */
        var cover = n, kc;
        if (got.attrs && got.attrs.style != null) {
          cover = 0;
          for (kc in declsOf(css)) cover++;
        }
        /*
         * ★ v2.5.3：tie-break 必须再比一层 wideRank。
         *   同 cover 的整条型标记里，只有「读入 = 裸 a[href]」的那个（link）
         *   才写什么读回什么；poi_link / weapp_link 带必需限定符，注定读不回来。
         *   不比这一层 ⇒ 按 marks 的声明顺序先到者胜 ⇒ 押在 poi_link 上 ⇒
         *   整条档静默失败、落到降级档、保存后外框全丢。
         *   （现场取证：报告二·D 的 12 条「完整档」全部只提 poi_link。）
         */
        var rank = cover > 1 ? wideRankOf(type, spec) : 0;
        if (!best || cover > best.cover
            || (cover === best.cover && rank > (best.wideRank || 0))) {
          best = { name: name, type: type, attrs: got.attrs, n: n,
                   cover: cover, wideRank: rank };
        }
      });
    } catch (e) {}
    return best;
  }

  function bestMarkFor(sc, css) {
    return bestMarkPick(sc, css, false) || bestMarkPick(sc, css, true);
  }

  // 降级档：找「能接住最多声明」的标记，用它接得住的子集
  function bestPartialFor(sc, css) {
    var best = null;
    try {
      sc.spec.marks.forEach(function (name, spec) {
        var type = null;
        try { type = sc.marks[name]; } catch (e) { return; }
        if (!type || !type.spec) return;
        if (markIsSemanticOnly(type, spec)) return;      // ★ v2.5：语义标签不参与配方搜索
        var got = cssToAttrSet(css, attrKeysOf(type, spec));
        var n = 0, q;
        for (q in got.attrs) n++;
        if (!n) return;
        /* cover 与 bestMarkPick 同一算法（见那里的注释），保证两处判据不漂移 */
        var cover = n, kc;
        if (got.attrs && got.attrs.style != null) {
          cover = 0;
          for (kc in declsOf(css)) cover++;
        }
        if (!best || cover > best.cover) {
          best = { name: name, type: type, attrs: got.attrs, n: n, cover: cover,
                     wideRank: cover > 1 ? wideRankOf(type, spec) : 0,
                     miss: got.miss };
        }
      });
    } catch (e) {}
    return best;
  }

  var RECIPES = {}, RECIPE_HOST = null;

  /*
   * 当前编辑器里「配方型」的自定义属性名（textstyle 这一类）。
   * 取消样式时必须连同它们一起清干净：只删 style 会留下旧的自定义属性，
   * 编辑器读回来还是旧样式，表现就是「再点一次取消不掉」。
   * 判定方式很收敛：只收「某个标记的 parseDOM 选择器明确要求」的属性名，
   * 且跳过 style / 结构性属性（href、id…）/ data-* —— 免得误删链接的 href。
   */
  function recipeAttrNames(ctx) {
    var out = ['textstyle'];
    var host = pmHostOf(ctx), sc = host && pmSchemaOf(host);
    if (!sc) return out;
    try {
      sc.spec.marks.forEach(function (name, spec) {
        var pd = (spec && spec.parseDOM) || [];
        for (var i = 0; i < pd.length; i++) {
          var reqs = selParts(pd[i] && pd[i].tag).reqs;
          for (var j = 0; j < reqs.length; j++) {
            var k = reqs[j];
            if (STYLE_ATTR_NAMES.indexOf(k) >= 0) continue;
            if (/^(href|src|id|class|target|rel)$/i.test(k)) continue;
            if (/^data-/i.test(k)) continue;
            if (out.indexOf(k) < 0) out.push(k);
          }
        }
      });
    } catch (e) {}
    return out;
  }

  function recipeCompute(ctx, key, sc, rec) {
    /*
     * ══ 三段式（v2.5.2 修正）══════════════════════════════════════════
     *   ① 精确档（属性名逐个对号）  → 能接住**全部**声明才算成功
     *   ② 整条档（带整条 style 的载体）→ 也能接住**全部**声明就算成功（★ 本轮新增）
     *   ③ 降级档（子集）           → 只能接住一部分，如实告知丢了什么
     *
     * 为什么必须插进②（本轮现场结论）：
     *   老实现是 `bestMarkFor = bestMarkPick(false) || bestMarkPick(true)`
     *   —— 小件按钮的 fb（降级子集）声明**全部**落在 SCHEMA_ATTR_CSS 那 7 个
     *   属性内，所以 textstyle 在**第一档**就能 miss 为空地胜出 ⇒ `||` 短路
     *   ⇒ 第二档（link 整条档）**从未执行**！
     *   于是 rec 判 partial ⇒ eff.full 永假 ⇒ directCarry 恒真
     *   ⇒ 写 <a href="#" style="整条配方">，而本机 link 标记只对**真链接**产出
     *   <a>（写出物带 linktype / data-linktype），href="#" 被它的 parser 当
     *   无意义链接接下 ⇒ 归并成 <span>
     *   ⇒ display / padding / border / border-radius / font-size / line-height 全丢
     *   ⇒ 编辑器里看着生效，微信后台**一保存样式就没了** —— 正是用户报的症状。
     *
     *   所以不能让第一档的「能接子集」把第二档挡在外面 —— 要多问一句：
     *   **整条载体能不能把整套声明一次接住？**
     */
    // ① 精确档
    var pick = bestMarkFor(sc, key);
    var gotAll = 0, k0;
    for (k0 in declsOf(key)) gotAll++;            // 这段样式一共有多少条声明
    if (pick) {
      var sol = ladderFor(ctx, pick.type, key, pick.attrs, rec.trace);
      if (sol) {
        rec.ok = true; rec.level = 'full';
        rec.mark = pick.name; rec.tag = sol.shell.tag; rec.attrs = sol.shell.attrs;
        rec.readVia = sol.via; rec.ready = sol.read; rec.strict = sol.strict;
        rec.attached = !!sol.attach;
        return rec;
      }
      rec.why = '标记「' + pick.name + '」能带这些属性，但试过它自己的写法都读不回来';
    } else {
      rec.why = '没有任何标记能同时接住这段样式的全部声明';
    }

    /*
     * ② 整条档（v2.5.2 新增）—— “子集能接住”不等于“只能接子集”。
     *   精确档只接 2~4 条，而整条档（link 的 a[style]）能接全部。
     *   只要它自己的 getAttrs 认账，就该用它 —— 这正是「完整落地」的唯一判据。
     *   载体开关关掉时不试（用户明确要求走扁平版）。
     */
    if (carryLinkOn() && (!pick || pick.cover < gotAll)) {
      var wide = bestMarkPick(sc, key, true);
      if (wide && wide.cover >= gotAll) {
        var solW = ladderFor(ctx, wide.type, key, wide.attrs, rec.trace);
        if (solW) {
          rec.ok = true; rec.level = 'full';
          rec.mark = wide.name; rec.tag = solW.shell.tag; rec.attrs = solW.shell.attrs;
          rec.readVia = solW.via; rec.ready = solW.read; rec.strict = solW.strict;
          rec.attached = !!solW.attach;
          return rec;
        }
        rec.why += '；整条载体（' + wide.name + '）能接全部声明，但它自己的写法也读不回来';
      }
    }

    // ③ 降级档：按「它能承载的子集」再走一遍梯子
    var pp = bestPartialFor(sc, key);
    if (pp) {
      var partCss = cssOf(pp.attrs);
      var sol2 = ladderFor(ctx, pp.type, partCss, pp.attrs, rec.trace);
      if (sol2) {
        rec.level = 'partial';
        rec.mark = pp.name; rec.tag = sol2.shell.tag; rec.attrs = sol2.shell.attrs;
        rec.readVia = sol2.via; rec.ready = sol2.read; rec.strict = sol2.strict;
        rec.attached = !!sol2.attach;
        rec.part = { css: partCss, drop: pp.miss, mark: pp.name };
        rec.why = '编辑器承载不了 ' + pp.miss.join('、');
        return rec;
      }
      rec.why += '；退让到子集（' + partCss + '）也读不回来';
    }
    rec.level = 'none';
    return rec;
  }

  /*
   * 主入口：css → 配方。
   *   rec.ok      = true  → 这段样式能**完整**落地（照它的写法写）
   *   rec.level   = partial → 只能落地「它能承载的子集」（rec.part）
   *   rec.level   = none    → 一条都承载不了
   *   rec.trace   = 取证：每一级试了什么、断在哪一步（报告里原样打印，不再只给结论）
   */
  function pmRecipe(ctx, css) {
    var host = pmHostOf(ctx);
    if (!host) return null;
    var sc = pmSchemaOf(host);
    if (!sc) return null;
    if (RECIPE_HOST !== host) { RECIPES = {}; RECIPE_HOST = host; }
    var key = norm(css);
    if (Object.prototype.hasOwnProperty.call(RECIPES, key)) return RECIPES[key];

    var rec = {
      css: key, ok: false, level: 'none', mark: '', tag: '', attrs: {}, readVia: '',
      ready: null, why: '', trace: [], strict: false, part: null, attached: false
    };
    try { rec = recipeCompute(ctx, key, sc, rec); }
    catch (e) { rec.why = '配方计算异常：' + String((e && e.message) || e); }
    RECIPES[key] = rec;
    return rec;
  }

  /* ══════════════════════════════════════════════════════════════════
   * 语义载体（v2.5）—— 「加粗在安卓端看不到」的正面修法
   *
   * 【现场】加粗 / 朱红加粗在安卓端看不到加粗效果（iOS 看着是粗的）。
   *
   * 【线上实证】2026-09-19 抓真实公众号文章正文比对写法，微信编辑器自己产出的加粗是：
   *       <strong style="font-weight: 700;color: rgb(26, 26, 26);">
   *   载体是 **<strong> 语义标签**，字重写在它的内联 style 上。
   *   而本脚本的加粗此前一律走 textstyle 配方 ⇒ `<span style="font-weight:bold">`。
   *   两者在桌面浏览器里渲染等价，**手机端不等价**：语义标签由终端原生渲染，
   *   不依赖内联属性透不透传；span + 内联字重正是「桌面正常、手机没粗」的那条路。
   *
   * 【做法】样式若只含「纯文字声明」（字重 / 字饰 / 字色 / 字号 / 行距），且编辑器
   *   schema 里确实有对得上这个标签的标记，就改用语义标签承载，**完整 css 照写进 style**。
   *   schema 里对不上 ⇒ 返回 null，原样退回 textstyle 链路（不更差）。
   * ══════════════════════════════════════════════════════════════════ */
  var SEM_TAGS = [
    { re: /(?:^|;)\s*font-weight\s*:\s*(?:bold|bolder|[6-9]\d{2}|1000)\s*(?:;|$)/i, tags: ['strong', 'b'] },
    { re: /(?:^|;)\s*font-style\s*:\s*italic\s*(?:;|$)/i, tags: ['em', 'i'] },
    { re: /(?:^|;)\s*text-decoration\s*:\s*underline\s*(?:;|$)/i, tags: ['u'] },
    { re: /(?:^|;)\s*text-decoration\s*:\s*line-through\s*(?:;|$)/i, tags: ['s', 'del'] }
  ];
  /*
   * 只有「纯文字」声明才允许走语义载体。
   * 含外框 / 底色 / 排版的配方（徽标、标签、行内代码、键盘键、渐变下划……）一律不走 ——
   * 那些样式的语义不是「加粗」，塞进 <strong> 只是把标签用错地方。
   * 这条白名单也是「加粗按钮不会被徽标抢走」的保险：徽标的配方里有 display/padding/border，
   * 一旦出现就不满足条件。
   */
  var SEM_DECL_OK = {
    'font-weight': 1, 'font-style': 1, 'text-decoration': 1,
    'color': 1, 'font-size': 1, 'line-height': 1
  };

  // 这段样式该用哪个语义标签（只看值，不看 schema）
  function semTagFor(css) {
    var s = norm(css), out = [], i, j;
    for (i = 0; i < SEM_TAGS.length; i++) {
      if (SEM_TAGS[i].re.test(s)) {
        for (j = 0; j < SEM_TAGS[i].tags.length; j++) {
          if (out.indexOf(SEM_TAGS[i].tags[j]) < 0) out.push(SEM_TAGS[i].tags[j]);
        }
      }
    }
    return out;
  }

  /*
   * ★ v2.6.5：宽载体（合成粘贴）送出去的 HTML 该用哪个标签包裹。
   *   纯文字样式（字重 / 字饰 / 字色 / 字号 / 行距）⇒ 语义标签：终端（手机）原生
   *   渲染语义标签，不依赖内联属性透传 ——「编辑器里粗、手机上不粗」正是
   *   span + 内联字重那条路。含外框 / 底色 / 排版的配方装不进语义标签 ⇒ 返回 ''
   *   （调用方退回 span）。这里**只看值不看 schema**：HTML 是送进宿主的导入链，
   *   由它自己的解析器接纳，比 schema 直通宽。
   */
  /*
   * ★ v2.6.23：停用「值 → 语义标签」映射，统一返回 ''。
   *   与 semTagForCtx 同一份判决书（见下方函数体）：真机 schema 没有语义标记，
   *   <strong> 被解析器剥掉、连挂在它身上的 textstyle 属性一起丢。产品实际的落点
   *   路径（semWrapFor → semTagForCtx）已停用语义标签、改走配方 span；这里的
   *   「值 → 标签」纯函数若仍返回 strong，会与产品实际落点不一致，误导诊断。
   *   所以任何纯文字样式都不再声称能走语义标签。
   *   本函数不参与任何实时落点路径（全源码无调用点，仅诊断装置直接引用），
   *   改它不影响产品行为，只让 semTagForHtml 与 semTagForCtx 口径一致。
   */
  function semTagForHtml(css) {
    return '';
  }

  // 在 schema 里找「读入标签」含该标签的标记
  function markByTag(sc, tag) {
    var found = null;
    try {
      sc.spec.marks.forEach(function (name, spec) {
        if (found) return;
        var tgs = [], i;
        try { tgs = readTagsOf(spec) || []; } catch (e) { tgs = []; }
        for (i = 0; i < tgs.length; i++) {
          if (String(tgs[i]).toLowerCase() === tag) {
            var t = null;
            try { t = sc.marks[name]; } catch (e2) {}
            if (t && t.spec) found = t;
            return;
          }
        }
      });
    } catch (e3) {}
    return found;
  }

  /*
   * 语义标记没有属性，judgeShell 那把尺子（getAttrs 读回非空 attrs）在这里量不到东西。
   * 判定改成一条等价命题：它的 parseDOM 里有「tag 命中且不要求任何属性」的规则 ⇒
   * DOMParser 见到 <strong> 就会建这个标记。有属性要求的规则（如 span[textstyle]）不算。
   */
  function semAccepts(type, tag) {
    var pd = [];
    try { pd = (type.spec && type.spec.parseDOM) || []; } catch (e) { return false; }
    for (var i = 0; i < pd.length; i++) {
      var r = pd[i], sel = (typeof r === 'string') ? r : (r && r.tag);
      if (!sel) continue;
      var sp = selParts(sel);
      if (sp.tag === tag && !sp.reqs.length) return true;
    }
    return false;
  }

  // 能走语义载体就返回一个造好的元素，否则 null（调用方原样退回 textstyle 链路）
  /*
   * 「这段样式能不能走语义载体、走哪个标签」—— 只回答标签名，不造元素。
   *   拆出来是为了让**上层也能问同一句话**（v2.5.1：合并路径要不要给它让路），
   *   判据与 semWrapFor 完全共用，避免「能不能走」在两处各写一份而漂移。
   */
  function semTagForCtx(ctx, css) {
    var host = pmHostOf(ctx);
    if (!host) return '';                         // 非受控编辑器：语义标签无人认领，不冒险
    var s = norm(css);
    if (!s) return '';
    var d = declsOf(s), k;
    for (k in d) { if (!SEM_DECL_OK[String(k).toLowerCase()]) return ''; }
    var tags = semTagFor(s);
    if (!tags.length) return '';
    var sc = pmSchemaOf(host);
    /* ★ v2.6.23：读不到 schema 就**不猜**语义标签 —— 见函数尾部的根因说明。 */
    if (!sc) return '';
    for (var i = 0; i < tags.length; i++) {
      var t = markByTag(sc, tags[i]);
      if (t && semAccepts(t, tags[i])) return tags[i];
    }
    /*
     * ══ ★ v2.6.23 判决：语义标签兜底**停用**（v2.6.5 / v2.6.9 那条路推翻）══
     *
     * 【现场判据】用户 2026-09-21 18:19 真机体检报告，两条互相印证：
     *   二·B —— 行内标记共 7 个（pasteLink / poi_link / weapp_link / topic /
     *           link / codehighlight / textstyle），【语义标记（无属性 ·
     *           终端原生渲染）】＝**无**；
     *   二·D —— 配方（直接调编辑器自己的 toDOM，再用**它自己的 parser** 回读）
     *           对「加粗」给出的写法是
     *             <span style="font-weight:bold" textstyle="font-weight:bold;">
     *           回读 {"fontWeight":"bold"}，校验=严格。
     *   而用户实测「加粗 / 朱红加粗点了没效果」—— 正是走 <strong> 的两个按钮
     *   （其余按钮走 span，全部正常）。走到哪一步断的已经很清楚了：
     *   **<strong> 被它的解析器剥掉，挂在它身上的 textstyle 属性随之一起丢**，
     *   连 v2.6.9 拿来兜底的「双保险」也救不回来（属性长在会被剥的壳上）。
     *
     * 【v2.6.5 / v2.6.9 错在哪】它们的依据是「宿主正文里活着 strong」。
     *   本轮复查那份证据：那些 strong 一带 `data-pm-slice`（ProseMirror 粘贴
     *   slice 的临时标记），是**从别处粘贴进来、还没被重解析的残留**，
     *   不是「宿主接纳 strong」的证明 —— 把粘贴残留读成了方言，才推翻了
     *   marks 表那条本来正确的判据。判据应当回到最硬的一条：
     *   **它在 marks 表里吗？不在 ⇒ 写进去就会被剥。**
     *
     * 【代价与边界】语义标签这条通道此后不再产出 —— 但产品行为一个字没少：
     *   加粗照样有内联 style（报告二·D 已证它被接纳，且二·C 的判决书本来就写着
     *   「安卓端只认内联 style」）；而真正会变的只有「写法」——
     *   从脚本自己编的 <strong> 改成照抄编辑器自己 toDOM 的 <span>，
     *   这正是 v1.9 判决书要的口径。
     */
    return '';
  }

  function semWrapFor(ctx, doc, css) {
    var tag = semTagForCtx(ctx, css);
    if (!tag) return null;
    try {
      var el = doc.createElement(tag);
      var full = norm(css);
      el.setAttribute('style', full);           // 完整配方照写：语义标签表达含义，style 表达其余
      /*
       * ★ v2.6.9 双保险：配方同时写成 textstyle 属性（span 承载样式的那条路）。
       *   语义标签在真机是否被**主解析器**接纳，我们只有间接证据（正文里活着 strong）。
       *   万一它把 <strong> 标签剥掉，只要属性还在，落地结果就与 v2.6.8 的
       *   span[style][textstyle] 完全等价 —— 不允许出现「换了载体反而更差」。
       *   到这一步所有声明都过了 SEM_DECL_OK 白名单（semTagForCtx 已筛），
       *   所以可以整条照写。
       */
      try { el.setAttribute('textstyle', full); } catch (e0) {}
      return el;
    } catch (e) { return null; }
  }

  // 用配方造包裹元素；配方不成立 → 回退成 <span style>（保持上一版行为，不倒退）
  function mkWrapEl(ctx, doc, css) {
    // ★ v2.5 语义载体优先（加粗一类）：见上面 semWrapFor 的大段注释
    var semEl = semWrapFor(ctx, doc, css);
    if (semEl) return semEl;
    var rec = pmRecipe(ctx, css);
    if (rec && rec.ok && rec.tag) {
      try {
        var el = doc.createElement(rec.tag);
        for (var k in rec.attrs) { try { el.setAttribute(k, rec.attrs[k]); } catch (e) {} }
        if (!el.getAttribute('style')) { try { el.setAttribute('style', norm(css)); } catch (e) {} }
        return el;
      } catch (e) {}
    }
    var sp = doc.createElement('span');
    sp.setAttribute('style', norm(css));
    return sp;
  }

  /*
   * 「直连载体」（v2.4）—— 不经过 schema 推导、也不经过 judgeShell 判定，
   * 直接造一个能带**整条 style** 的行内载体。
   *   外壳形态不是猜的：装置实测里那条取胜的候选给出的正是
   *   `<a href="#" style="整条配方">`（回读 {"href":"#","style":"display:inline-block;…"}）。
   *   为什么要绕过判定：现场报告里徽标 / 标签 / 橙高亮 / 行内代码 / 键盘键**全部**走到
   *   降级档，而同一份代码在装置里是「能生效」⇒ 说明「靠 schema 推导 + 回读判定」
   *   这条链路在真机上没走通。既然成败不能押在它身上，就在它判降级时改走直连。
   *   仅用于「形状声明」场景；纯文字样式（加粗 / 字色）仍走精确档 ——
   *   否则加粗会被做成一条无意义的链接（v2.2 分档要防的正是这个）。
   */
  function mkWrapElDirect(ctx, doc, css) {
    /*
     * ★ v2.5.2：直连载体不再一上来就硬造 <a href="#">。
     *   现场：写进去的 <a href="#" style="整条配方"> 被编辑器归并成 <span>
     *   （本机 link 标记只对**真链接**产出 <a>：写出物带 linktype / data-linktype，
     *    href="#" 被它的 parser 当无意义链接接下）⇒ display / padding / border /
     *   border-radius 全丢 ⇒ 一保存样式就没了。
     *
     *   修法：**先问配方** —— 它推导出的写法（rec.ok 为真）是经过它自己
     *   getAttrs 审计的，带着 linktype 一类必需属性，能真正被接纳；
     *   配方不成立时才退回硬造 <a href="#">（行为与旧版一致，不更差）。
     */
    var rec = null;
    try { rec = ctx ? pmRecipe(ctx, css) : null; } catch (e0) { rec = null; }
    if (rec && rec.ok && rec.tag) {
      try {
        var el = doc.createElement(rec.tag);
        for (var k in rec.attrs) { try { el.setAttribute(k, rec.attrs[k]); } catch (e1) {} }
        if (!el.getAttribute('style')) { try { el.setAttribute('style', norm(css)); } catch (e2) {} }
        return el;
      } catch (e3) {}
    }
    var a = doc.createElement('a');
    try {
      a.setAttribute('href', safeHref());   // ★ v2.6.3：'#' 会被保存清洗层归并，给真链接形状
      a.setAttribute('style', norm(css));
    } catch (e) {}
    return a;
  }

  /*
   * 把一段 css 落到**已有**元素上 —— 关键在「同步」：

   * 配方给出的属性（如 textstyle）必须跟着 style 一起改。只删 style 会让
   * textstyle 残留，编辑器读回来的还是旧样式 —— 表现就是「再点一次取消不掉」。
   */
  function applyCssToEl(ctx, el, css) {
    if (!el) return;
    var full = cssOf(declsOf(css));
    /*
     * v2.5：语义载体（<strong> 一类）**只改 style**。
     *   它靠标签本身表达语义，给它挂 textstyle 一类的自定义属性只会让编辑器
     *   多解析出一个标记来（同一段字的样式被拆成两份），而且那份属性在手机端没用。
     */
    if (isSemanticCarrier(el)) { try { el.setAttribute('style', full); } catch (e0) {} return; }
    var rec = pmRecipe(ctx, full);
    if (rec && rec.ok && rec.attrs) {
      var keep = { style: 1 }, k;
      for (k in rec.attrs) { keep[k] = 1; try { el.setAttribute(k, rec.attrs[k]); } catch (e) {} }
      // 清掉本配方不再需要的「自定义样式属性」—— 见 recipeAttrNames 的注释
      var ours = recipeAttrNames(ctx);
      for (var i = 0; i < ours.length; i++) {
        if (!keep[ours[i]]) { try { if (el.hasAttribute(ours[i])) el.removeAttribute(ours[i]); } catch (e) {} }
      }
    }
    try { el.setAttribute('style', full); } catch (e) {}
  }

  // 从 css 里剔掉若干声明（纯函数，不碰 DOM）
  function stripCss(css, drop) {
    var d = declsOf(drop), src = declsOf(css), out = {};
    for (var k in src) { if (!Object.prototype.hasOwnProperty.call(d, k)) out[k] = src[k]; }
    return cssOf(out);
  }

  /*
   * 报告用：遍历全部行内样式，给出「能生效 / 不能生效」汇总 + 逐条取证。
   * 三条口径（用户最需要知道的正是「哪些按钮能用、哪些不能用、为什么」）：
   *   OK  完整生效 —— 脚本用「编辑器自己的写法」通过了它自己的解析器
   *   ◆   降级生效 —— 编辑器承载不了全部声明，按它能承载的部分写（括号里是被丢掉的）
   *   X   无法生效 —— schema 里没有能承载这些声明的标记，下面带**取证步骤**
   *      （v1.8 这里只印结论、把 rec.why 丢掉了，于是现场报告看不出断在哪一步，
   *        只能再要一轮现场数据 —— 这是本轮改动最要紧的一条教训。）
   */
  function shellLineOf(rec) {
    if (!rec || !rec.tag) return '（无写法）';
    var a = [];
    for (var k in rec.attrs) a.push(k + '="' + String(rec.attrs[k]).slice(0, 90) + '"');
    return '<' + rec.tag + (a.length ? ' ' + a.join(' ') : '') + '>';
  }

  function recipeLines(ctx) {
    var yes = [], part = [], no = [], detail = [];
    for (var key in STYLES) {
      var st = STYLES[key];
      if (!st || st.g !== 'inline') continue;
      var lbl = st.label || key;
      var eff = effectiveCss(ctx, st);
      if (!eff.blocked && !eff.partial) {
        yes.push(lbl);
        detail.push('   OK  ' + lbl + '　标记 ' + ((eff.rec && eff.rec.mark) || '?')
          + '　策略=' + ((eff.rec && eff.rec.readVia) || '?')
          + ((eff.rec && eff.rec.attached) ? '（挂到宿主文档才读到）' : '')
          + '　校验=' + ((eff.rec && eff.rec.strict) ? '严格' : '宽松')
          + ((eff.rec && eff.rec.ready) ? '　回读=' + JSON.stringify(eff.rec.ready).slice(0, 110) : ''));
        detail.push('       → 该写：' + shellLineOf(eff.rec));
      } else if (!eff.blocked) {
        yes.push(lbl);
        part.push(lbl);
        detail.push('   ◆   ' + lbl + '　降级生效（编辑器承载不了 ' + (eff.dropped.join('、') || '—') + '）');
        detail.push('       → 该写：' + shellLineOf(eff.rec) + '　实际样式：' + eff.css);
        /*
         * ★ v2.4 补证：降级行必须带上「完整档为什么不成立」+ 载体开关状态 + 试过的候选。
         *   老版本只印结论，现场只能看到「降级了」，看不出卡在哪个标记、哪一级候选，
         *   于是必须再要一轮现场报告 —— 本轮徽标问题就是被这条拖了一轮。
         *   pmRecipe 有缓存（RECIPES），这里重新取一次几乎没有开销。
         */
        var raw = null;
        try { raw = pmRecipe(ctx, st.css); } catch (e0) { raw = null; }
        detail.push('       · 完整档：' + (raw && raw.ok ? '成立' : ((raw && raw.why) || '未能计算'))
          + '　行内小件载体开关 carryLink=' + (carryLinkOn() ? '开' : '关'));
        var rt = (raw && raw.trace) || [];
        for (var t1 = 0; t1 < rt.length && t1 < 6; t1++) detail.push('       ' + rt[t1]);
      } else {
        no.push(lbl);
        detail.push('   X   ' + lbl + '　' + ((eff.rec && eff.rec.why) || '编辑器里没有能承载它的标记'));
        var tr = (eff.rec && eff.rec.trace) || [];
        for (var t = 0; t < tr.length && t < 4; t++) detail.push('       ' + tr[t]);
      }
    }
    var L = [];
    L.push('   ★ 在这个版本的编辑器里【能生效】的行内按钮（' + yes.length + ' 个）：' + (yes.join('、') || '无'));
    if (part.length) {
      L.push('     其中【降级生效】的（' + part.length + ' 个）：' + part.join('、')
        + '　（括号里的声明编辑器不支持，已按它支持的部分应用）');
    }
    L.push('   ✗ 【不能生效】的（' + no.length + ' 个）：' + (no.join('、') || '无'));
    L.push('   —— 能生效＝脚本用编辑器自己的写法通过了它自己的解析器（getAttrs 读得回＝写进去会被接纳）。');
    L.push('   —— 降级生效＝退让到它能承载的子集；不能生效＝schema 里没有能承载这些声明的标记。');
    L.push('   —— 逐条取证（标记＝用哪个标记；策略＝配方怎么得到的；校验＝回读值是否与目标逐条等价）：');
    for (var i = 0; i < detail.length; i++) L.push(detail[i]);
    return L;
  }

  function envReport() {
    var L = [];
    L.push('【窗口】' + (window.top === window.self ? '顶层窗口（正常）' : '子框架（脚本不该在这里跑）')
      + '　readyState=' + document.readyState);

    var frames;
    try { frames = document.querySelectorAll('iframe'); } catch (e) { frames = []; }
    L.push('【iframe】主文档内共 ' + frames.length + ' 个');
    for (var i = 0; i < frames.length; i++) {
      var f = frames[i], d = null, cross = '';
      try { d = f.contentDocument; } catch (e) { d = null; cross = '　※跨域读不到'; }
      var vis = '?';
      try { var st = window.getComputedStyle(f); vis = (st.display === 'none' || st.visibility === 'hidden') ? '隐藏' : '可见'; } catch (e) {}
      var ces = '-', txt = '-';
      if (d && d.body) {
        try { ces = d.querySelectorAll(EDITABLE_SEL).length; } catch (e) {}
        try { txt = String(d.body.innerText || '').replace(/\s+/g, '').length; } catch (e) {}
      }
      var nm = '#' + (f.id || '(无id)');
      if (f.className && typeof f.className === 'string') nm += '.' + f.className.split(/\s+/)[0];
      L.push('   ' + nm + '　' + Math.round(boxArea(f)) + 'px²　' + vis
        + '　内部可编辑 ' + ces + ' 个　内部文本 ' + txt + ' 字' + cross);
    }

    var list = [];
    try { list = document.querySelectorAll('[contenteditable]'); } catch (e) { list = []; }
    L.push('【主文档 contenteditable】共 ' + list.length + ' 个');
    if (!list.length) L.push('   （无）');
    for (var j = 0; j < list.length && j < 12; j++) {
      var el = list[j];
      var nm2 = '<' + String(el.tagName || '?').toLowerCase() + '>#' + (el.id || '(无id)');
      if (el.className && typeof el.className === 'string') nm2 += '.' + el.className.split(/\s+/)[0];
      var v2 = '?';
      try { var s2 = window.getComputedStyle(el); v2 = (s2.display === 'none' || s2.visibility === 'hidden') ? '隐藏' : '可见'; } catch (e) {}
      L.push('   ' + nm2 + '　可编辑=' + (el.isContentEditable ? '真' : '假')
        + '　' + Math.round(boxArea(el)) + 'px²　' + v2
        + '　子元素 ' + (el.children ? el.children.length : 0) + ' 个'
        + '　文本 ' + String(el.innerText || '').replace(/\s+/g, '').length + ' 字');
    }

    var U = null;
    try { U = window.UE; } catch (e) { U = null; }
    var uinfo = '未检出 window.UE';
    if (U) {
      var ks = [];
      try { for (var k in U.instants) ks.push(k); } catch (e) {}
      uinfo = '版本 ' + (U.version || '?') + '　实例 ' + ks.length + ' 个'
        + (ks.length ? '（' + ks.join(',') + '）' : '');
      if (U.getEditor && ks.length) {
        try {
          var e0 = U.getEditor(ks[0]);
          if (e0) {
            var bd = e0.body;
            uinfo += '　body=' + (bd ? ('<' + String(bd.tagName || '?').toLowerCase() + '>' + (bd.id ? '#' + bd.id : '')) : '无');
            try { uinfo += '　编辑器内文本 ' + String(e0.getContent ? (e0.getContent() || '') : '').replace(/<[^>]*>/g, '').replace(/\s+/g, '').length + ' 字'; } catch (e) {}
          }
        } catch (e) {}
      }
    }
    L.push('【UEditor】' + uinfo);

    // 受控编辑器检出 —— 微信新版编辑器（type=77）走这条线，不再是 UEditor
    var pmAny = null;
    try {
      var ceAll = document.querySelectorAll('.ProseMirror, [contenteditable]');
      for (var z = 0; z < ceAll.length; z++) { if (ceAll[z].pmViewDesc) { pmAny = ceAll[z]; break; } }
    } catch (e) {}
    L.push('【受控编辑器】' + (pmAny
      ? ('检出 ProseMirror　宿主=div.' + String(pmAny.className || '').split(/\s+/)[0]
        + '　schema ' + (pmSchemaOf(pmAny) ? '可读' : '读不到'))
      : '未检出（当前编辑器不是 ProseMirror）'));

    return L;
  }

  // 某个上下文里「当前活的选区」，且必须落在该上下文的 root 内
  function liveRange(ctx) {
    if (!ctx) return null;
    var sel = null;
    try { sel = ctx.win.getSelection(); } catch (e) { return null; }
    if (!sel || sel.rangeCount === 0) return null;
    var r = sel.getRangeAt(0);
    var anc = r.commonAncestorContainer;
    if (anc !== ctx.root && !ctx.root.contains(anc)) return null;
    return r;
  }

  function applySel(ctx, range) {
    if (!ctx || !range) return;
    try {
      if (ctx.frame) { try { ctx.win.focus(); } catch (e) {} }
      var sel = ctx.win.getSelection();
      sel.removeAllRanges();
      sel.addRange(range);
      if (!ctx.frame) { try { ctx.win.focus(); } catch (e) {} }
      savePts(range, true, ctx);   // 程序化设完选区，同步刷新「快照 + 光标」，供下一次点击使用
    } catch (e) {}
  }

  /* ══════════════════════════════════════════════════════════════════
   * 3c. 操作流水（trace） + 宿主同步（notifyEdit）
   *
   *   为什么要有这一层：「改动到底有没有落进编辑器」不能靠人眼看截图。
   *   每次点击都记一条流水（定位到谁 / 有没有产生改动 / 有没有被宿主回滚），
   *   红点诊断会把最近若干条原样显示出来 —— 反馈一次就能钉死卡在哪一环。
   *
   *   notifyEdit 解决另一半问题：直接改 DOM 之后宿主编辑器（UEditor）并不知道
   *   内容变了，草稿自动保存、正文字数都可能还是旧值。补上 input 事件 +
   *   它自己的 sync()/contentchange，宿主才会认这笔账。
   * ══════════════════════════════════════════════════════════════════ */

  var TRACE = [];

  function trace(kind, msg) {
    var rec = { t: new Date(), kind: kind, msg: String(msg).slice(0, 200) };
    TRACE.push(rec);
    while (TRACE.length > 40) TRACE.shift();
    try { if (window.console && console.log) console.log('[排版助手]', kind, rec.msg); } catch (e) {}
    return rec;
  }

  function two(n) { return (n < 10 ? '0' : '') + n; }

  function traceText() {
    return TRACE.map(function (r) {
      var d = r.t;
      return two(d.getHours()) + ':' + two(d.getMinutes()) + ':' + two(d.getSeconds())
        + '  ' + r.kind + '  ' + r.msg;
    });
  }

  // 通知宿主编辑器「内容变了」—— 少这一步，草稿里的正文可能还是旧的
  function notifyEdit(ctx) {
    if (!ctx || !ctx.root) return;
    try { ctx.root.dispatchEvent(new Event('input', { bubbles: true, cancelable: false })); } catch (e) {}
    try { ctx.root.dispatchEvent(new Event('change', { bubbles: true })); } catch (e) {}
    // UEditor：把 iframe body 的内容同步回它自己的 textarea，并广播 contentchange
    try {
      var U = window.UE || (ctx.win && ctx.win.UE);
      if (U && U.instants) {
        for (var k in U.instants) {
          var ed = U.instants[k];
          if (!ed || ed.body !== ctx.root) continue;
          if (typeof ed.sync === 'function') ed.sync();
          if (typeof ed.fireEvent === 'function') ed.fireEvent('contentchange');
          break;
        }
      }
    } catch (e) {}
  }

  /* ══════════════════════════════════════════════════════════════════
   * 3b. 选区快照 —— 「选中文字后点按钮」不丢选区的真正保障
   *
   *   点击工具栏按钮 / 字体下拉时，编辑器一定失焦（哪怕按钮上写了
   *   mousedown.preventDefault，下拉框这种原生控件也拦不住焦点转移），
   *   此刻现场 getSelection() 往往只剩一个塌陷光标 —— 于是所有行内样式
   *   都被误判成「没选中文字」。老版本正是栽在这里。
   *
   *   对策：在用户「刚松手」的瞬间（selectionchange / mouseup / keyup）
   *   就把选区固化成点对存起来。点按钮时按优先级取：
   *     ① 现场的非折叠选区   ② 快照里的非折叠选区   ③ 现场光标（仅块级操作可用）
   *
   *   存点对（node + offset）而不是 Range 对象：Range 是「活」的，DOM 一变
   *   它自己就漂移；点对每次重建，配合 isConnected 校验，行为完全可预期。
   * ══════════════════════════════════════════════════════════════════ */

  var SNAP = { sc: null, so: 0, ec: null, eo: 0, t: 0 };   // 只记「非折叠」选区（要用来包样式）
  var CUR = { c: null, o: 0, t: 0 };                       // 只记最近一次「现场光标」（塌陷也算）
  /*
   * ★ v1.9 追加：除节点引用外，另存一份「正文文本字符偏移」。
   *   原因见 rangeFromSnap —— 受控编辑器会整棵重渲染，节点引用必然作废。
   */
  SNAP.s = -1; SNAP.e = -1; SNAP.offRoot = null; SNAP.sample = '';
  CUR.off = -1; CUR.offRoot = null;
  function snapPtsValid() {
    var a = SNAP.sc, b = SNAP.ec;
    if (!a || !b) return false;
    if (!a.isConnected || !b.isConnected) return false;
    if (!a.nodeValue || !b.nodeValue) return false;
    if (SNAP.so > a.nodeValue.length || SNAP.eo > b.nodeValue.length) return false;
    return !(a === b && SNAP.so === SNAP.eo);
  }

  function curValid() {
    return !!(CUR.c && CUR.c.isConnected && CUR.c.nodeValue && CUR.o <= CUR.c.nodeValue.length);
  }

  /* ══════════════════════════════════════════════════════════════════
   * 3b·1 快照的「抗重渲染」表示：正文文本字符偏移
   *
   * 受控编辑器（ProseMirror 一类）在我们改完 DOM 后，会拿自己那份 doc
   * 把整棵子树**重渲染**一遍 —— 于是 SNAP / CUR 里存的节点引用全部脱线
   * （isConnected === false），快照作废。现场症状就是：
   *   第一次点样式生效，**第二次点同一个按钮却提示「请先选中文字」**，
   *   因为「取消」要靠快照重建选区，而快照已经指向一堆被换掉的旧节点。
   *
   * 出路：除节点引用外，再存一份**相对正文根的文本字符偏移**。
   * 加样式不会改动文字 ⇒ 偏移跨任意次重渲染依然成立；
   * 需要时按偏移反查回（文本节点 + 段内偏移），选区就回来了。
   * 万不得已文字被动过，再用选中文字样张就近纠偏。
   * ══════════════════════════════════════════════════════════════════ */

  function textNodesOf(root) {
    var out = [];
    if (!root) return out;
    try {
      var doc = root.ownerDocument || document;
      var w = doc.createTreeWalker(root, NodeFilter.SHOW_TEXT, null, false), n;
      while ((n = w.nextNode())) out.push(n);
    } catch (e) {}
    return out;
  }

  // 「节点 + 偏移」→「正文根内的字符偏移」；算不出返回 -1
  function offsetOf(root, node, off) {
    if (!root || !node) return -1;
    var list = textNodesOf(root);
    /* 超长正文不做：本函数挂在每次 selectionchange 上，不能没有上限。
     * 跳过只是退回「只有节点引用」的旧行为，不会更差。 */
    if (!list.length || list.length > 1200) return -1;
    if (node.nodeType === 3 && node.nodeValue == null) return -1;
    var doc = root.ownerDocument || document;
    try {
      var p = doc.createRange();
      if (node.nodeType === 3) p.setStart(node, Math.max(0, Math.min(off, node.nodeValue.length)));
      else p.setStart(node, Math.max(0, Math.min(off, node.childNodes.length)));
      var acc = 0;
      for (var i = 0; i < list.length; i++) {
        var t = list[i];
        if (t === node) return acc + Math.max(0, Math.min(off, t.nodeValue.length));
        var r = doc.createRange();
        r.selectNodeContents(t);
        /* 0 === Range.START_TO_START，用数字常量免得跨 frame 取不到 Range 构造器 */
        if (p.compareBoundaryPoints(0, r) > 0) acc += t.nodeValue.length;
        else break;                       // 已到该文字之后，后面的更靠后
      }
      return acc;
    } catch (e) { return -1; }
  }

  // 「正文根内的字符偏移」→「节点 + 偏移」；超界夹到末尾
  function ptAtOffset(root, off) {
    var list = textNodesOf(root);
    if (!list.length) return null;
    var acc = 0;
    for (var i = 0; i < list.length; i++) {
      var t = list[i], len = t.nodeValue.length;
      if (off <= acc + len) return { n: t, o: Math.max(0, off - acc) };
      acc += len;
    }
    var last = list[list.length - 1];
    return { n: last, o: last.nodeValue.length };
  }

  // 快照的「偏移表示」能不能用（节点引用脱线时的唯一出路）
  function snapOffValid(ctx) {
    if (!ctx || !ctx.root) return false;
    if (SNAP.s == null || SNAP.e == null || SNAP.s < 0 || SNAP.e < 0) return false;
    if (SNAP.e <= SNAP.s) return false;
    if (SNAP.offRoot && SNAP.offRoot !== ctx.root) return false;
    try { return SNAP.e <= String(ctx.root.textContent || '').length; } catch (e) { return false; }
  }

  function curOffValid(ctx) {
    if (!ctx || !ctx.root) return false;
    if (CUR.off == null || CUR.off < 0) return false;
    if (CUR.offRoot && CUR.offRoot !== ctx.root) return false;
    try { return CUR.off <= String(ctx.root.textContent || '').length; } catch (e) { return false; }
  }

  // 在正文里找 sample 出现的位置，取离 from 最近的一处（避免落到重复的段落上）
  function locateSample(ctx, sample, from) {
    try {
      var full = String(ctx.root.textContent || '');
      if (!sample || !full) return -1;
      var best = -1, at = 0, k;
      while (true) {
        k = full.indexOf(sample, at);
        if (k < 0) break;
        if (best < 0 || Math.abs(k - from) < Math.abs(best - from)) best = k;
        at = k + 1;
      }
      return best;
    } catch (e) { return -1; }
  }

  // 按文本偏移重建 Range；样张对不上就就近纠偏
  function rangeByOffsets(ctx, from, to, sample) {
    try {
      var a = ptAtOffset(ctx.root, from), b = ptAtOffset(ctx.root, to);
      if (!a || !b) return null;
      var r = ctx.doc.createRange();
      r.setStart(a.n, a.o);
      r.setEnd(b.n, b.o);
      if (r.collapsed) return null;
      var want = String(sample || ''), got = '';
      try { got = String(r.toString()); } catch (e) { got = ''; }
      if (want && got.indexOf(want) !== 0) {
        var loc = locateSample(ctx, want, from);
        if (loc >= 0) {
          var a2 = ptAtOffset(ctx.root, loc), b2 = ptAtOffset(ctx.root, loc + want.length);
          if (a2 && b2) {
            var r2 = ctx.doc.createRange();
            r2.setStart(a2.n, a2.o);
            r2.setEnd(b2.n, b2.o);
            if (!r2.collapsed) {
              trace('snap', '快照按文本偏移找回（就近纠偏 ' + from + '→' + loc + '）');
              return r2;
            }
          }
        }
        trace('snap', '快照按文本偏移找回，但文字已变'
          + '（原=' + JSON.stringify(want.slice(0, 12)) + ' 现=' + JSON.stringify(got.slice(0, 12)) + '）');
      } else {
        trace('snap', '快照按文本偏移找回 · ' + JSON.stringify(got.slice(0, 16)));
      }
      return r;
    } catch (e) { return null; }
  }

  function savePts(r, keepCaret, ctx) {
    if (!r) return false;
    if (isOurNode(nodeOf(r.startContainer)) || isOurNode(nodeOf(r.endContainer))) return false;
    var root = (ctx && ctx.root) || null;
    if (r.collapsed) {
      if (keepCaret) {
        CUR.c = r.startContainer; CUR.o = r.startOffset; CUR.t = Date.now();
        CUR.off = root ? offsetOf(root, r.startContainer, r.startOffset) : -1;
        CUR.offRoot = root;
      }
      return false;
    }
    SNAP.sc = r.startContainer; SNAP.so = r.startOffset;
    SNAP.ec = r.endContainer; SNAP.eo = r.endOffset;
    SNAP.t = Date.now();
    /* 节点引用 + 文本偏移，两份都存：前者精确，后者抗重渲染（见 rangeFromSnap） */
    SNAP.s = root ? offsetOf(root, SNAP.sc, SNAP.so) : -1;
    SNAP.e = root ? offsetOf(root, SNAP.ec, SNAP.eo) : -1;
    SNAP.offRoot = root;
    try { SNAP.sample = String(r.toString()).slice(0, 24); } catch (e) { SNAP.sample = ''; }
    return true;
  }

  function snapSel() {
    var ctx = (ECTX && aliveCtx(ECTX)) ? ECTX : null;
    if (ctx) { if (savePts(liveRange(ctx), true, ctx)) return true; }
    /*
     * 缓存里那个上下文没有真选区时，重新扫一遍。
     * 注意这里要遍历**所有**候选而不是只取最高分那个：快照的价值就是
     * 「哪怕定位还没反应过来，也先把选区留下来」，所以广撒网、见谁有真选区就存谁。
     * 但这些「非首选文档」里出现的塌陷光标不能记（keepCaret=false）——
     * 否则正文外的某个输入框一点，就会把正文里的光标覆盖掉。
     */
    var docs = collectDocs();
    for (var i = 0; i < docs.length; i++) {
      var d = docs[i], roots = [], list = null;
      try { list = d.doc.querySelectorAll(EDITABLE_SEL); } catch (e) { list = null; }
      if (list) { for (var j = 0; j < list.length; j++) roots.push(list[j]); }
      var b = d.doc.body;
      if (b && b.isContentEditable && roots.indexOf(b) < 0) roots.push(b);
      for (var k = 0; k < roots.length; k++) {
        var c2 = { doc: d.doc, win: d.win, root: roots[k], frame: d.frame };
        if (savePts(liveRange(c2), false, c2)) return true;
      }
    }
    return false;
  }

  // 节点是否属于某个 root（连同所属文档一起核对 —— 跨文档的节点永远不算数）
  function inRootOf(n, root) {
    if (!n || !root) return false;
    if (n.ownerDocument !== (root.ownerDocument || root)) return false;
    return n === root || root.contains(n);
  }

  function rangeFromSnap(ctx) {
    /*
     * ① 首选「节点引用」这条路 —— 它最精确，嵌套标记里也不会偏。
     *    快照必须属于**当前这个上下文**才能用。少了这一步，快照会跨上下文
     *    「串门」：上下文认成了主文档、快照却来自 iframe，于是拿着 iframe
     *    的坐标去主文档里找文字 —— 一个都找不到。
     */
    if (snapPtsValid() && inRootOf(SNAP.sc, ctx.root) && inRootOf(SNAP.ec, ctx.root)) {
      try {
        var r = ctx.doc.createRange();
        r.setStart(SNAP.sc, SNAP.so);
        r.setEnd(SNAP.ec, SNAP.eo);
        if (!r.collapsed) return r;
      } catch (e) {}
    }
    /*
     * ② ★ 节点引用作废时的兜底：按「文本偏移」反查。
     *    受控编辑器改完 DOM 会整棵重渲染，我们手里的节点全部脱线 ——
     *    这一条正是「点一次样式生效、再点一次却说没选中文字」的正解。
     */
    if (!snapOffValid(ctx)) return null;
    return rangeByOffsets(ctx, SNAP.s, SNAP.e, SNAP.sample);
  }  // 由「现场光标」重建的塌陷 Range（块级操作用）
  function rangeFromCur(ctx) {
    if (curValid() && inRootOf(CUR.c, ctx.root)) {
      try {
        var r = ctx.doc.createRange();
        r.setStart(CUR.c, CUR.o);
        r.collapse(true);
        return r;
      } catch (e) {}
    }
    // 节点引用被重渲染换掉时的兜底：按文本偏移反查（见 rangeFromSnap ②）
    if (!curOffValid(ctx)) return null;
    try {
      var p = ptAtOffset(ctx.root, CUR.off);
      if (!p) return null;
      var r2 = ctx.doc.createRange();
      r2.setStart(p.n, p.o);
      r2.collapse(true);
      return r2;
    } catch (e) { return null; }
  }  /*
   * 取「本次操作要用的」选区 —— 所有操作层入口统一走这里。
   *   needText = true  （行内样式 / 链接 / 字体）→ 只认非折叠选区，取不到返回 null
   *   needText = false （引用 / 列表 / 标题 / 换行）→ 塌陷光标也算，块级操作允许只放光标
   *
   * 优先级：
   *   现场非折叠 → 快照非折叠（点击工具栏可能让编辑器失焦、现场只剩光标）
   *   块级再加一条：若「刚点下的光标」比快照更近，听光标的（那才是用户当前意图）
   */
  function grabRange(needText) {
    var ctx = pickEditor();
    if (!ctx) return { ctx: null, range: null };

    var live = liveRange(ctx);
    if (live) savePts(live, true, ctx);

    if (live && !live.collapsed) return { ctx: ctx, range: live };

    var fromSnap = rangeFromSnap(ctx);

    if (!needText) {
      var curR = rangeFromCur(ctx);
      if (curR && (!fromSnap || CUR.t >= SNAP.t)) return { ctx: ctx, range: curR };
      if (fromSnap) return { ctx: ctx, range: fromSnap };
      if (live) return { ctx: ctx, range: live };
      return { ctx: ctx, range: null };
    }

    if (fromSnap) return { ctx: ctx, range: fromSnap };
    return { ctx: ctx, range: null };
  }

  // 挂「选区固化」监听。主文档与编辑器 iframe 文档各挂一份，命中即返回。
  function bindSelWatch(doc) {
    if (!doc || doc.__mptbSelWatch) return;
    doc.__mptbSelWatch = true;
    var h = function () { snapSel(); };
    doc.addEventListener('selectionchange', h, true);
    doc.addEventListener('mouseup', h, true);
    doc.addEventListener('keyup', h, true);
  }

  /* ══════════════════════════════════════════════════════════════════
   * 4. 文本 run 收集与包裹
   *    —— 一个 run ＝「同一文本节点里的一截」。按节点去重，保证各 run 互不干扰。
   * ══════════════════════════════════════════════════════════════════ */

  function collectRuns(range, ctx) {
    var doc = ctx.doc;
    var sc = range.startContainer, so = range.startOffset;
    var ec = range.endContainer, eo = range.endOffset;

    if (sc === ec && sc.nodeType === 3) {
      return so === eo ? [] : [{ node: sc, s: so, e: eo }];
    }
    if (sc === ec) return [];

    var runs = [];
    var walker = doc.createTreeWalker(ctx.root, NodeFilter.SHOW_TEXT, null, false);
    var n;
    while ((n = walker.nextNode())) {
      var pn = n.parentNode;
      if (pn && pn.closest && (pn.closest('#mptb-bar') || pn.closest('#mptb-dlg'))) continue;
      if (!n.nodeValue || !n.nodeValue.length) continue;
      if (!range.intersectsNode(n)) continue;

      var s = (n === sc) ? so : 0;
      var e = (n === ec) ? eo : n.nodeValue.length;
      if (s < 0) s = 0;
      if (e > n.nodeValue.length) e = n.nodeValue.length;
      if (s < e) runs.push({ node: n, s: s, e: e });
      if (n === ec) break;
    }
    return runs;
  }

  // 把 run 精确切成独立文本节点，返回该节点
  function isolateRun(run) {
    var node = run.node, s = run.s, e = run.e;
    var target = node;
    if (s > 0 || e < node.nodeValue.length) {
      if (s > 0) { target = node.splitText(s); e = e - s; }
      if (e < target.nodeValue.length) target.splitText(e);
    }
    return target;
  }

  // 包裹（或强化）单个 run。已有纯样式 span 宿主时直接合并，避免嵌套膨胀。
  function wrapRun(run, css) {
    var target = isolateRun(run);
    var doc = target.ownerDocument;
    var p = target.parentNode;
    if (p && isPureStyleSpan(p)) { mergeStyle(p, css); return p; }
    var sp = doc.createElement('span');
    sp.setAttribute('style', norm(css));
    p.insertBefore(sp, target);
    sp.appendChild(target);
    return sp;
  }

  // 向上找最近的纯样式 span 宿主（可跨多层）
  function hostOf(node) {
    var p = node && node.parentNode;
    // v2.2：行内小件由 <a> 承载，宿主查找必须一并认它，否则「再点一次取消」
    // 的判据（runsAllHave → hostOf）永远返回 null，取消就永远不成立。
    while (p && p.nodeType === 1
           && (p.tagName === 'SPAN' || p.tagName === 'A' || isSemanticCarrier(p))) {
      if (isPureStyleSpan(p)) return p;
      p = p.parentNode;
    }
    return null;
  }

  // 选区里是否「全部」都已带该样式 —— 决定这次点击是应用还是取消
  function runsAllHave(runs, css) {
    if (!runs.length) return false;
    for (var i = 0; i < runs.length; i++) {
      var h = hostOf(runs[i].node);
      if (!h || !elHasCss(h, css)) return false;
    }
    return true;
  }

  /* ══════════════════════════════════════════════════════════════════
   * 5. 块级定位
   * ══════════════════════════════════════════════════════════════════ */

  var BLOCK_TAGS = {
    P: 1, DIV: 1, SECTION: 1, ARTICLE: 1, HEADER: 1, FOOTER: 1,
    H1: 1, H2: 1, H3: 1, H4: 1, H5: 1, H6: 1,
    LI: 1, BLOCKQUOTE: 1, PRE: 1, FIGURE: 1, TABLE: 1, UL: 1, OL: 1
  };

  function isBlockEl(el, root) {
    if (!el || el.nodeType !== 1) return false;
    if (el === root) return false;
    return !!BLOCK_TAGS[el.tagName];
  }

  function firstBlock(node, root) {
    var p = node && (node.nodeType === 1 ? node : node.parentNode);
    while (p && p !== root) {
      if (isBlockEl(p, root)) return p;
      p = p.parentNode;
    }
    return null;
  }

  function topLevel(el, root) {
    var p = el;
    while (p && p.parentNode && p.parentNode !== root) p = p.parentNode;
    return p;
  }

  // 选区「碰到」的所有同级块（半行也算整段，符合块级样式的直觉）
  function selectedBlocks(range, ctx) {
    var root = ctx.root;
    var sb = firstBlock(range.startContainer, root);
    var eb = firstBlock(range.endContainer, root);
    if (!sb || !eb) return [];
    var st = topLevel(sb, root), et = topLevel(eb, root);
    if (!st || !et) return [];

    var kids = [];
    for (var i = 0; i < root.childNodes.length; i++) {
      if (root.childNodes[i].nodeType === 1) kids.push(root.childNodes[i]);
    }
    var i1 = kids.indexOf(st), i2 = kids.indexOf(et);
    if (i1 < 0 || i2 < 0) return [];
    if (i1 > i2) { var t = i1; i1 = i2; i2 = t; }
    return kids.slice(i1, i2 + 1);
  }

  // 按「同一父级 + 连续相邻」分组，避免把跨容器的块硬凑成一个引用块
  function groupByParent(blocks) {
    var groups = [];
    for (var i = 0; i < blocks.length; i++) {
      var b = blocks[i];
      var g = groups[groups.length - 1];
      if (g && g.parent === b.parentNode && g.last === b.previousElementSibling) {
        g.items.push(b);
        g.last = b;
      } else {
        groups.push({ parent: b.parentNode, items: [b], last: b });
      }
    }
    return groups;
  }

  function isQuoteEl(el) {
    if (!el || el.nodeType !== 1) return false;
    var s = el.style;
    if (!s) return false;
    var hasBar = !!(s.borderLeftWidth && s.borderLeftStyle && s.borderLeftStyle !== 'none')
      && !!(s.backgroundColor || s.background);
    if (!hasBar) return false;
    return elHasCss(el, STYLES.q1.css) || elHasCss(el, STYLES.q2.css) || elHasCss(el, STYLES.q3.css)
      || (s.borderLeftWidth === '4px' && s.borderLeftStyle === 'solid');
  }

  function quoteAncestorOf(node, root) {
    var p = node && (node.nodeType === 1 ? node : node.parentNode);
    while (p && p !== root) {
      if (isQuoteEl(p)) return p;
      p = p.parentNode;
    }
    return null;
  }

  function elemKids(c) {
    var out = [];
    for (var i = 0; i < c.childNodes.length; i++) {
      if (c.childNodes[i].nodeType === 1) out.push(c.childNodes[i]);
    }
    return out;
  }

  function lastElemKid(c) {
    var ks = elemKids(c);
    return ks.length ? ks[ks.length - 1] : null;
  }

  function topLevelIn(el, container) {
    var p = el;
    while (p && p.parentNode && p.parentNode !== container) p = p.parentNode;
    return p;
  }

  function sliceBetween(container, a, b) {
    var ks = elemKids(container);
    var i1 = ks.indexOf(a), i2 = ks.indexOf(b);
    if (i1 < 0 || i2 < 0) return [];
    if (i1 > i2) { var t = i1; i1 = i2; i2 = t; }
    return ks.slice(i1, i2 + 1);
  }

  /*
   * 块级操作的「精确作用域」。
   *
   * 为什么不用 selectedBlocks（它取的是 root 的直接子级）：
   *   当光标落在引用块内部的某一段时，selectedBlocks 会返回**整个引用容器**，
   *   于是「在引用里加列表」就变成了「把整个引用块变成列表项」—— margin/padding 被
   *   覆盖，引用样式当场损坏。
   *   正确语义：块级样式应当作用在「光标所在那一层容器」的直接子块上。
   *      · 光标在普通段落里        → 容器 = root，目标 = 该段落（或跨选的多段）
   *      · 光标在引用块内的段落里  → 容器 = 引用块，目标 = 引用块内的段落
   *      · 光标直接落在引用容器上  → 容器 = 引用块，目标 = 其子块
   */
  function listScope(range, ctx) {
    var root = ctx.root;
    var sb = firstBlock(range.startContainer, root);
    var eb = firstBlock(range.endContainer, root);
    if (!sb || !eb) return null;

    var container, first, last;

    if (isQuoteEl(sb)) {
      container = sb;
      var ks = elemKids(container);
      if (!ks.length) return null;
      first = ks[0];
      last = (isQuoteEl(eb) && eb !== sb) ? lastElemKid(eb) : eb;
      if (!last || last.parentNode !== container) last = ks[ks.length - 1];
    } else {
      var q = quoteAncestorOf(sb, root);
      container = q || root;
      first = topLevelIn(sb, container);
      last = (eb === sb) ? first : topLevelIn(eb, container);
      if (!last || last.parentNode !== container) last = first;
    }

    if (!first || first.parentNode !== container) return null;
    return { container: container, first: first, last: last };
  }

  /* ══════════════════════════════════════════════════════════════════
   * 6. 撤销栈（innerHTML 快照）
   *    必须在操作「之前」调用 snapshot()，label 用于提示文案。
   * ══════════════════════════════════════════════════════════════════ */

  var undoStack = [];

  function snapshot(label) {
    var ctx = pickEditor();
    if (!ctx) return false;
    var html = ctx.root.innerHTML;
    var top = undoStack[undoStack.length - 1];
    if (top && top.html === html) return true;
    undoStack.push({ html: html, label: label || '', off: caretOffIn(ctx) });
    while (undoStack.length > UNDO_MAX) undoStack.shift();
    return true;
  }

  /* ── 「这一步操作开始前，光标在正文里的字符偏移」（v2.6.34）──────────
   *   撤销后要靠它把光标放回原处 —— 撤销是**整篇重建**，节点引用必然脱线，
   *   只有字符偏移还能用（加样式不改文字 ⇒ 偏移在重建前后同义）。
   *   优先现场选区；现场没有就退到最近一次光标 / 选区快照。算不出返回 -1。
   * ───────────────────────────────────────────────────────────────── */
  function caretOffIn(ctx) {
    if (!ctx || !ctx.root) return -1;
    try {
      var r = liveRange(ctx);
      if (r) {
        var o = offsetOf(ctx.root, r.startContainer, r.startOffset);
        if (o >= 0) return o;
      }
    } catch (e) {}
    if (CUR.off != null && CUR.off >= 0 && (!CUR.offRoot || CUR.offRoot === ctx.root)) return CUR.off;
    if (SNAP.s != null && SNAP.s >= 0 && (!SNAP.offRoot || SNAP.offRoot === ctx.root)) return SNAP.s;
    return -1;
  }

  /* 正文根最近的可滚动祖先（撤销后把滚动位置一并还原；找不到就用窗口滚动） */
  function scrollHostOf(root) {
    var p = root && root.parentNode;
    while (p && p.nodeType === 1) {
      try { if (p.scrollHeight > p.clientHeight + 2) return p; } catch (e) {}
      p = p.parentNode;
    }
    return null;
  }

  var UNDO_TOK = 0;

  function doUndo() {
    var ctx = pickEditor();
    if (!ctx) return;
    var s = undoStack.pop();
    if (!s) { toast('没有可撤销的操作了'); return; }
    var tok = ++UNDO_TOK;
    var sh = scrollHostOf(ctx.root), st0 = 0, wy0 = 0;
    if (sh) { try { st0 = sh.scrollTop; } catch (e1) {} }
    try { wy0 = ctx.win.pageYOffset || 0; } catch (e2) {}
    ctx.root.innerHTML = s.html;
    /*
     * ★ v2.6.34：撤销后必须把光标放回原处。
     *   上面那句是**整篇重建** —— 旧选区里的节点全部脱线，浏览器与受控编辑器
     *   都会把光标塌陷到**正文开头**，页面随即滚到顶部
     *   （用户现场：「按 Ctrl+Z 会自动跑到文章顶部」）。根因不是滚动，是**选区丢了**。
     *   放两次：同步一次（普通 contenteditable 当场就认），40ms 后再补一次 ——
     *   受控编辑器会在这之后重解析整篇并重置它的选区，只放一次会被它覆盖掉。
     *   两次都用 tok 守卫：期间又有新撤销 / 新操作 ⇒ 过期动作闭嘴，不许抢用户的光标。
     */
    var put = function (why) {
      if (tok !== UNDO_TOK) return false;
      if (s.off == null || s.off < 0) return false;
      var p = ptAtOffset(ctx.root, s.off);
      if (!p) return false;
      try {
        var r = ctx.doc.createRange();
        r.setStart(p.n, p.o);
        r.collapse(true);
        applySel(ctx, r);
      } catch (e3) { return false; }
      /* 设选区会让浏览器滚到选区处 —— 位置已正确，再把滚动还原成操作前的样子 */
      if (sh) { try { sh.scrollTop = st0; } catch (e4) {} }
      else { try { ctx.win.scrollTo(0, wy0); } catch (e5) {} }
      trace('undo', '光标归位（' + why + '）：偏移 ' + s.off);
      return true;
    };
    put('同步');
    setTimeout(function () { if (tok === UNDO_TOK) put('异步'); }, 40);
    toast((s.label ? ('已撤销：' + s.label) : '已撤销上一步')
      + ((s.off == null || s.off < 0) ? '　（这一步没记到光标位置）' : ''));
  }
  /* ══════════════════════════════════════════════════════════════════
   * 7. 操作层 —— 所有按钮最终都落到这里
   * ══════════════════════════════════════════════════════════════════ */

  function needCtx() {
    var ctx = pickEditor();
    if (!ctx) { trace('fail', '未定位到任何可编辑容器'); toast('没找到公众号编辑器，请先打开「图文素材 → 新建图文」页面'); return null; }
    return ctx;
  }

  /*
   * 所有操作的统一取参入口。
   *   needText = true  行内类：必须有非折叠选区，否则判定为「没选中文字」
   *   needText = false 块级类：塌陷光标也算有效（光标落在段落里即可操作）
   * 选区优先级（现场选区 > 快照）在 p2 的 grabRange 内实现，
   * 这里只负责把两种情况翻译成人话。
   *
   * 【v1.4】取参失败一律写进操作流水，并带上「认了哪个容器」——
   * 「点了没反应」这类反馈最难查的就是这一步，没有流水就只能靠猜。
   */
  function pick(needText, failMsg) {
    var g = grabRange(needText);
    if (!g.ctx) {
      trace('fail', '未定位到编辑器（needText=' + !!needText + '）');
      toast('没找到公众号编辑器，请先打开「图文素材 → 新建图文」页面');
      return null;
    }
    if (!g.range) {
      trace('fail', '无有效选区 · ' + ctxDesc(g.ctx) + ' · 现场=' + liveSelDesc(g.ctx)
        + ' · 快照=' + (SNAP.sc ? '有' : '无') + ' · needText=' + !!needText);
      toast(failMsg || '请先选中要处理的文字');
      return null;
    }
    trace('pick', ctxDesc(g.ctx) + ' · ' + (g.range.collapsed ? '光标' : '选中 ' + g.range.toString().length + ' 字'));
    return g;
  }

  // 现场选区的文字描述，只用于流水
  function liveSelDesc(ctx) {
    var r = liveRange(ctx);
    if (!r) return '无';
    return r.collapsed ? '光标' : ('选中 ' + r.toString().length + ' 字');
  }

  function ancestorTag(node, tag, root) {
    var p = node && (node.nodeType === 1 ? node : node.parentNode);
    while (p && p !== root) {
      if (p.tagName === tag) return p;
      p = p.parentNode;
    }
    return null;
  }

  // 遍历 root 的所有后代元素（先拍快照，避免遍历中 unwrap 打乱 TreeWalker）
  function walkEls(root, fn) {
    var doc = root.ownerDocument || document;
    var all = [], n;
    var w = doc.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, null, false);
    while ((n = w.nextNode())) all.push(n);
    for (var i = 0; i < all.length; i++) {
      if (all[i].isConnected) { try { fn(all[i]); } catch (e) {} }
    }
  }

  function selectNodes(ctx, nodes) {
    var first = null, last = null;
    for (var i = 0; i < nodes.length; i++) {
      if (nodes[i] && nodes[i].isConnected && nodes[i].nodeValue && nodes[i].nodeValue.length) { first = nodes[i]; break; }
    }
    for (var j = nodes.length - 1; j >= 0; j--) {
      if (nodes[j] && nodes[j].isConnected && nodes[j].nodeValue && nodes[j].nodeValue.length) { last = nodes[j]; break; }
    }
    if (!first || !last) return;
    try {
      var r = ctx.doc.createRange();
      r.setStart(first, 0);
      r.setEnd(last, last.nodeValue.length);
      applySel(ctx, r);
    } catch (e) {}
  }

  /*
   * 决定「这次到底写什么」—— 配方结果的落地口径，只有这一个出口。
   * 返回 { css, partial, dropped, rec, blocked }
   *   · 完整配方成立            → css = 原样式（partial=false）
   *   · 登记了降级写法且它成立  → 用降级写法，dropped = 原样式里没进去的声明
   *   · 否则用「能承载的子集」  → 同上
   *   · 都不行                  → blocked=true（按钮只告知、不写）
   * 非受控编辑器（老版 UEditor / 没有 ProseMirror）一律原样写，不做任何闸门。
   */
  function effectiveCss(ctx, st) {
    var base = { css: norm(st.css), partial: false, dropped: [], rec: null, blocked: false, full: false };
    if (!pmHostOf(ctx)) return base;
    var degrade = DEGRADE_DEFAULT;
    try { degrade = GMX.get('degrade', DEGRADE_DEFAULT) !== false; } catch (e) {}
    var rec = pmRecipe(ctx, st.css);
    base.rec = rec;
    // 配方**完整成立** ⇒ 标记为 full。上层据此判断「不需要再试宽载体」。
    if (rec && rec.ok) { base.full = true; return base; }
    if (!degrade) { base.blocked = true; return base; }
    if (st.fb) {
      var rf = pmRecipe(ctx, st.fb);
      if (rf && rf.ok) {
        base.css = norm(st.fb);
        base.partial = true;
        base.rec = rf;
        base.dropped = dropList(st.css, st.fb);
        return base;
      }
    }
    if (rec && rec.level === 'partial' && rec.part) {
      base.css = norm(rec.part.css);
      base.partial = true;
      base.rec = pmRecipe(ctx, rec.part.css);
      base.dropped = rec.part.drop || [];
      return base;
    }
    base.blocked = true;
    return base;
  }

  // 原样式里有哪些声明没进最终写法（报告与提示用）
  function dropList(full, eff) {
    var a = declsOf(full), b = declsOf(eff), out = [];
    for (var k in a) {
      if (!Object.prototype.hasOwnProperty.call(b, k)) out.push(k);
      else if (!valEq(a[k], b[k])) out.push(k);
    }
    return out;
  }

  /* ── 7.1 行内样式（可切换） ─────────────────────────────────────── */


  function applyInline(key) {
    var st = STYLES[key];
    if (!st) return;
    var mySeq = ++INLINE_SEQ;      // v2.5：本次操作的代际号（落地复查用，见 inlineTextCheck）
    var g = pick(true, '请先选中要加样式的文字，再点按钮');
    if (!g) return;
    var ctx = g.ctx, range = g.range;

    /*
     * 方言闸门（v1.9 起带降级档）—— 受控编辑器只吃它 schema 里有的写法，
     * 写别的会被它剥回去（用户看到的只是「点一下、闪一下、又变回来」）。
     *   ① 完整配方成立       → 照它的写法写，样式全保留；
     *   ② 只有部分声明能承载 → 按「它能承载的部分」写，并明确告知丢了什么；
     *   ③ 一条都承载不了     → 不写，只告知。
     * 降级可在脚本菜单里关掉（「切换降级模式」）。
     */
    var eff = effectiveCss(ctx, st);
    if (pmHostOf(ctx) && eff.blocked) {
      toast('微信这个版本的编辑器不支持「' + st.label + '」——点标题栏红点看「样式配方」');
      return;
    }
    var useCss = eff.css;

    /*
     * ★ v2.4 直连载体（现场修复）。
     *   条件三条同时成立才启用：① 样式含「形状声明」（display / padding / border* /
     *   border-radius）；② 配方判定只能降级（eff.full 为假）；③ 载体开关是开的。
     *   不满足②就不动手 —— 已经能完整生效的样式没有理由改道。
     *   载体开关关掉时**必须说出来**：静默降级会让用户以为脚本坏了。
     */
    var shapeNeed = wideDecls(st.css).length > 0;
    var directCarry = shapeNeed && !eff.full && carryLinkOn();
    if (shapeNeed && !eff.full && !carryLinkOn()) {
      trace('carry', st.label + ' · 需要整条 style 载体才能显示外框 / 内边距，'
        + '但「行内小件载体」当前是 span 扁平版（脚本菜单可切回）');
    }
    if (directCarry) useCss = norm(st.css);   // 直连时按**配方原文**写全，不写降级子集

    var runs = collectRuns(range, ctx);
    if (!runs.length) { toast('选区内没有可处理的文字（图片请用编辑器原生操作）'); return; }

    /*
     * 二次点击取消：拿**实际写入的那套 css** 判定，不能用原始 css ——
     * 降级后原始 css 永远不可能出现在内联样式里，否则「取消」永远判不成立。
     */
    var willRemove = runsAllHave(runs, useCss);

    /*
     * ★ 宽载体优先（v2.0）
     *   配方里若含「编辑器 schema 接不住、但投放白名单支持」的声明
     *   （border / border-radius / padding / display …），先试粘贴导入链路 ——
     *   那是宿主接纳**外部 HTML** 的通道，比「改 DOM 节点」宽。
     *   只有宿主确实接住了、并且事后验真通过，才采纳；否则原样退回配方节点替换。
     *
     *   ★ 判据和送进去的 HTML 都必须用**配方原文** `st.css`，不能用降级后的 eff.css：
     *     降级式本来就只剩 schema 能接住的那几个声明，拿它求差集恒为空 ——
     *     宽载体一次都触发不了，整条通道变成死代码（v2.0 第一版就栽在这）。
     *     差集要的是「配方**想要**什么」减「schema 能接什么」，不是「退让后要什么」。
     *
     *   这里刻意**不压自己的快照栈**：粘贴走的是宿主自己的通道，
     *   宿主自带撤销记录，重复压一层会让撤销按两次才回到原状。
     */
    /*
     * ★ 配方已完整成立时，**不再走宽载体**（v2.2）
     *   宽载体（合成 paste 导入）是「配方推不出写法」时的备用通道 ——
     *   它要动宿主的选区、失败后还得让用户重选，有实打实的代价。
     *   现在小件在精确档之外多了一档「整条 style 载体（<a>）」⇒ 配方本身就能完整落地，
     *   再让宽载体抢先，等于把一条走得通的路换成了碰运气的路。
     *   只有配方确实接不住（eff.full = false）时，才轮到它出场。
     */
    /*
     * ★ v2.5.1：宽载体（合成粘贴）默认不再出场 —— 见 p1 的 wideCarrierOn 注释。
     *   它的落点由**宿主自己的 selection** 决定、不由我们的选区决定；现场
     *   「开头自动多一份、预览后正文里的又全消失」正出在它身上。
     */
    /*
     * ★ v2.6.5：宽载体升为首选通道（不再等 eff.full=false）。
     *   真机三次验证：<a> 载体的 style 在保存链路上活不下来 ——
     *     href=";" 被清洗层当无意义链接归并 → mp.weixin.qq.com 被本域校验拦（弹黄条）
     *     → 外域 www.qq.com 过了校验但保存后外框仍消失（2026-09-20 16:18 用户复验）。
     *   而「span / strong + 整条 style」有真机样本背书：外部排版工具走宿主的
     *   HTML 导入（粘贴）链路产出这两种形态，保存后存活。
     *   两类需要它：
     *     ① 含差集声明（display / padding / border* / border-radius）的外框类小件；
     *     ② 纯文字样式但 schema 认不出对应语义标签 —— 加粗「编辑器里粗、手机不粗」的根因。
     */
    var wideDeclList = wideDecls(st.css);
    /*
     * ★ v2.6.6：宽载体覆盖**全部**样式，不再只收「差集声明」。
     *   真机证明：直连写入的产物**不在受控编辑器的文档状态里** —— 保存时它按自己的
     *   状态序列化，写进去的 style 一律丢（标签/徽标的外框丢、加粗在手机端不粗，
     *   是同一条根因）。唯一能进入那个状态的通道是宿主自己的输入通道（粘贴导入）。
     *   ⇒ 差集声明（外框类）与纯文字样式（加粗一类）都必须走这条路。
     */
    /* ★ v2.6.19：只在配方确实含「schema 接不住的差集声明」时才走宽载体。
   *   旧判据（v2.6.6）是「差集为空就送整条 css」⇒ 连加粗 / 徽标 / 高亮这类
   *   纯文字样式也走合成粘贴，而合成粘贴的落点由宿主自己的 selection 决定：
   *   现场就是「点一次徽标，正文开头多出一份带样式的副本」（诊断报告五·流水
   *   12:32:49「宽载体未采纳…自动撤销没成功」）。
   *   现在差集为空 ⇒ wideNeed 为空 ⇒ 走下面的配方节点替换（落点由本脚本选区决定）。
   *   这是安全的：v2.6.18 已启用节点级固化，直连写入会进宿主 doc（流水「已固化 N 个节点」）。
   */
  var wideNeed = (willRemove || !wideCarrierOn()) ? [] : wideDeclList;
    if (!willRemove && !wideCarrierOn() && wideDeclList.length) {
      trace('wide', st.label + ' · 宽载体（合成粘贴）已关闭，改走直连载体 / 配方节点替换'
        + '　落点由本脚本选区决定');
    }
    /*
     * ★ v2.6.5 实测后撤回：曾让「纯文字样式但 schema 认不出语义标签」也走宽载体，
     *   装置（pmwx2 T3b/T3c、pmwx4 T18e）实测退化 —— 宽载体一旦没落地，
     *   回退路径要求用户「重新选中文字再点一次」，对加粗这种高频操作是不可接受的降级。
     *   所以纯文字样式仍走直连语义标签链路；schema 读不到时的兜底见 p2 的 WX_KNOWN_SEM。
     */
    if (!willRemove && pmHostOf(ctx) && wideNeed.length) {
      var wp = widePasteRuns(ctx, range, st.css);
      if (wp.done) {
        // 提示里点名**验真通过**的那几个声明 —— 「成功」要能被逐条追认，
        // 而不是一句没有信息量的「已送达」。
        toast('已应用「' + st.label + '」（宽载体：'
          + (wp.pre ? '这段文字原本就带这套样式，无需改动'
            : ((wp.hit && wp.hit.length) ? wp.hit.join('、') + ' 已确认落到内联 style' : '内联样式完整送达'))
          + '）');
        /* 成功路径也必须留一条流水 + 证据。
           以前只有「未采纳」才写 trace，成功路径一片空白 ——
           一旦验真出假阳性（装置实测到过），现场只能靠猜。 */
        trace('wide', st.label + ' · 宽载体已采纳' + (wp.pre ? '（基线已达标·无需改动）' : '')
          + '　验真命中=[' + ((wp.hit || []).join('、') || '—')
          + ']　证据=' + String(wp.ev || '').slice(0, 160));
        return;
      }
      trace('wide', st.label + ' · 宽载体未采纳（' + wp.why + '），退回配方节点替换'
        + (wideDeclList.length ? '　差集声明=[' + wideDeclList.join('、') + ']' : '　（纯文字样式）')
        + '　送出=' + String(wp.sent || ''));

      /*
       * ★ 重新定位选区（v2.0 补丁 H）
       *   宿主接了粘贴，就意味着它**动过**选区 —— 很可能已经把选中的那一段
       *   换成了内容相同的纯文字。此时旧的 range / runs 指向的节点多半已经不在树上，
       *   继续拿它们走下面的配方路径，等于对着一棵重渲染过的树干活：
       *   轻则静默无效，重则把样式写到已经脱离文档的节点上。
       *   「退回配方节点替换」这句承诺要成立，必须先重新定位。
       *   定位不回来就当场中止并如实告知 —— 不许拿着失效节点乱写。
       */
      if (wp.touched) {
        var g2 = pick(true, '宽载体未被编辑器接纳，且原选区已失效 —— 请重新选中文字再点一次');
        if (!g2) return;
        ctx = g2.ctx; range = g2.range;
        runs = collectRuns(range, ctx);
        if (!runs.length) { toast('选区内没有可处理的文字（图片请用编辑器原生操作）'); return; }
        willRemove = runsAllHave(runs, useCss);
      }
    }

    snapshot(st.label);

    // 先把每个 run 切成独立文本节点，之后的坐标才是稳定的
    var nodes = [];
    for (var i = 0; i < runs.length; i++) nodes.push(isolateRun(runs[i]));

    for (var j = nodes.length - 1; j >= 0; j--) {
      var node = nodes[j];
      if (!node || !node.isConnected) continue;
      if (willRemove) {
        var h = hostOf(node);
        if (h) {
          /*
           * 取消：先算出剩下的 css，再**整体重写**元素属性。
           * 不能只删 style —— 配方型元素（span[textstyle]）的样式并不只存在
           * style 属性里，只删 style 会留下旧的 textstyle 值，
           * 编辑器读回来还是原样式，表现就是「再点一次取消不掉」。
           */
          var rest = stripCss(h.getAttribute('style') || '', useCss);
          if (!norm(rest)) unwrap(h);
          else applyCssToEl(ctx, h, rest);
        }
      } else {
        var p = node.parentNode;
        /*
         * 复用已有宿主有前提（v2.4 修正）。
         *   宿主必须**自己就能带**这套样式：
         *     · 我们的 <a href="#"> 小件载体 ⇒ link 标记的 attrs 里有 style，
         *       整条配方都能落地 ⇒ 直接合并（顺带保住原来的 style，不叠加元素）；
         *     · 纯样式 <span>（textstyle 型）⇒ 只认 7 个文字属性。
         *   本轮若含「形状声明」（display / padding / border / border-radius），
         *   合并进 span 等于把外框交给一个承载不了的通道 —— 编辑器会静默丢掉，
         *   表现就是「点了没反应 / 外框不见了」。此时必须另起直连载体包在外层，
         *   而不是图省事复用那个 span。
         */
        /*
         * ★ v2.5.1：语义载体不许被「复用已有 span」吞掉 —— 这是「加粗在手机上不显示」的真根。
         *   正文里的字往往已经套着一层 <span textstyle>（编辑器自己的字号 / 字色，
         *   或用户先前加的样式），旧判据见状判「可以合并」，把字重**并进那个 span**：
         *   <strong> 一次都没建出来 —— 桌面上看着是粗的（内联字重生效），
         *   手机端不粗（span + 内联字重正是终端不认的那条路）。
         *   装置 rep251b 实测：先给「西格玛」点蓝色标签、再点加粗 ⇒
         *   载体仍是 `a#display:inline-block;…`，`<strong>` 计数 0。
         *   所以：这次要写的样式「语义标签能表达、且 schema 确实认那个标签」时，一律另起语义节点。
         */
        var semTag = (willRemove || directCarry) ? '' : semTagForCtx(ctx, useCss);
        /*
         * ★ 注意 semTag 这一条**必须放在最前面**、且不分载体形态：
         *   `p.tagName === 'A'` 那一支（v2.4 的直连载体）同样会吞掉语义标签 ——
         *   装置实测：先给文字点「蓝色标签」（得到 <a href style=标签>），
         *   再点「加粗」时旧判据走 A 支 ⇒ 字重被并进那个 <a>，<strong> 依旧没建出来。
         *   所以只要这次写的是「语义标签表达的样式」，任何形态的既有宿主都不得复用。
         */
        var pHostOk = p && isPureStyleSpan(p) && !semTag && (p.tagName === 'A' || !directCarry);
        if (pHostOk) { applyCssToEl(ctx, p, norm(p.getAttribute('style')) + ';' + useCss); }
        else {
          // ★ 配方优先：包裹元素的写法必须与编辑器方言一致，否则写完就被拆
          //   v2.4：配方判降级且含形状声明时改走直连载体（不押在 schema 判定上）
          var sp = directCarry ? mkWrapElDirect(ctx, ctx.doc, useCss) : mkWrapEl(ctx, ctx.doc, useCss);
          p.insertBefore(sp, node);
          sp.appendChild(node);
        }
      }
    }

    selectNodes(ctx, nodes);
    if (directCarry) inlineCarryCheck(ctx, nodes, useCss, st.label);
    // ★ v2.5：不论成功与否都回头看一眼「这一笔到底留住了没有」——见 inlineTextCheck
    if (!willRemove) inlineTextCheck(ctx, nodes, useCss, st.label, mySeq);
    if (willRemove) toast('已取消「' + st.label + '」');
    else if (directCarry) {
      /*
       * 直连时把话说准：写的是完整配方，成不成由事后的异步复查给结论。
       * 这里**不能**报「已按它支持的部分应用」—— 那是降级档的说法，与事实不符。
       */
      toast('已应用「' + st.label + '」（直连载体：外框 / 圆角 / 内边距一并写入）');
    }
    else if (eff.partial) {
      toast('已应用「' + st.label + '」（编辑器承载不了 ' + (eff.dropped.join('、') || '部分声明')
        + '，已按它支持的部分应用）');
    } else {
      toast('已应用「' + st.label + '」');
    }
  }

  /*
   * 直连载体的事后复查（v2.4）。
   *   「写进去了」不等于「编辑器留下了」：受控编辑器的重渲染跑在**微任务**里，
   *   同步代码看不到它把 style 抹回去的那一刻（这与 runAct 里「固化必须同步」是同一条时序规律）。
   *   所以必须异步回头看一次，并且**只取证 + 如实告知，不二次改写** ——
   *   反复刷 DOM 会让编辑器卡，与图片圆角那条经验一致。
   */
  var CARRY_SHAPE = ['display', 'padding', 'border', 'border-radius'];
  /*
   * 直连载体的事后复查（v2.4 立项 / v2.5.2 改判据）。
   *
   * 【为什么改判据】旧版只查 `a[href="#"]`：
   *   现场「点保存后徽标 / 标签样式失效」的直接原因，就是写进去的
   *   `<a href="#" style="…">` 被编辑器**归并成了 <span>**（本机 link 标记
   *   只对真链接产出 <a>）。而旧判据换个载体就查不到任何元素 ⇒ `alive = 0`
   *   应当报警，却因为「一个 a[href="#"] 都没有」而走了同一分支 ——
   *   更糟的是：v2.5.1 现场流水里它报的是「直连载体复查通过」，
   *   因为那一次载体还没被换掉；一旦被换掉，它连线索都不给。
   *   结论：**判据绑在具体的标签上，就必然漏掉「标签被换掉」这一类事故**。
   *
   * 【新判据】改成与 inlineTextCheck 完全同源的三步：
   *   ① 按**文字内容**把落点找回来（findInlineHosts，一次遍历）；
   *   ② 从落点往上找「真的带上这套形状声明」的那一层（carrierFor，≤8 层）；
   *   ③ 三个结论，逐条说清：
   *        · 载体仍是 <a>（小件载体）      → 复查通过
   *        · 载体换成了别的标签但声明还在  → **如实报告换了载体**（这就是隐患）
   *        · 声明不在了                    → 被编辑器抹回
   *   这样「标签被换掉」不再静默 —— 它正是「保存后失效」的前兆。
   */
  function inlineCarryCheck(ctx, nodes, css, label) {
    var want = [], i;
    for (i = 0; i < CARRY_SHAPE.length; i++) {
      if (String(css).indexOf(CARRY_SHAPE[i]) >= 0) want.push(CARRY_SHAPE[i]);
    }
    if (!want.length) return;
    var texts = [], j;
    for (j = 0; j < (nodes || []).length; j++) {
      if (nodes[j] && nodes[j].nodeValue) texts.push(nodes[j].nodeValue);
    }
    if (!texts.length) return;
    setTimeout(function () {
      try {
        if (!ctx || !ctx.root || !ctx.root.isConnected) return;
        var hosts = findInlineHosts(ctx, texts);
        var total = texts.length, okA = 0, moved = 0, dead = 0, tagSeen = {}, t;
        for (t = 0; t < total; t++) {
          var hit = carrierFor(hosts[texts[t]], css);
          if (!hit) { dead++; continue; }
          var tn = String(hit.tagName || '');
          tagSeen[tn] = (tagSeen[tn] || 0) + 1;
          if (tn === 'A') okA++; else moved++;
        }
        var tagsTxt = [];
        for (var tk in tagSeen) tagsTxt.push('<' + tk.toLowerCase() + '>×' + tagSeen[tk]);
        if (!dead && !moved) {
          /*
           * ★ v2.5.3：把**实际标签名**报出来（以前只说「仍是小件载体」）。
           *   与 inlineTextCheck 的措辞对齐，两条日志放一起就能一眼对上，
           *   不会再出现「一条说 <a>、一条说 <span>」这种互相矛盾的读法。
           */
          trace('carry', label + ' · 直连载体复查通过：' + okA + ' 处仍是小件载体（'
            + (tagsTxt.join(' ') || '<a>') + '）且带 [' + want.join('、') + ']');
        } else if (!dead && moved) {
          /*
           * ★ 这一条是 v2.5.2 的新证据：载体被换了，但声明还在内联 style 上。
           *   桌面端看着正常，可「载体」本身就是编辑器**不认**才被换掉的 ——
           *   微信后台一保存就会按它对那个标签的理解重排，外框随之消失。
           */
          trace('carry', label + ' · 直连载体已被编辑器换掉：' + (tagsTxt.join(' ') || '—')
            + '（写进去的是 <a href="#"> 小件载体）—— 形状声明虽在，保存后可能仍会失效');
          toast('「' + label + '」的载体被编辑器换成了 ' + (tagsTxt.join(' ') || '别的标签')
            + ' —— 点标题栏红点把诊断发我');
        } else {
          trace('carry', label + ' · 直连载体被编辑器抹回：写进去的 [' + want.join('、')
            + '] 已不在内联 style 上（' + dead + '/' + total + ' 处）');
          toast('「' + label + '」的外框 / 内边距被编辑器抹掉了 —— 点标题栏红点把诊断发我');
        }
      } catch (e) {}
    }, 700);
  }

  var INLINE_SEQ = 0;

  /*
   * ══ 行内样式的「落地形态」事后复查（v2.5）════════════════════════════
   * 加粗这条链路此前**没有任何事后复查**：写完就报「已应用」，
   * 于是「桌面上看着有了、手机端没有」这件事在桌面端一直不可见 ——
   * 只能等用户拿着文章去手机上撞，撞完回一句「安卓端还是没有加粗」，
   * 而现场到底断在哪一步，桌面端一个字都没留下。
   *
   * 这里在 700ms 后（受控编辑器的重渲染跑在**微任务**里，必须等它跑完）
   * 按**文字内容**把那段字找回来，看它落在什么宿主上、这次写的声明还在不在内联 style 上：
   *   · 宿主是 <strong>/<b> 一类语义标签 → 手机端由终端原生渲染加粗，最稳；
   *   · 宿主是 <span> 但声明仍在      → 还能用，但依赖内联属性被透传；
   *   · 声明也不在了                  → 编辑器把这一笔抹掉了，当场如实告知。
   * 代际号（seq）保证「用户紧接着又点了别的样式」时，这一轮复查直接放弃，
   * 不会把过期结论说出来（也避免把用户手动取消掉的样式又报成失败）。
   */
  function inlineTextCheck(ctx, nodes, css, label, seq) {
    if (!ctx || !ctx.root || !nodes || !nodes.length) return;
    var texts = [], i;
    for (i = 0; i < nodes.length; i++) {
      if (nodes[i] && nodes[i].nodeValue) texts.push(nodes[i].nodeValue);
    }
    if (!texts.length) return;
    setTimeout(function () {
      try {
        if (seq !== INLINE_SEQ) return;              // 期间又点了别的 → 放弃这一轮
        if (!ctx.root.isConnected) return;
        /*
         * ★ v2.5.1：一次遍历查全部，不再「每处跑一遍全文」。
         *   旧实现对每一处都调一次 findInlineHost，而那是**整篇**的 TreeWalker ——
         *   选中 M 处就是 O(M × 全文)。长文 + 批量着色时这一条会单独把主线程压住，
         *   现场表现正是「文章一长，点一下半天没反应 / 页面无响应」。
         *   装置 rep251b 实测（120 段、选中 31 段）：旧实现全文遍历 1672 次。
         *   判据完全等价：每一处取它**第一次**出现的行内包裹父元素。
         */
        var hosts = findInlineHosts(ctx, texts);
        var total = texts.length, sem = 0, span = 0, dead = 0, t, hit;
        var tagSeen = {};                     // ★ v2.5.3：按真实标签名归类
        for (t = 0; t < total; t++) {
          hit = carrierFor(hosts[texts[t]], css);
          if (!hit) { dead++; continue; }
          /*
           * ★ v2.5.3：以前这里是 `if (isSemanticCarrier(hit)) sem++; else span++;`，
           *   而 SEM_CARRIER 里**没有 `A`** ⇒ 我们自己的小件 <a href="#" style=…>
           *   被记成 span++，最后报出「载体是 <span>」——**与事实相反**。
           *   现场取证（用户 10:05 报告，「默认徽标」）：
           *     直连载体复查通过：1 处仍是小件载体且带 [display、padding、border、border-radius]
           *     落地复查：载体是 <span>，声明仍在（1/1 处，依赖内联样式透传）
           *   同一秒、同一落点，两句结论互相矛盾 —— 就是这一行造成的。
           *   这条标签不是修辞问题：它正是「载体是否被换掉」的**唯一证据来源**，
           *   报错了，「被换掉」与「没被换掉」在日志上就长得一模一样。
           */
          var tn2 = String(hit.tagName || '').toUpperCase();
          tagSeen[tn2] = (tagSeen[tn2] || 0) + 1;
          if (isSemanticCarrier(hit)) sem++;
          else if (tn2 === 'A' && isPureStyleSpan(hit)) span++;
          else span++;                        // 其它标签也归入「非语义」，但如实报名字
        }
        var tagTxt = (function () {
          var a = [], k;
          for (k in tagSeen) a.push('<' + k.toLowerCase() + '>×' + tagSeen[k]);
          return a.join(' ');
        })();
        if (sem === total) {
          trace('carry', label + ' · 落地复查：语义标签载体保住全套声明（' + total + ' 处）');
        } else if (!dead) {
          trace('carry', label + ' · 落地复查：载体是 ' + (tagTxt || '<span>')
            + '，声明仍在（' + span + '/' + total + ' 处，依赖内联样式透传）');
        } else {
          /*
           * 刻意**不弹 toast**：这一笔没留住时，脚本另有更精确的解释在更早处
           * （nochange / 回滚探针在 420ms 内就会说清「写了、但被编辑器剥回原样」，
           * 见装置 T13c 的判据）。这条复查跑在 700ms，若再抢一次提示，
           * 顶掉的正是那句最有信息量的话 —— 用户只会看到「被抹掉了一部分」，
           * 反而不知道是「压根没写进去」还是「写进去又被剥回」。
           * 结论写进流水，「样式配方」诊断里能逐条查。
           */
          trace('carry', label + ' · 落地复查：' + dead + '/' + total
            + ' 处已不带这套声明（编辑器把它抹掉了）——详情见「样式配方」诊断');
        }
      } catch (e) {}
    }, 700);
  }

  /*
   * 按文字内容找它的行内包裹宿主。
   * 只认行内标签 —— 块级元素（p / section）自带的 padding / display 会骗过判定，
   * 这是 wideVerify 早就踩过并修好的一条，判据共用同一份白名单。
   */
  /*
   * 按文字内容批量找行内包裹宿主 —— **一次** TreeWalker 走完整篇。
   *   旧版是「传一个词、走一遍全文」，被调用方在循环里逐处调用 ⇒ O(M × 全文)。
   *   语义与旧版逐条调用完全一致：每一处取它**第一次**出现、
   *   且父元素属于 INLINE_WRAP 的那个（父元素不是行内包裹时继续往后找）。
   */
  function findInlineHosts(ctx, texts) {
    var out = {}, want = {}, left = 0, i;
    for (i = 0; i < texts.length; i++) {
      var k = texts[i];
      if (k == null || want[k]) continue;
      want[k] = 1; left++;
    }
    if (!left) return out;
    try {
      var w = ctx.doc.createTreeWalker(ctx.root, 4, null, false), n;   // 4 = SHOW_TEXT
      while (left && (n = w.nextNode())) {
        var v = n.nodeValue;
        if (v == null || !want[v] || out[v]) continue;
        var el = n.parentNode;
        if (!el || el.nodeType !== 1 || !INLINE_WRAP[el.tagName]) continue;
        out[v] = el; left--;
      }
    } catch (e) {}
    return out;
  }

  // 单条版（保留：别处若只问一个词，仍走这里；内部转调批量版，避免两套判据漂移）
  function findInlineHost(ctx, text) { return findInlineHosts(ctx, [text])[text] || null; }

  /*
   * 从宿主往上找「真正承载这次声明的那个元素」。
   *   为什么必须往上找（v2.5.1）：语义载体（<strong>）与直连载体（<a href style=标签>）
   *   会**嵌套**，而 PM 重新渲染时谁在里谁在外并不固定 —— 装置实测到过
   *   `<a href style=标签><strong style=font-weight:bold>字</strong></a>`。
   *   只看最里那一层，就会把「加粗好好落在 <strong> 上」误报成
   *   「编辑器把它抹掉了」，在诊断里给出一条与事实相反的结论（装置 A4 实测到过）。
   *   判据仍然严格：必须是**真的带上了这套声明**的那一层，光有语义标签不算数。
   */
  function carrierFor(host, css) {
    var p = host, i = 0;
    while (p && p.nodeType === 1 && i++ < 8) {
      if (elHasCss(p, css)) return p;
      if (BLOCK_TAGS[p.tagName]) return null;
      p = p.parentNode;
    }
    return null;
  }

  /* ── 7.2 链接 ───────────────────────────────────────────────────── */

  function applyLink() {
    var g = pick(true, '请先选中要加链接的文字');
    if (!g) return;
    var ctx = g.ctx, range = g.range;
    var runs = collectRuns(range, ctx);
    if (!runs.length) { toast('选区内没有文字'); return; }

    openDialog({
      title: '添加链接',
      fields: [{ k: 'url', label: '链接地址', value: 'https://', ph: 'https://mp.weixin.qq.com/...' }],
      ok: function (v) {
        var url = (v.url || '').trim();
        if (!url || url === 'https://') { toast('链接地址不能为空'); return; }
        snapshot('链接');
        var nodes = [];
        for (var i = 0; i < runs.length; i++) nodes.push(isolateRun(runs[i]));
        for (var j = nodes.length - 1; j >= 0; j--) {
          var node = nodes[j];
          if (!node || !node.isConnected) continue;
          var pa = node.parentNode;
          if (pa && pa.tagName === 'A') {
            pa.setAttribute('href', url);
            pa.setAttribute('style', norm(STYLES.a.css));
            continue;
          }
          var a = ctx.doc.createElement('a');
          a.setAttribute('href', url);
          a.setAttribute('style', norm(STYLES.a.css));
          pa.insertBefore(a, node);
          a.appendChild(node);
        }
        selectNodes(ctx, nodes);
        toast('已添加链接');
      }
    });
  }

  function removeLink() {
    var g = pick(false, '请把光标放到链接里');
    if (!g) return;
    var ctx = g.ctx, range = g.range;
    var a = ancestorTag(range.startContainer, 'A', ctx.root);
    if (!a) { toast('光标不在链接上'); return; }
    /*
     * v2.2：行内小件（徽标 / 标签 / 行内代码 / 键盘键）也由 <a> 承载。
     * 它们 href 为空（或 '#'）、属性只有 style / href —— 不是链接，不能拆。
     * 判据直接复用 isPureStyleSpan，避免「什么是小件」在两处各写一份而漂移。
     */
    if (isPureStyleSpan(a)) { toast('这是行内小件（徽标 / 标签），不是链接'); return; }
    snapshot('取消链接');
    unwrap(a);
    toast('已取消链接');
  }

  /* ── 7.3 引用 / 嵌套引用 ────────────────────────────────────────── */

  function wrapBlocks(ctx, blocks, css) {
    var groups = groupByParent(blocks), out = [];
    for (var i = 0; i < groups.length; i++) {
      var g = groups[i];
      var sec = ctx.doc.createElement('section');
      sec.setAttribute('style', norm(css));
      g.parent.insertBefore(sec, g.items[0]);
      for (var j = 0; j < g.items.length; j++) sec.appendChild(g.items[j]);
      out.push(sec);
    }
    return out;
  }

  // mode: 'toggle' 普通引用 ｜ 'accent' 强调引用 ｜ 'nest' 嵌套引用
  //      ｜ 'nestAccent' 嵌套强调引用（强调引用的再嵌一层）
  function applyQuote(mode) {
    var g = pick(false, '请把光标放到正文段落里');
    if (!g) return;
    var ctx = g.ctx, range = g.range;

    var sc = listScope(range, ctx);
    if (!sc) { toast('没找到可引用的段落'); return; }
    var targets = filterDeco(sliceBetween(sc.container, sc.first, sc.last));
    if (!targets.length) { toast('没找到可引用的段落'); return; }

    var first = targets[0];
    // 只认「直接父级就是引用容器」——说明这些块确实躺在某个引用里
    var anc = (first.parentNode && isQuoteEl(first.parentNode)) ? first.parentNode : null;

    /* ── ① 取消路径（就地 toggle） ── */
    if (anc) {
      if (mode === 'toggle') {
        snapshot('取消引用'); unwrap(anc); toast('已取消引用'); return;
      }
      if (mode === 'accent' && elHasCss(anc, STYLES.q3.css)) {
        snapshot('取消强调引用'); unwrap(anc); toast('已取消强调引用'); return;
      }
      if (mode === 'nest' && elHasCss(anc, STYLES.q2.css)) {
        snapshot('取消嵌套引用'); unwrap(anc); toast('已取消嵌套引用'); return;
      }
      if (mode === 'nestAccent' && elHasCss(anc, STYLES.q4.css)) {
        snapshot('取消嵌套强调引用'); unwrap(anc); toast('已取消嵌套强调引用'); return;
      }
    }

    /* ── ② 应用路径 ── */
    var css, label, note = '';
    if (mode === 'accent') { css = STYLES.q3.css; label = '强调引用'; }
    else if (mode === 'nestAccent') {
      /*
       * 嵌套强调引用 = 强调引用的「再嵌一层」，与「嵌套引用之于引用」同一逻辑。
       *   光标已在强调引用里 → 落 q4（更深朱红 / 更浅底）；
       *   不在 → 先落一层强调引用，并在提示里说明 —— 直接报错或静默都不合适。
       */
      if (anc && elHasCss(anc, STYLES.q3.css)) { css = STYLES.q4.css; label = '嵌套强调引用'; }
      else { css = STYLES.q3.css; label = '强调引用'; note = '当前不在强调引用内，已先落一层强调引用'; }
    }
    else if (mode === 'nest') {
      if (anc) { css = STYLES.q2.css; label = '嵌套引用'; }
      else { css = STYLES.q1.css; label = '引用'; note = '当前不在引用内，已按一级引用处理'; }
    } else { css = STYLES.q1.css; label = '引用'; }

    snapshot(label);
    var made = wrapBlocks(ctx, targets, css);
    if (made.length) {
      /*
       * ★ 引用块的「首行前 / 末行后」间距对齐（用户反馈：两者视觉不一致）。
       *   容器的上下 padding 本来是对称的，但容器里那些段落**自带 margin**：
       *   首块带 margin-top、末块带 margin-bottom ⇒ 「首行前」比「末行后」多一截，
       *   整块看起来往下坠。微信会剥 :first-child / :last-child 选择器，CSS 表达不了，
       *   只能在套用的同一时刻**逐个直接子块写内联 margin**。
       *   只动首块的上边距与末块的下边距 —— 中间的段间距是内容排版的一部分，不碰。
       */
      for (var mi = 0; mi < made.length; mi++) tidyQuoteSpacing(made[mi]);
      toast(note || ('已应用' + label));
    }
  }

  /*
   * 引用块的对称间距：把首块的 margin-top 与末块的 margin-bottom 归零。
   *   为什么不能靠 CSS：微信会剥 :first-child / :last-child 这类选择器，
   *   以及 ::before / ::after，所以只能落到具体元素的内联样式上。
   *   为什么不能删掉所有子块 margin：中间的段间距是内容排版的一部分，
   *   一并压平会让多段引用糊成一块。
   */
  function tidyQuoteSpacing(sec) {
    if (!sec || sec.nodeType !== 1) return;
    var kids = [], n = sec.firstChild;
    while (n) { if (n.nodeType === 1) kids.push(n); n = n.nextSibling; }
    if (!kids.length) return;
    var k0 = kids[0];
    if (k0 && k0.style) { try { k0.style.setProperty('margin-top', '0'); } catch (e) {} }
    var kz = kids[kids.length - 1];
    if (kz && kz.style) { try { kz.style.setProperty('margin-bottom', '0'); } catch (e2) {} }
    sec.__mptbQSpaced = 1;
  }

  /* ── 7.4 列表（悬挂缩进，不用 ul/li 语义标签，引用内同样可用） ──── */

  var MARK_STYLE = 'color:#9F312A;font-weight:600;';

  /*
   * 列表前缀标记（• / 1.）的识别。
   * 刻意不用 elHasCss 全等比对 —— 全等比对只能认得自己那一种写法。
   * 换成「颜色是品牌红 + 字重 ≥ 600」之后，圆点列表与数字列表走同一套逻辑
   * 都能认出来，以后再加新前缀也不用回来改。
   */
  function isPrefixSpan(el) {
    if (!el || el.nodeType !== 1 || el.tagName !== 'SPAN' || !isPureStyleSpan(el)) return false;
    var s = el.style;
    if (!s) return false;
    if (!valEq(s.color, MARK_COLOR)) return false;
    var w = parseInt(s.fontWeight, 10);
    return !isNaN(w) && w >= MARK_WEIGHT;
  }

  function removePrefix(block) {
    var f = block && block.firstChild;
    if (isPrefixSpan(f)) block.removeChild(f);
  }

  function insertPrefix(ctx, block, text, css) {
    var sp = ctx.doc.createElement('span');
    sp.setAttribute('style', css);
    sp.textContent = text + ' ';
    block.insertBefore(sp, block.firstChild);
    return sp;
  }

  /*
   * 块级操作的统一取参：取「光标所在那一层容器」里的目标块。
   * 引用 / 列表 / 标题 三类块级样式共用它，保证三者作用域规则完全一致
   * （光标在引用块内时，作用对象是引用块内的段落，而不是整个引用容器）。
   */
  function blockScope(failMsg) {
    var g = pick(false, failMsg);
    if (!g) return null;
    var sc = listScope(g.range, g.ctx);
    if (!sc) { toast('没找到可用的段落'); return null; }
    var blocks = filterDeco(sliceBetween(sc.container, sc.first, sc.last));
    if (!blocks.length) { toast('没找到可用的段落'); return null; }
    return { ctx: g.ctx, blocks: blocks };
  }

  function applyList(ordered) {
    var s = blockScope('请把光标放到要变成列表的段落里');
    if (!s) return;
    var ctx = s.ctx, blocks = s.blocks;

    var key = ordered ? 'oli' : 'li';
    var all = true;
    for (var i = 0; i < blocks.length; i++) {
      if (!elHasCss(blocks[i], STYLES[key].css)) { all = false; break; }
    }

    if (all) {
      snapshot('取消列表');
      for (var j = 0; j < blocks.length; j++) {
        stripStyle(blocks[j], STYLES.li.css);
        stripStyle(blocks[j], STYLES.oli.css);
        removePrefix(blocks[j]);
      }
      toast('已取消列表');
      return;
    }

    snapshot(ordered ? '数字列表' : '列表');
    var n = 1;
    for (var k = 0; k < blocks.length; k++) {
      var b = blocks[k];
      stripStyle(b, STYLES.li.css);
      stripStyle(b, STYLES.oli.css);
      removePrefix(b);
      mergeStyle(b, STYLES[key].css);
      insertPrefix(ctx, b, ordered ? (n + '.') : '•', MARK_STYLE);
      n++;
    }
    toast(ordered ? '已应用数字列表' : '已应用圆点列表');
  }

  /* ── 7.4b-1 一级标题自动编号（★ v2.6.25 新增）──────────────────────
   *
   * 用户 2026-09-21 指定：一级标题「都改为自动从 01 开始编号的标题，
   * 点击后自动应用编号」。⇒ 点四款一级标题任一颗 ⇒ 套样式 **并按文档顺序
   * 重排全篇编号**；取消标题时编号一并撤掉、后面的顺延。
   *
   * 【为什么是「重排全篇」而不是「只给这一段加号」】
   *   编号的语义是**序号**，不是装饰 —— 插入 / 删除 / 挪动任一级标题之后，
   *   单纯给新块补一个「有意义的号」是不可能的（后面的全得顺延）。所以做成
   *   幂等的全篇重排：任何时候点一下，全篇编号都与当前结构一致。
   *
   * 【编号是真实文字，不是 CSS counter】
   *   微信不支持 CSS counter / ::before ⇒ 编号只能作为文本写进段落内容里。
   *   承载方式与列表前缀（• / 1.）完全一致：一个行内 span + 内联 style，
   *   由编辑器的 textstyle 标记送回文档模型（三条声明都在它的 7 属性表内）。
   *
   * 【与列表前缀的隔离】
   *   两者都是「段落里的第一个行内 span」，靠**颜色**分开：
   *   列表前缀 #9F312A + 600（isPrefixSpan），编号 #8A8A8A + 700（isHeadNumSpan）。
   *   为什么不合并成同一个判据：两种语义共用一套签名，一定会互相误删 ——
   *   本项目在语义标签 / 内联源码档上已经吃过三次同型的亏。
   */

  // 两位零填充：1 → '01'，99 → '99'，100 → '100'（超两位自然进位，不截断）
  function headNumText(n) {
    var s = String(n);
    while (s.length < 2) s = '0' + s;
    return s;
  }

  function isHeadNumSpan(el) {
    if (!el || el.nodeType !== 1 || el.tagName !== 'SPAN' || !isPureStyleSpan(el)) return false;
    var s = el.style;
    if (!s) return false;
    if (!valEq(s.color, HEAD_NUM_COLOR)) return false;
    if (!valEq(s.fontWeight, '700')) return false;
    return /^[0-9]{2,}$/.test(String(el.textContent || '').replace(/[\s\u00a0]/g, ''));
  }

  function removeHeadNum(block) {
    var n = block && block.firstChild;
    if (isHeadNumSpan(n)) { block.removeChild(n); return true; }
    return false;
  }

  /*
   * ══ 编号的落点（★ v2.6.28 改：跟**文字**走，不跟「块的第几个孩子」走）════════
   *
   * 【现场】编号被顶到标题**上一行** ⇒ 竖条 / 双线的左竖条跨两行（用户报「竖线太长」），
   *   下划的线也跟着变高。根因不在配方，在**落点**：
   *   旧写法 `block.insertBefore(sp, block.firstChild)` 把编号钉死在**块的第 0 个孩子**上，
   *   而「标题文字」未必就在那儿 —— 块首只要有一个换行（或编辑器把文字包进内层容器
   *   如 <p>），编号与文字就分到了两行。同一份产物里两种形态都可能出现，
   *   所以落点判据不能只钉一种。
   *
   * 【做法】先找「首个**标题文字**文字节点」（让开列表前缀 •/1. 与旧编号），再往上找出
   *   **最内层的块级容器**（P/SECTION/DIV/PRE…），把编号插进该容器、摆在「文字所在那个
   *   直接子元素」**之前**。容器内部一律是行内级内容 ⇒ 编号与标题文字**必然同一行**。
   *   块里没有任何文字（空标题）⇒ 退回旧行为（插在块首），保证不失效。
   *
   * 【为什么不用 getComputedStyle 判块级】游离 / 克隆 DOM 上它恒空且**不抛错** ⇒
   *   这类守卫会把整条通道静默掐死（本项目 rebuildTables 就这么哑过 9 个版本）。
   *   这里用**标签白名单**，判据确定、可离线复现。
   */
  var BLOCKISH_TAGS = { P: 1, SECTION: 1, DIV: 1, ARTICLE: 1, BLOCKQUOTE: 1,
    UL: 1, OL: 1, LI: 1, H1: 1, H2: 1, H3: 1, H4: 1, H5: 1, H6: 1,
    FIGURE: 1, TABLE: 1, TBODY: 1, TR: 1, TD: 1, TH: 1, PRE: 1 };
  function isBlockishEl(el) {
    return !!(el && el.nodeType === 1 && BLOCKISH_TAGS[el.tagName]);
  }

  /*
   * 首个**标题文字**文字节点：跳过纯空白的，以及列表前缀（• / 1.）与旧编号的。
   *   为什么必须让开前缀：removePrefix() 只看 block.firstChild，编号一旦把前缀顶到后面，
   *   那个 `•` 就再也删不掉了（本项目第五次栽在位置耦合上）。
   */
  function headTextNode(ctx, block) {
    var w = ctx.doc.createTreeWalker(block, NodeFilter.SHOW_TEXT, null, false), n, p;
    while ((n = w.nextNode())) {
      p = n.parentNode;
      if (isPrefixSpan(p) || isHeadNumSpan(p)) continue;
      if (String(n.nodeValue || '').replace(/[\s\u00a0]/g, '').length) return n;
    }
    return null;
  }

  /*
   * 算出「编号该插进哪一层、摆在谁之前」。落点计算与块首空行清理（trimBlockLeadBreak）
   * 共用这一份，避免两处口径漂移。返回 null = 块里没有文字。
   */
  function headNumSlot(ctx, block) {
    var t = headTextNode(ctx, block);
    if (!t) return null;
    var chain = [], probe = t.parentNode;
    while (probe && probe !== block) { chain.push(probe); probe = probe.parentNode; }
    if (probe !== block) return null;                  // 文字不在本块内（异常结构）
    var host = block, i;
    for (i = 0; i < chain.length; i++) {               // 自文字往上第一个块级容器 = 最内层
      if (isBlockishEl(chain[i])) { host = chain[i]; break; }
    }
    var anchor = t;
    for (i = chain.length - 1; i >= 0; i--) {          // host 的直接子元素里最靠上的那个
      if (chain[i].parentNode === host) { anchor = chain[i]; break; }
    }
    return { host: host, anchor: anchor, text: t };
  }

  /* 容器子树里有没有**非空白文字**（判「这个节点是不是空行/空壳」用） */
  function hasContentText(el) {
    var d = el.ownerDocument || document;
    var w = d.createTreeWalker(el, NodeFilter.SHOW_TEXT, null, false), n;
    while ((n = w.nextNode())) {
      if (String(n.nodeValue || '').replace(/[\s\u00a0]/g, '')) return true;
    }
    return false;
  }

  /*
   * ══ 「首个标题文字**之前**」的边缘扫描（★ v2.6.29）════════════════════════
   *
   * 【为什么要有这一层】用户现场（2026-09-22）：同一篇里 01/05~10 的编号与标题同行，
   *   02/03/04 掉到标题**上一行**。本机形态矩阵复现出**两种**子症状，根因同一个：
   *     · 换行与文字**同 leaf** `<span leaf=""><br>标题</span>`
   *         ⇒ 编号被插在含换行的那个容器**之前** ⇒ **编号独占一行**
   *     · 换行**单独一个 leaf** `<span leaf=""><br></span><span leaf>标题</span>`
   *         ⇒ 编号落在换行之后 ⇒ 同行，但标题**上方留一个空行**（竖条跨两行）
   *   而 v2.6.28 的清理判据是「块的**直接孩子**是不是 <br>」——
   *   换行一旦被包在行内容器里（微信的常态），两种形态**一个都认不出**。
   *
   * 【规则】从 host 起沿**块首边缘**往下走：
   *     · 纯空白文本 / 注释 / 无文字的容器（含只装 <br> 的 span、空 span）⇒ 登记删除，继续
   *     · 列表前缀（品牌红）与旧编号 span ⇒ **让开**（不删，交给 removePrefix / 重排）
   *     · 文字所在的那一支（祖先链）⇒ 只清它的**左侧**，自己不动
   *     · 一遇到有文字的节点 ⇒ **立刻停手**（再往后都是正文，与块首无关）
   *   返回 { dead: 待删节点, breaks: 文字之前的 <br>（文档序）}。
   *   ★ 清理与落点**共用这一份遍历**，避免两处口径漂移（同 headNumSlot 的规矩）。
   *
   * 【为什么不用 getComputedStyle】游离 / 克隆 DOM 上它恒空且不抛错 ⇒ 会把整条通道
   *   静默掐死（本项目 rebuildTables 就这么哑过 9 个版本）。这里只看标签与文字。
   */
  function leadEdgeScan(ctx, host, t) {
    var dead = [], breaks = [], guard = 0;
    function leadWalk(container) {
      var n = container.firstChild, nx;
      while (n && n !== t && guard < 3000) {
        guard++;
        if (n.nodeType === 3) {                          // 文本
          if (String(n.nodeValue || '').replace(/[\s\u00a0]/g, '')) return true;   // 有文字 ⇒ 停
          dead.push(n); n = n.nextSibling; continue;      // 纯空白 ⇒ 删
        }
        if (n.nodeType !== 1) { dead.push(n); n = n.nextSibling; continue; }   // 注释等
        if (isPrefixSpan(n) || isHeadNumSpan(n)) { n = n.nextSibling; continue; }
        if (n.contains && n.contains(t)) {                // 文字在这一支里：只清它的左侧
          if (leadWalk(n)) return true;
          n = n.nextSibling; continue;
        }
        if (hasContentText(n)) return true;               // 有文字但不含 t（异常）⇒ 停
        if (n.tagName === 'BR') breaks.push(n);           // 文字之前的换行
        dead.push(n);                                     // 无文字的节点整体可删
        n = n.nextSibling;
      }
      return false;
    }
    leadWalk(host);
    return { dead: dead, breaks: breaks };
  }

  /*
   * 去掉标题块**块首的空行** —— ★ v2.6.29：由「只看块的直接孩子是不是 <br>」改为
   * **可穿透行内容器**的边缘扫描（见 leadEdgeScan 的长注）。
   * 只在**设为标题**时执行：那是用户显式动作，且标题块首本来就不该有空行；
   * 取消标题 / 清除格式**绝不动内容**（只摘样式，不替用户删东西）。
   */
  function trimBlockLeadBreak(ctx, block) {
    var slot = headNumSlot(ctx, block);
    if (!slot || !slot.text || !slot.text.parentNode) return 0;      // 空标题 ⇒ 不动
    var scan = leadEdgeScan(ctx, block, slot.text), k = 0, i;
    for (i = 0; i < scan.dead.length; i++) {                         // 自外向内删，父先亡则跳过
      if (scan.dead[i].parentNode) { scan.dead[i].parentNode.removeChild(scan.dead[i]); k++; }
    }
    return k;
  }

  /*
   * 全篇标题块的块首清理（★ v2.6.29）—— 只为「设为标题」这个显式动作服务。
   * 为什么必须覆盖**全篇**：renumberHeads 本来就是全篇动作（老文章点一下就要全篇编号
   * 正确），而编号的落点依赖「块首没有换行」⇒ 只清被点的那几块，其余标题的编号仍会
   * 被换行顶到上一行（用户现场：同一篇里有的同行、有的掉行）。
   * ⚠️ 取消标题 / 清除格式两条路径**不调用本函数** —— 那时不动内容。
   */
  function trimHeadsLeadBreaks(ctx) {
    var n = 0;
    walkEls(ctx.root, function (el) {
      if (isSerifDeco(el) || !isHeadBlock(el)) return;
      n += trimBlockLeadBreak(ctx, el);
    });
    return n;
  }

  function insertHeadNum(ctx, block, n) {
    var sp = ctx.doc.createElement('span');
    sp.setAttribute('style', HEAD_NUM_STYLE);
    sp.textContent = headNumText(n) + HEAD_NUM_GAP;
    /* ★ v2.6.28：落点跟**文字**走（见上方长注） */
    var slot = headNumSlot(ctx, block);
    if (slot && slot.anchor && slot.anchor.parentNode === slot.host) {
      /* ★ v2.6.29 兜底落点：文字之前若**仍**夹着换行（清理没覆盖到的形态、或编辑器
         从 doc model 重渲染把 <br> 还原回来），编号必须落在该换行**之后** ——
         宁可留一个空行，也绝不让编号掉到标题上一行（用户报的就是这个）。
         这里只**读**不删：删除动作归 trimBlockLeadBreak（只在「设为标题」时跑）。*/
      var scan = leadEdgeScan(ctx, block, slot.text);
      var br = scan.breaks.length ? scan.breaks[scan.breaks.length - 1] : null;
      if (br && br.parentNode) br.parentNode.insertBefore(sp, br.nextSibling);
      else slot.host.insertBefore(sp, slot.anchor);
      return sp;
    }
    var first = block.firstChild;
    if (isPrefixSpan(first)) block.insertBefore(sp, first.nextSibling);
    else block.insertBefore(sp, first);
    return sp;
  }

  /*
   * 全篇重排 —— 幂等：先摘掉文档里**所有**编号 span（不只是标题里的：
   * 标题被取消 / 被清除格式之后，那个编号已经没有主人，留着就是脏数据），
   * 再按文档顺序给当前所有一级标题块从 01 重编。
   * 顺序由 walkEls 的 TreeWalker 前序遍历保证 = 文档顺序。
   */
  function renumberHeads(ctx) {
    var stale = [];
    walkEls(ctx.root, function (el) { if (isHeadNumSpan(el)) stale.push(el); });
    for (var i = 0; i < stale.length; i++) {
      if (stale[i].parentNode) stale[i].parentNode.removeChild(stale[i]);
    }
    var blocks = [];
    walkEls(ctx.root, function (el) {
      if (!isSerifDeco(el) && isHeadBlock(el)) blocks.push(el);
    });
    for (var j = 0; j < blocks.length; j++) insertHeadNum(ctx, blocks[j], j + 1);
    return blocks.length;
  }

  /* ── 7.4b 杂志风标题 ────────────────────────────────────────────── */

  function isHeadBlock(el) {
    for (var i = 0; i < HEAD_KEYS.length; i++) {
      if (elHasCss(el, sigCss(STYLES[HEAD_KEYS[i]].css))) return true;
    }
    return false;
  }

  /*
   * ★ v2.6.28：「识别标题」时**忽略 width**。
   *   本版给下划 / 双线加了 `width:fit-content`（底部线只到标题文字宽度）。
   *   而 elHasCss 要求配方里**每一条声明都在** ⇒ 本版之前设过的标题没有这条，
   *   会被判成「不是标题」⇒ renumberHeads 先把全篇编号摘掉、再只给认出来的块重编
   *   ⇒ **老标题的编号会被静默吞掉**（现场表现：01/02 突然消失，还看不出是谁干的）。
   *   width 只改观感、不参与识别签名（四款靠边框与颜色就能区分）⇒ 比较前剔掉它。
   * ★ v2.6.30：同一条纪律推广到 **font-family**。
   *   本版给四款一级都补了宋体栈（HEAD_SERIF），而 v2.6.30 之前设过的标题
   *   **没有这条**（衬线款虽有、但那是旧栈、字面也不同）⇒ 不剥掉的话，
   *   老文章里**每一款**标题都会被判成「不是标题」⇒ 编号被 renumberHeads 整片吞掉。
   *   字体同样只改观感、不参与识别签名（四款靠边框 / 颜色 / 装饰形状区分）。
   * ⚠️ 只有**识别**用它；applyHead 里「全部已是该标题 ⇒ 再点一次取消」仍比**完整配方**
   *   —— 老标题点一下就升级到新配方，而不会被误判成「已经设过了」。
   *   判据：**这字段是「长什么样」，还是「是不是它」？** 前者一律在这里剥掉。
   */
  function sigCss(css) {
    return String(css)
      .replace(/(?:^|;)\s*width\s*:[^;]*/g, '')
      .replace(/(?:^|;)\s*font-family\s*:[^;]*/g, '');
  }
  /*
   * toggle 判定专用的「身份签名」—— 只留**盒子声明**。
   *
   * ★ v2.6.33 新增。为什么不能直接复用上面的 sigCss：
   *   ① 宽严要求相反。sigCss 服务的 isHeadBlock 是**全篇识别**，判错会把
   *      编号静默吞掉（见上一段注释的血案）⇒ 它必须**严**；而 toggle 问的是
   *      「**我点的这一块**是不是这款」，判错的代价是「功能失灵」⇒ 它必须**稳**。
   *   ② 剥的东西不一样。sigCss 只剥 width / font-family；而 toggle 判定的
   *      致命项是 font-size / font-weight / line-height / color —— 这四条
   *      在保存链路上会被编辑器**下移到内层 span**（v2.6.31 现场：正文 span
   *      自带 font-size:16px，就是编辑器写的）⇒ 只要搬走一条，比完整配方的
   *      判定就恒为 false，**toggle 永久失效**。
   *
   * 留下的 border-left / border-bottom 有三个性质，正好是 toggle 需要的：
   *   · 是**盒子声明**，现场已证明块级能活过保存（装饰块四条声明一条不少）；
   *   · 是**长属性**（不会被 shorthand 展开成四条 longhand 而取不到值）；
   *   · 四款**两两可区分** —— 左 4px 红（#9F312A）/ 底 3px 实线 / 底 1px 实线
   *     / 左 4px 黑 + 底 1px 虚线。
   *
   * ⚠️ 正则里**绝不能出现 border 前缀**（那会把要留的两条一起剥掉）。
   *    margin / padding / width / background 一并剥掉：它们四款之间不构成
   *    身份差异（竖条与双线都有 padding-left，剥掉不影响区分）。
   */
  function headIdentCss(css) {
    return String(css).replace(
      /(?:^|;)\s*(?:(?:font|line-height|color|letter-spacing|width|margin|padding|background)[a-z-]*)\s*:[^;]*/g,
      '');
  }


  /*
   * 衬线标题的「压线红段」是一个没有文字、只负责显形的实色块。
   * 微信会剥 position / ::before，CSS 层面摆不出「细线下方压红段」，只能用真实节点。
   *
   * 识别只靠形态，**不挂 data-* 标记**：微信会把自定义属性整条剥掉，标记一旦
   * 留在产出物里就是白名单外的脏东西（会被清洗审计抓出来），而且剥掉之后
   * 识别就失灵，取消标题会留下一条孤儿红线。三个特征一起判，认得住：
   *   ① 是 SECTION ② 自身零行高 ③ 只有一个 SPAN 孩子，且它正是那块砖红短段。
   */
  function isSerifDeco(el) {
    if (!el || el.nodeType !== 1 || el.tagName !== 'SECTION') return false;
    if (!el.style || !/^0(px)?$/.test(el.style.lineHeight || '')) return false;
    var k = el.children, i;
    for (i = 0; i < SERIF_KEYS.length; i++) {
      var st = STYLES[SERIF_KEYS[i]];
      /* ★ v2.6.31 新形态：红段就在装饰块自身（width / height / background-color） */
      if (elHasCss(el, st.deco)) return true;
      /* 老形态：装饰块 + 内层 span 承载红段（v2.6.25~v2.6.30 的产出） */
      if (k && k.length === 1 && k[0].tagName === 'SPAN'
          && elHasCss(k[0], st.decoMark)) return true;
    }
    /* ★ v2.6.31 形态兜底：零行高 + 零字号 + 无文字。
       老文章的装饰块，内层 span 的样式被保存链路剥掉之后只剩这副骨架
       （现场样本 `section[margin:0 0 12px;height:3px;font-size:0;line-height:0;]`）。
       认不出的后果是实打实的：换款式 / 取消标题时留下**一条孤儿红线**。 */
    if (/^0(px)?$/.test(el.style.fontSize || '') && !hasContentText(el)) return true;
    return false;
  }

  function removeSerifDeco(block) {
    var n = block && block.nextSibling;
    while (n && n.nodeType !== 1) n = n.nextSibling;   // 跳过块之间的空白文本节点
    if (isSerifDeco(n)) { n.parentNode.removeChild(n); return true; }
    return false;
  }

  /*
   * 装饰块不是「段落」。块级操作取参时必须先把它摘出去，否则光标跨过一条
   * 已设成衬线标题的段落时，会有人试图把那条红线本身变成列表项或引用块。
   */
  function filterDeco(list) {
    var out = [];
    for (var i = 0; i < list.length; i++) {
      if (!isSerifDeco(list[i])) out.push(list[i]);
    }
    return out;
  }

  function insertSerifDeco(ctx, block, st) {
    st = st || STYLES.hSerif;                     // 不传就按一级，兼容老调用
    /* ★ v2.6.31：不再塞内层 span —— 那个 span 的盒子属性（display / width /
       height / background-color）在保存链路上**必被剥**，红段就是在那里消失的
       （现场取证：span 那几条全丢，而装饰块自己的四条声明完整存活）。
       红段现在由装饰块自身承担。 */
    var d = ctx.doc.createElement('section');
    d.setAttribute('style', st.deco);
    block.parentNode.insertBefore(d, block.nextSibling);
    return d;
  }

  function applyHead(key) {
    var st = STYLES[key];
    if (!st) return;
    var s = blockScope('请把光标放到要设为标题的段落里');
    if (!s) return;
    var ctx = s.ctx, blocks = s.blocks;

    /* 全部已是该标题 → 再点一次取消
     * ★ v2.6.33：判定改用 headIdentCss（只比 border）—— 理由见该函数注释。
     *  一句话：完整配方含**文字属性**，编辑器会把它们从块级搬到内层 span
     *  ⇒ 只要搬走一条，这里就恒为 false ⇒ 再点一次只是又应用一遍，
     *    用户看到的是「点了没反应 / 取消不掉」。而 border 是盒子声明，
     *    现场已证明块级能活过保存。
     *  ⚠️ 代价：「老配方点一次自动升级」取消 —— 按 toggle 点两下（取消 →
     *    重新生效）拿到的就是最新配方，正是用户规格里的循环。 */
    var all = true;
    for (var i = 0; i < blocks.length; i++) {
      if (!elHasCss(blocks[i], headIdentCss(st.css))) { all = false; break; }
    }
    if (all) {
      snapshot('取消标题');
      for (var j = 0; j < blocks.length; j++) {
        stripStyle(blocks[j], st.css);
        clearHeadTextMark(ctx, blocks[j]);      // ★ v2.6.26：文字级标记对称清（见 applyHeadTextMark）
        removePrefix(blocks[j]);
        if (st.mark === 'serif') removeSerifDeco(blocks[j]);
      }
      renumberHeads(ctx);   // ★ v2.6.25：取消后全篇编号顺延（幂等重排）
      toast('已取消「' + st.label + '」');
      return;
    }

    snapshot(st.label);
    for (var k = 0; k < blocks.length; k++) {
      var b = blocks[k];
      // 先清掉这一块上可能残留的其它标题样式 / 前缀 / 装饰，保证换款式时不叠加
      for (var h = 0; h < HEAD_KEYS.length; h++) {
        stripStyle(b, STYLES[HEAD_KEYS[h]].css);
        // 文字级标记统一由下方 applyHeadTextMark 处理（换款式不叠加）
      }
      removePrefix(b);
      removeSerifDeco(b);
      mergeStyle(b, st.css);
      applyHeadTextMark(ctx, b, st);                      // ★ v2.6.26：文字级字号/字重走 textstyle 标记
      trimBlockLeadBreak(ctx, b);                        // ★ v2.6.28：清掉块首空行（否则竖条会跨两行）
      if (st.mark === 'serif') insertSerifDeco(ctx, b, st);
    }
    trimHeadsLeadBreaks(ctx);   // ★ v2.6.29：全篇标题块块首清理（必须**先于**重排：编号落点依赖它）
    renumberHeads(ctx);     // ★ v2.6.25：按文档顺序重排全篇编号（01 / 02 / …）
    toast('已应用「' + st.label + '」');
  }

  /*
   * ══ 标题文字级字体声明（★ v2.6.23 提出根因；★ v2.6.26 改道 textstyle 标记）════════════════
   *
   * 【根因】编辑器给段落里**每一个 leaf span 都自带一份同属性声明**（font-size:16px;
   *   font-weight:normal;font-family:"mp-quote"…），子元素自己的声明压过父级继承 ⇒
   *   只把字号/字重写在容器上等于没写；而保存前编辑器按 doc model 重渲染，活 DOM 上的
   *   改动会被默认值覆盖（报告二·C：保存后内层回 16px/normal）。
   *   ⇒ 能活过保存的只有**写进 doc model 的标记**（与加粗同一条存活路径，v2.6.23~25 的
   *      headInnerApply 只改活 DOM、被重渲染吞掉，即本轮现场「标题保存后仍失效」的真因）。
   *
   * 【正解】选中标题文字，包成 `<span style="字号/字重"><span leaf>文字</span></span>`
   *   插回 DOM，编辑器把它重解析成 textstyle 标记写进文档模型。文字级声明只取行内
   *   7 属性白名单内的几项：font-size / font-weight / line-height / color / letter-spacing。
   *
   * 【★ v2.6.27 更正 —— 宋体不在本通道，**也没丢**】font-family 不在行内 7 属性里，
   *   ⇒ **文字级标记本来就带不了它**（textstyle 的 schema 边界，不是本修复造成的）。
   *   而「衬线一级」的宋体栈 `font-family:'SimSun','Songti SC','STSong',serif` 是随
   *   hSerif.css 由 mergeStyle(b, st.css) 写在**块级**上的 —— 走的是
   *   「写容器上就活、写行内标记上就死」那条通道（见 §7.6b 段旁证①②）。
   *   ⇒ 本修复只搬「字号 / 字重」，**与宋体无关，也未削弱宋体**。
   *   ⚠️ 别把「行内带不了 font-family」误读成「宋体丢了 / 衬线降级」——
   *      v2.6.26 的注释曾写下相反结论，与 §7.6b 的正确结论自相矛盾，v2.6.27 更正。
   *   ⏳ 仍需真机复验：编辑器给**内层 leaf span** 自带 `font-family:"mp-quote"…`
   *      （报告二·C），当场可能压过容器的宋体 ⇒ 编辑器预览里看不看得见宋体，待真机。
   *
   * 【编号 span】本脚本的 01/02 编号是块内灰色 span（isHeadNumSpan）。文字级标记只该作用于
   *   标题正文，故先 removeHeadNumDeep 摘掉编号，再由收尾的 renumberHeads 重加（不重号）。
   */
  // 挑出「行内 7 属性白名单内」的文字级声明。font-family 不在白名单 ⇒ 天然不输出；
  //   宋体走块级（hSerif.css + mergeStyle），不依赖这里 —— 别误读成「刻意剔掉了宋体」。
  function headFontCss(css) {
    var d = declsOf(css), out = [], k;
    /* ★ v2.6.31：font-family 也归「文字级」—— 标题的宋体不能只挂在块级：
       编辑器会给每个文字 span 补一份带 `font-family:"mp-quote",…` 的完整样式，
       那份**内层**声明会压过块级继承（现场样本 ×61）。字号与字体同一个理由：写到底。 */
    var ok = { 'font-size': 1, 'font-weight': 1, 'line-height': 1, 'color': 1, 'letter-spacing': 1,
               'font-family': 1 };
    for (k in d) { if (ok[k]) out.push(k + ':' + d[k]); }
    return out.length ? out.join(';') + ';' : '';
  }

  /*
   * 块内所有「文字载体」= 块自身 + 每一层**含文字**的元素（★ v2.6.31 新增）。
   *
   *   为什么要有这一层：编辑器会往**每个**文字 span 上补一份完整样式，
   *   其中就有 `font-size:16px` / `font-family:"mp-quote",…`。它们是标题块的
   *   子元素 ⇒ **内层压外层** ⇒ 无论我们在块级 section 上把 24px / 宋体写得多好，
   *   文字看到的仍是 16px / 黑体。现场表现就是「同一篇里标题字号一大一小」，
   *   与 v2.5.3「段落字体」踩的是同一个坑（见 paraFontState 长注）。
   *
   *   判定只用「谁直接装着文字节点」—— 不看标签名、不看 class：
   *     · 无文字的节点天然被排除 —— 装饰块、空 leaf、<br>、纯样式壳都不受影响；
   *     · 编号 span 与列表前缀显式跳过：它们是**标记**，不该吃标题的字号 / 字体。
   *
   *   ★ 为什么**只收直接含文字的**、不收「含文字的后代元素」那一类中间容器：
   *     ① 文字实际吃到样式的是**叶子**那层；覆盖它一个就够，副作用最小；
   *     ② **编号的落点常常就在某一层中间容器里** —— 现场形态「内层容器 + 首换行」
   *        `<section><section><span leaf=""><br>标题</span></section></section>`
   *        的编号正是插在**内层 section** 里的。一旦给中间容器写上
   *        font-size / font-weight / color，编号的祖先链上就冒出带字号的容器
   *        —— T57b 盯的就是这件事（编号被插进「文字标记容器」内、字号字色被覆盖）。
   *     ③ 块自身若是文字的父节点，它自然在列（块级配方本来就写过一遍，同值重复无害）。
   */
  function headTextCarriers(b) {
    var out = [];
    if (!b || b.nodeType !== 1) return out;
    var doc = b.ownerDocument || document;
    var w = doc.createTreeWalker(b, NodeFilter.SHOW_TEXT, null, false), n, p;
    while ((n = w.nextNode())) {
      if (!String(n.nodeValue || '').replace(/[\s\u00a0]/g, '')) continue;   // 纯空白不算
      p = n.parentNode;
      if (!p || p.nodeType !== 1) continue;
      if (isHeadNumSpan(p) || isPrefixSpan(p)) continue;                     // 标记不算文字
      if (out.indexOf(p) < 0) out.push(p);
    }
    return out;
  }

  // 按签名摘掉块内编号 span（renumberHeads 收尾会重加，故此处删净不会丢编号）
  // ★ v2.6.28：由「只扫直接孩子」改为**深度扫描** —— 编号现在会落在内层容器里
  //   （见 insertHeadNum 的长注）。只扫一层会漏掉它，那一串「01」就会被包进
  //   文字级标记里、变成标题文字的一部分。
  //   ⚠️ 这里**不用 walkEls**：它带 `isConnected` 守卫，在游离树上恒假且不抛错
  //   （本项目已因此哑过 9 个版本）—— 本函数只对已在文档里的标题块调用。
  function removeHeadNumDeep(block) {
    if (!block || block.nodeType !== 1) return 0;
    var all = [], i, n, k = 0;
    var doc = block.ownerDocument || document;
    var w = doc.createTreeWalker(block, NodeFilter.SHOW_ELEMENT, null, false);
    while ((n = w.nextNode())) all.push(n);
    for (i = all.length - 1; i >= 0; i--) {          // 自内向外摘，避免父子同时命中
      if (isHeadNumSpan(all[i]) && all[i].parentNode) {
        all[i].parentNode.removeChild(all[i]); k++;
      }
    }
    return k;
  }

  /*
   * ══ 标题文字级字号 / 字体：**不碰选区，直接改 DOM、写到底**（★ v2.6.31 重写）══
   *
   * 【旧实现为什么靠不住】v2.6.26 走的是「设选区 → insertHTMLAtCursor 插一层
   *   `<span style="…">`」。可受控编辑器会在我们设完选区之后重新接管，
   *   于是插进去的那层 span 里**是空的**（现场流水原样：
   *   `'<span style="font-size:24px;…"><span leaf=""></span></span>'`，文字留在了外面）
   *   ⇒ 全篇 8 个标题块只有 2 个碰巧包对，其余的字号全靠块级继承，而块级又被
   *   内层 span 自带的 16px 压住 ⇒ 「有的标题 24px、有的还是 16px」。
   *
   * 【新实现】直接遍历 headTextCarriers 写一份声明到**每一层文字载体**上：
   *   · 幂等 —— 重复点击只是把同样的值再写一遍；
   *   · 换款式时新的 fc 直接覆盖旧值 ⇒ 不需要额外的清除步骤；
   *   · 不看光标、不看选区 ⇒ 与编辑器的选区模型彻底解耦。
   */
  function applyHeadTextMark(ctx, b, st) {
    var fc = headFontCss(st.css);
    if (!fc) return 0;
    removeHeadNumDeep(b);                 // 编号先摘（它是标记，不该吃标题字号），renumberHeads 收尾重加
    var list = headTextCarriers(b), i;
    for (i = 0; i < list.length; i++) mergeStyle(list[i], fc);
    return list.length;
  }

  /*
   * 对称清（取消标题 / 换款式共用）：把**四款**的 fc 都从文字载体上剥掉。
   *   为什么遍历四款而不是只看当前款：换款式时块上可能残留**别的款**的 fc
   *   （用户的现场操作就是几款来回点），只剥当前款会留下脏值。
   *   只剥我们那几条（declsOf 里的属性名），编辑器自己写的属性一概不动。
   */
  function clearHeadTextMark(ctx, b) {
    removeHeadNumDeep(b);                 // 编号先摘（renumberHeads 收尾重加）
    var list = headTextCarriers(b), i, h, fc;
    for (i = 0; i < list.length; i++) {
      for (h = 0; h < HEAD_KEYS.length; h++) {
        fc = headFontCss(STYLES[HEAD_KEYS[h]].css);
        if (fc) stripStyle(list[i], fc);
      }
    }
    return list.length;
  }

  /* ── 7.5 换行辅助 ───────────────────────────────────────────────── */

  function insertBlankParagraph(before) {
    var g = pick(false, '请把光标放到段落里');
    if (!g) return;
    var ctx = g.ctx, range = g.range;
    var blk = firstBlock(range.startContainer, ctx.root);
    if (!blk) { toast('请把光标放到段落里'); return; }

    snapshot(before ? '段前空行' : '段后空行');
    var p = ctx.doc.createElement('p');
    p.setAttribute('style', 'margin:0 0 16px;');
    p.appendChild(ctx.doc.createElement('br'));
    blk.parentNode.insertBefore(p, before ? blk : blk.nextSibling);

    var r = ctx.doc.createRange();
    r.setStart(blk, 0);
    r.collapse(true);
    applySel(ctx, r);
    toast(before ? '已在段前插入空行' : '已在段后插入空行');
    return p;
  }

  // 把选中的多段合并为一段，段间用 n 个 <br> 连接
  function joinBlocks(n, label) {
    var g = pick(true, '请先跨两段以上选中文字');
    if (!g) return;
    var ctx = g.ctx, range = g.range;

    var blocks = selectedBlocks(range, ctx);
    if (blocks.length < 2) { toast('请选中两段以上的文字'); return; }

    var groups = groupByParent(blocks);
    var g = null;
    for (var i = 0; i < groups.length; i++) { if (groups[i].items.length >= 2) { g = groups[i]; break; } }
    if (!g) { toast('选中的段落不在同一层，换个范围试试'); return; }

    snapshot(label);
    var host = g.items[0];
    for (var j = 1; j < g.items.length; j++) {
      var cur = g.items[j];
      for (var k = 0; k < n; k++) host.appendChild(ctx.doc.createElement('br'));
      while (cur.firstChild) host.appendChild(cur.firstChild);
      if (cur.parentNode) cur.parentNode.removeChild(cur);
    }
    toast('已合并为' + label);
  }

  /* ── 7.6 字体 —— 【v2.4 整块删除】────────────────────────────────────
   *   原 fontByKey / fontEq / runsAllFont / applyFont 四个函数已删。
   *   删因见现场报告·五：七个字体按钮全部 nochange，font-family 不在编辑器方言里。
   *   要换字体请用编辑器自带的字体设置（那是块级 / 全选级能力）。
   * ──────────────────────────────────────────────────────────────── */

  /* ── 7.6b 段落字体（v2.6 新增 · A 档）─────────────────────────────── */

  /*
   * ══ 为什么是「段落」而不是「选中的那几个字」════════════════════════════
   *
   * 微信的行内标记白名单里**没有 font-family**（textstyle 只有 7 个属性：
   * fontSize / letterSpacing / backgroundColor / color / fontWeight /
   * fontStyle / textDecoration），所以「只给选中的十几个字换字体」在这条
   * 通道上**做不到** —— 写上去必被剥。
   *
   * 能活下来的只有**容器级**：与「衬线标题的宋体」「全局排版的字号」同一条路。
   *   · 旁证①：本脚本 hSerif 系列的 font-family:'SimSun' 一直是好的；
   *   · 旁证②：wechat-md 的思源宋体写在 container 上，交付后能生效。
   *
   * 所以按钮的语义是：**把选区覆盖到的段落，整段设为该字体**。
   * 粒度说清楚，不做「看起来只改了几个字」的假象。
   */

  /*
   * 段落字体的**完整**落地判据（v2.5.3 新增）。
   *
   * 【为什么必须有这一层】现场取证（用户 2026-09-20 报告 二·C）：
   *     section[font-family:"SourceHanSerifSC",…] ×4
   *     span[color:…;font-size:17px;font-family:"mp-quote","PingFangSC",…,sans-serif;…] ×5
   *   全篇 5 个段落，**每一个内层 span 都自带 font-family**。
   *   span 是 section 的子元素 ⇒ 它自己的 font-family 压过父级继承 ⇒
   *   **只在容器上写 font-family，在这个编辑器里等于没写。**
   *
   * 旧判据 `fontsEq(el.style.fontFamily, …)` 只看容器，
   *   于是内层还残留 mp-quote 时也报「已经是了」⇒ 用户第二点得到 nochange ⇒
   *   永远修不好，而日志上一句错话都没有。
   *
   * 返回值：
   *   'full'    容器与内层后代**都**是目标字体（真的生效了）
   *   'partial' 容器是目标字体，但内层还有带 font-family 的后代压着（＝看起来没效果）
   *   'none'    容器与内层都没有任何 font-family
   *   'other'   容器是**别的**字体
   */
  function paraFontState(el, css) {
    if (!el || !el.style) return 'none';
    var want = firstFamilyOf(css);
    var cur = firstFamilyOf(el.style.fontFamily);
    if (cur && want && cur !== want) return 'other';
    var inner = fontBearingDescendants(el);
    if (!cur) return inner.length ? 'partial' : 'none';
    // 容器已是目标字体：再看内层还有没有「带 font-family 且不是目标」的后代
    var i;
    for (i = 0; i < inner.length; i++) {
      var f = firstFamilyOf(inner[i].style && inner[i].style.fontFamily);
      if (!f) continue;
      if (!want || f !== want) return 'partial';
    }
    return 'full';
  }

  // 「已经是了」= 只有 full 才算 —— partial 必须继续写，否则第二点直接 nochange
  function paraHasFont(el, css) {
    if (!css) return false;
    return paraFontState(el, css) === 'full';
  }

  /*
   * 把段落字体**写到底**：容器 + 所有带/不带 font-family 的内层后代。
   *   为什么要连没写 font-family 的后代一起覆写：
   *   编辑器随时可能给某个 span 补一条 font-family（它自己的渲染习惯），
   *   补上那一刻就把我们的容器字体压回去了。一次性把该段落铺满，
   *   是让它「没有可回退的中间层」。
   *   只碰 font-family 一个属性（这是个字体按钮，顺手改字号 / 颜色会串味）。
   */
  function setParaFont(el, css) {
    if (!el || el.nodeType !== 1) return 0;
    var n = 0;
    try { el.style.setProperty('font-family', css); n++; } catch (e) {}
    var inner = fontBearingDescendants(el), i;
    for (i = 0; i < inner.length; i++) {
      try { inner[i].style.setProperty('font-family', css); n++; } catch (e2) {}
    }
    return n;
  }

  /*
   * 该段落内所有「能带 font-family 的行内后代」。
   *   只收行内标签（span / a / strong / em / u / s / b / i / del / ins / code /
   *   sub / sup / mark / small / font）—— 块级子元素（嵌套 section / 引用 / 列表）
   *   自成一段，不该被父段的字体顺过去（与「全局排版只碰正文段落」同一条纪律）。
   */
  var FONT_INNER_TAGS = {
    SPAN: 1, A: 1, STRONG: 1, B: 1, EM: 1, I: 1, U: 1, S: 1, DEL: 1, INS: 1,
    CODE: 1, SUB: 1, SUP: 1, MARK: 1, SMALL: 1, FONT: 1, VAR: 1, KBD: 1, SAMP: 1
  };
  function fontBearingDescendants(el) {
    var out = [];
    try {
      var all = el.querySelectorAll('*'), i;
      for (i = 0; i < all.length; i++) {
        var d = all[i];
        if (!d || !d.style) continue;
        if (!FONT_INNER_TAGS[d.tagName]) continue;   // 只收行内层
        out.push(d);
      }
    } catch (e) {}
    return out;
  }

  /*
   * ★ v2.6.11：只收「自己声明了该属性」的行内后代 —— 它们才是压住父级继承的竞争者。
   *
   *   依据（用户真机体检报告 二·C 五行样本）：
   *     span[color:rgba(0,0,0,0.9);font-size:17px;font-family:"mp-quote",…;line-height:1.6;…]
   *   编辑器给**每个 leaf span** 都自带 font-size 与 line-height ⇒
   *   段落容器上写 20px，文字实际仍是 17px。这与 v2.5.3 的字体问题是同一个病：
   *   **子元素自己的声明压过父级继承，只写容器等于没写，而日志里一句错话都没有。**
   *
   *   为什么只改「已有声明」的后代、不给靠继承的 span 凭空补一条：
   *     · 补上去只是把同样的值多写一遍，渲染完全相同 —— 纯噪音；
   *     · 不补就不会把 DOM 撑肥，也不会动到用户自己那些没写死样式的 span；
   *     · 而真正会「压住」我们的，恰恰只有已经声明了它的那些。
   */
  function declDescendants(el, prop) {
    var base = fontBearingDescendants(el), out = [], i;
    for (i = 0; i < base.length; i++) {
      var d = base[i];
      try {
        if (String(d.style.getPropertyValue(prop) || '').trim()) out.push(d);
      } catch (e) {}
    }
    return out;
  }

  /* 把容器上这条值**压到内层**去。返回被覆盖的后代数（0 = 内层没有竞争者） */
  function writeInnerDecl(el, prop, val) {
    var inner = declDescendants(el, prop), i, n = 0;
    for (i = 0; i < inner.length; i++) {
      try { inner[i].style.setProperty(prop, val); n++; } catch (e) {}
    }
    return n;
  }

  /*
   * 清字体（k === 'none'）：容器与内层一起清。
   *   不对称清理是上一版的另一个半拉子：用户点「清字体」后，
   *   容器干净了，内层 span 仍带着我们上一次写进去的字体 ⇒ 看上去"清不掉"。
   */
  function clearParaFont(el) {
    if (!el || el.nodeType !== 1) return 0;
    var n = 0;
    try {
      if (el.style && el.style.fontFamily) { el.style.removeProperty('font-family'); n++; }
    } catch (e) {}
    var inner = fontBearingDescendants(el), i;
    for (i = 0; i < inner.length; i++) {
      try {
        if (inner[i].style && inner[i].style.fontFamily) {
          inner[i].style.removeProperty('font-family'); n++;
        }
      } catch (e2) {}
    }
    return n;
  }

  // 取字体栈的首个族名（用于比对；浏览器会把 stack 归一化成逗号分隔）
  function firstFamilyOf(stack) {
    var s = String(stack == null ? '' : stack).split(',')[0] || '';
    return s.replace(/^["']|["']$/g, '').trim().toLowerCase();
  }

  function fontsEq(a, b) {
    return firstFamilyOf(a) === firstFamilyOf(b);
  }

  /*
   * 施加于选区覆盖到的段落（用 selectedBlocks —— 与引用 / 标题同一个选区口径）。
   *   返回 { n: 生效段落数, cleared: 清掉字体的段落数 }
   *   k === 'none' → 把 font-family **移除**（清掉，不留 ''），让微信回默认。
   *   只碰 font-family 一个属性，绝不追加别的声明：这是个"字体"按钮，
   *   顺手改字号 / 颜色会让用户没法把它当独立开关用。
   */
  function applyParaFont(k) {
    var ctx = needCtx(); if (!ctx) return;
    var css = fontCssOf(k);
    if (k !== 'none' && !css) { toast('未知字体：' + k); return; }
    var g = pick(false, '请先把光标放在要改字体的段落里');
    if (!g) return;
    var blocks = selectedBlocks(g.range, ctx);
    if (!blocks.length) {
      // 选区落在 root 之外（比如用户选了宿主自己的控件）—— 退一步按光标所在块处理
      var fb = firstBlock(g.range.startContainer, ctx.root);
      if (fb) blocks = [topLevel(fb, ctx.root)];
    }
    if (!blocks.length) { toast('选区内没有可处理的段落'); return; }

    snapshot('段落字体');
    var n = 0, cleared = 0;
    for (var i = 0; i < blocks.length; i++) {
      var el = blocks[i];
      if (!el || el.nodeType !== 1) continue;
      if (k === 'none') {
        /* ★ v2.5.3：容器与内层一起清 —— 只清容器会压不住内层残留 */
        if (clearParaFont(el)) cleared++;
      } else {
        /* ★ v2.5.3：判据换成 paraFontState ——
         *   'full' 才是「已经是了」；'partial'（容器对、内层还残留）必须继续写到底，
         *   否则第二次点直接 nochange，用户永远看不到效果。 */
        if (paraHasFont(el, css)) continue;
        if (setParaFont(el, css)) n++;
      }
    }
    var label = fontLabelOf(k);
    if (k === 'none') {
      toast(cleared ? ('已清掉 ' + cleared + ' 个段落的字体（回微信默认）')
                    : '这些段落本来就没设字体');
    } else if (n) {
      toast('已应用「' + label + '」：生效 ' + n + ' 个段落'
        + '　·　粒度是整段（微信行内不认 font-family，逐字换字体做不到）');
    } else {
      toast('这些段落已经是「' + label + '」了');
    }
    trace('pfont', label + ' · 段落 ' + blocks.length + ' 个 / 新写 ' + n + ' / 清除 ' + cleared);
  }

  function fontLabelOf(k) {
    for (var i = 0; i < FONTS.length; i++) { if (FONTS[i].k === k) return FONTS[i].label; }
    return k;
  }

  /*
   * 一键全篇字体 = applyGlobalDefault（见 7.7）—— 走的是「全局正文排版」面板，
   * 字体是其中一个字段。这里不再另做一个全篇按钮，避免两套入口口径不一致。
   */

  /* ── 7.7 全局默认排版 ───────────────────────────────────────────── */

  /*
   * 出厂值 = BASE（16px / 行距 1.8 / 段前 0 / 段后 0），用户改过的值会记住。
   *   为什么字号与段间距写绝对 px、行距写无单位倍数：
   *     微信用 em 会随两端基准字号漂移（后台与手机端基准不同），
   *     后台看着对、手机端就变了 —— 这是跨端富文本搬运的老坑。
   */
  var GPREF = { size: BASE.size, lh: BASE.lh, mt: BASE.mt, mb: BASE.mb, font: 'none' };

  function loadGlobalPref() {
    var o = null;
    try { o = GMX.get('globalPref', null); } catch (e) { o = null; }
    if (!o || typeof o !== 'object') return;
    var keys = ['size', 'lh', 'mt', 'mb'];
    for (var i = 0; i < keys.length; i++) {
      var v = parseFloat(o[keys[i]]);
      if (isFinite(v) && v >= 0) GPREF[keys[i]] = v;
    }
    // v2.6：全篇字体（键名必须在 FONTS 里，否则拉回「不写」）
    var fk = String(o.font == null ? 'none' : o.font);
    GPREF.font = fontCssOf(fk) || fk === 'none' ? fk : 'none';
    if (fk !== 'none' && !fontCssOf(fk)) GPREF.font = 'none';
    // 越界一律拉回出厂值（持久化数据可能被手改坏）
    if (!(GPREF.size >= 8 && GPREF.size <= 40)) GPREF.size = BASE.size;
    if (!(GPREF.lh >= 1 && GPREF.lh <= 4)) GPREF.lh = BASE.lh;
    if (!(GPREF.mt >= 0 && GPREF.mt <= 80)) GPREF.mt = BASE.mt;
    if (!(GPREF.mb >= 0 && GPREF.mb <= 80)) GPREF.mb = BASE.mb;
  }

  function saveGlobalPref() { try { GMX.set('globalPref', GPREF); } catch (e) {} }

  function globalPrefFields() {
    return [
      { k: 'size', label: '正文字号（px · 8–40，推荐 ' + BASE.size + '）', value: String(GPREF.size) },
      { k: 'lh', label: '行距（无单位倍数 · 1–4，推荐 ' + BASE.lh + '）', value: String(GPREF.lh) },
      { k: 'mt', label: '行前间距（px · 0–80，推荐 0 = 不干预）', value: String(GPREF.mt) },
      { k: 'mb', label: '行后间距（px · 0–80，推荐 ' + BASE.mb + ' ≈ 0.46 × 行高）', value: String(GPREF.mb) },
      { k: 'font', label: '全篇字体（' + fontLabelList() + '）', value: String(GPREF.font) }
    ];
  }

  /* 「全篇字体」的候选项自述（写进字段标签，用户照着敲键名即可） */
  function fontLabelList() {
    var out = [];
    for (var i = 0; i < FONTS.length; i++) out.push(FONTS[i].k + '=' + FONTS[i].label);
    return out.join(' / ');
  }

  /*
   * ── 全局正文排版：只作用于「纯正文段落」（v2.3 换白名单）──────────────
   * 旧实现是**黑名单**：跳过引用 / 标题 / 装饰块 / 列表项，其余全写。
   * 现场报告的流水（「固化 19 个节点」，样本 section×22 / li×19 / ul / ol）
   * 说明黑名单的漏网面不可控 —— 表格、图片、分割线、宿主自己的容器都会被写。
   *
   * 现在反过来只认「纯正文段落」，四条判据缺一不可：
   *   ① 标签是 P / DIV / SECTION，且不在跳过表里；
   *   ② 不是引用块、也不在引用块内部；
   *   ③ 不是标题（9 档任一）、不是衬线装饰块；
   *   ④ **没有块级子元素** —— 有就说明它是容器而不是段落，往里写字号会顺着
   *      继承落到它内部的标题 / 引用上，那正是「对块内容生效」。
   */
  var GPREF_SKIP_TAGS = {
    TABLE: 1, THEAD: 1, TBODY: 1, TFOOT: 1, TR: 1, TD: 1, TH: 1,
    UL: 1, OL: 1, LI: 1, BLOCKQUOTE: 1, PRE: 1, FIGURE: 1, FIGCAPTION: 1,
    H1: 1, H2: 1, H3: 1, H4: 1, H5: 1, H6: 1, HR: 1, IMG: 1
  };

  /*
   * ★ v2.6.17：识别「表格作用域」—— 本脚本重建的圆角表格容器，或用户原生 <table>。
   *   为什么需要它：一键最佳排版 / 全局正文排版走的是「给正文段落写字号行距」，
   *   而 isBodyParaOf 认得的是段落形态，表格容器（section + display:flex）不在它的排除名单里
   *   —— 表格会被当成一个正文段落，被写上行距与段后距；更糟的是 writeInnerDecl 会**写到底**，
   *   把单元格里声明过 font-size 的行内后代一起改成正文号 ⇒ 表格的字号层级整个塌掉。
   *   用户诉求：「一键最佳排版适用的内容不包含表格」⇒ 在遍历口上直接跳过（子树一并不进）。
   */
  function inTableScope(el, root) {
    var p = el;
    while (p && p !== root) {
      if (p.tagName === 'TABLE') return true;
      if (isFlexTableBox(p)) return true;
      p = p.parentNode;
    }
    return false;
  }

  function isBodyParaOf(el, root) {
    if (!el || el.nodeType !== 1) return false;
    if (el === root) return false;
    if (GPREF_SKIP_TAGS[el.tagName]) return false;
    if (el.tagName !== 'P' && el.tagName !== 'DIV' && el.tagName !== 'SECTION') return false;
    if (isQuoteEl(el) || quoteAncestorOf(el, root)) return false;
    if (isHeadBlock(el)) return false;
    if (isSerifDeco(el)) return false;
    if (elHasCss(el, STYLES.li.css) || elHasCss(el, STYLES.oli.css)) return false;
    var ks = elemKids(el);
    for (var i = 0; i < ks.length; i++) {
      if (isBlockEl(ks[i], root)) return false;
    }
    return true;
  }

  /*
   * 只写 font-size 与 line-height 两个属性（v2.6 起增加可选的 font-family）。
   *   · 不再写 font-family / color —— 用户要求「仅对正文字号、行距进行生效」；
   *   · 行前 / 行后间距为 0 时**完全不写 margin**（0 = 不干预），填正数才写。
   *     这样默认那套「16 / 1.8 / 0 / 0」落地后，段落上不会多出任何多余声明。
   *   · 容器 root 上一个字都不写：容器一旦带上 font-size，引用块 / 列表里没有
   *     显式字号的文字会顺着继承一起变 —— 那就等于对块内容生效了。
   * 返回生效段落数，交给 toast 报出来，误伤与否一眼可查。
   */
  function applyGlobalPref(ctx) {
    var fs = GPREF.size, lh = GPREF.lh, n = 0, fFont = fontCssOf(GPREF.font);
    walkEls(ctx.root, function (el) {
      if (!isBodyParaOf(el, ctx.root)) return;
      if (inTableScope(el, ctx.root)) return;   // ★ v2.6.17 表格一律不动
      el.style.setProperty('font-size', fs + 'px');
      el.style.setProperty('line-height', String(lh));
      /*
       * ★ v2.6：font-family 也写在这里 —— 与字号 / 行距**同一条容器通道**。
       *   这是本任务（A+C）的核心：字体只有写在段落容器上才不会被微信剥掉。
       *   'none' = 不写（不干预，也不清掉用户已有的字体）。
       */
      /*
       * ★ v2.5.3：字体必须**连内层一起写**。
       *   现场取证（用户报告 二·C）：编辑器给每一个内层 span 都自带
       *   `font-family:"mp-quote","PingFangSC",…` —— 子元素自己的声明
       *   压过父级继承 ⇒ 只写容器时「设置了字体但看不到效果」。
       *   字号 / 行距写在容器上有效，是因为它们在内层 span 里没有对手；
       *   字体不是 —— span 自己也写了一份。这是字体与字号的关键差别。
       */
      /*
       * ★ v2.6.11：字号 / 行距也要**写到底**，与字体同一条纪律。
       *   编辑器给每个 leaf span 都自带 `font-size:17px;line-height:1.6`
       *   （v2.6.0 报告 二·C 五例），子元素自己的声明压过父级继承 ——
       *   只写容器时，用户把字号改成 20px，手机上文字仍是 17px，
       *   而流水里一句错话都没有（与 v2.5.3 那次字体同构）。
       */
      writeInnerDecl(el, 'font-size', fs + 'px');
      writeInnerDecl(el, 'line-height', String(lh));
      if (fFont) setParaFont(el, fFont);
      /*
       * ★ v2.6.11：段间距改成**对称清理** —— 填 0 表示「清掉」，不再是「跳过」。
       *   旧写法只在 > 0 时 setProperty，等于 0 时什么都不做 ⇒ 用户把行前间距
       *   从 31 改回 0，段落上那条 margin-top:31px 还挂着 —— 看起来就是
       *   「这个输入框不生效」。这与 v2.5.3 修过的「清字体清不掉」是同一类
       *   半拉子：**只有写、没有对偶的清**。
       */
      if (GPREF.mt > 0) el.style.setProperty('margin-top', GPREF.mt + 'px');
      else { try { el.style.removeProperty('margin-top'); } catch (e3) {} }
      if (GPREF.mb > 0) el.style.setProperty('margin-bottom', GPREF.mb + 'px');
      else { try { el.style.removeProperty('margin-bottom'); } catch (e4) {} }
      n++;
    });
    return n;
  }

  function applyGlobalDefault() {
    var ctx = needCtx(); if (!ctx) return;
    loadGlobalPref();
    openDialog({
      title: '全局正文排版',
      msg: '只作用于正文段落的字号、行距与段间距；标题、引用块、列表、图片、表格一律不动。间距填 0 = 清掉该段落上已有的同类 margin。',
      fields: globalPrefFields(),
      /* v2.6.11：由「恢复默认」改名为「填入推荐值」，并且**不再动字体字段** ——
       *   字体是另一个维度，排版预设顺手把用户选的字体抹掉是越界；
       *   数值一律取自 BASE，与「一键最佳排版」同一个来源，不会各写一份。 */
      extra: [{
        text: '填入推荐值 ' + BASE.size + ' / ' + BASE.lh + ' / ' + BASE.mt + ' / ' + BASE.mb,
        fn: function (inputs) {
          GPREF.size = BASE.size; GPREF.lh = BASE.lh; GPREF.mt = BASE.mt; GPREF.mb = BASE.mb;
          if (!inputs) return;
          try {
            inputs.size.value = String(GPREF.size);
            inputs.lh.value = String(GPREF.lh);
            inputs.mt.value = String(GPREF.mt);
            inputs.mb.value = String(GPREF.mb);
          } catch (e) {}
        }
      }],
      okText: '套用',
      ok: function (v) {
        function num(k, d, lo, hi) {
          var n = parseFloat(v[k]);
          if (!isFinite(n)) n = d;
          return Math.min(hi, Math.max(lo, n));
        }
        GPREF.size = num('size', BASE.size, 8, 40);
        GPREF.lh = num('lh', BASE.lh, 1, 4);
        GPREF.mt = num('mt', BASE.mt, 0, 80);
        GPREF.mb = num('mb', BASE.mb, 0, 80);
        // 字体：键名不在清单里一律拉回「不写」，不静默写一个用户没选的字体
        var wantF = String(v.font == null ? '' : v.font).trim();
        GPREF.font = (wantF === 'none' || fontCssOf(wantF)) ? wantF : 'none';
        saveGlobalPref();
        snapshot('全局默认');
        var pn = applyGlobalPref(ctx);
        var fName = '';
        for (var fi = 0; fi < FONTS.length; fi++) { if (FONTS[fi].k === GPREF.font) fName = FONTS[fi].label; }
        toast('已套用：正文 ' + GPREF.size + 'px / 行距 ' + GPREF.lh
          + (fName ? ' / 字体 ' + fName : '')
          + '　·　生效 ' + pn + ' 个正文段落'
          + (GPREF.mt > 0 || GPREF.mb > 0
            ? '　·　行前 ' + GPREF.mt + ' / 行后 ' + GPREF.mb + 'px' : ''));
      }
    });
  }

  /*
   * ── 7.8 一键最佳排版（v2.6.11）─────────────────────────────────────
   *
   * 与「全局默认」的分工：
   *   「全局默认」  = 面板 —— 先看值、可改、再点套用（两下）。
   *   「一键最佳」  = 一次点击，把参数复位成出厂那套最佳阅读参数并立即套用。
   *
   * 数值来源就是 BASE —— 与面板里那颗「填入推荐值」同一个常量，
   *   两处不会各写一份数字、改一处忘一处。
   * 只动四项排版参数，**不动全篇字体**（理由见 applyGlobalDefault 的 extra 注释）。
   */
  function applyBestPreset() {
    var ctx = needCtx(); if (!ctx) return;
    GPREF.size = BASE.size; GPREF.lh = BASE.lh;
    GPREF.mt = BASE.mt; GPREF.mb = BASE.mb;
    saveGlobalPref();
    snapshot('一键最佳排版');
    var pn = applyGlobalPref(ctx);
    toast('最佳阅读参数已套用：正文 ' + BASE.size + 'px / 行距 ' + BASE.lh
      + ' / 段后 ' + BASE.mb + 'px　·　生效 ' + pn + ' 个正文段落'
      + (GPREF.font === 'none' ? '' : '　·　字体保持你当前的选择'));
  }

  /* ── 7.9 清除格式 ───────────────────────────────────────────────── */

  function clearFormat() {
    var ctx = needCtx(); if (!ctx) return;
    var g = grabRange(false);
    var range = g.range;
    var scoped = !!(range && !range.collapsed);

    function cleanBlock(el) {
      stripStyle(el, STYLES.li.css);
      stripStyle(el, STYLES.oli.css);
      for (var h = 0; h < HEAD_KEYS.length; h++) stripStyle(el, STYLES[HEAD_KEYS[h]].css);
      removePrefix(el);
    }

    openConfirm(
      scoped ? '清除选中文字的格式' : '清除全文排版格式',
      scoped
        ? '将剥掉选中范围内的行内样式包裹（含链接）与段落级样式，文字本身保留。'
        : '将剥掉全文所有行内样式包裹与段落级样式（含引用、列表、标题），文字本身保留。此操作影响较大。',
      function () {
        snapshot('清除格式');
        var killed = 0;
        walkEls(ctx.root, function (el) {
          var hit = !scoped;
          if (scoped) { try { hit = range.intersectsNode(el); } catch (e) { hit = false; } }
          if (!hit) return;
          // 衬线标题的红段是个「空的实色 span」——unwrap 掉只会剩一条空白，
          // 它得跟装饰块一起走，不能单独剥。
          if (isSerifDeco(el.parentNode)) return;
          // ★ v2.6.25：编号 span 由收尾的 renumberHeads 统一摘 ——
          // 走了 unwrap 就剩一串裸文本「01」，反而清不掉。
          if (isHeadNumSpan(el)) return;
          if (isPureStyleSpan(el) || el.tagName === 'A') { unwrap(el); killed++; }
        });
        // 装饰块不是段落，cleanBlock 清不掉它本身，单独收集后统一摘除
        // （先收集再删，避免在 walkEls 遍历过程中改动树）
        var decos = [];
        walkEls(ctx.root, function (el) { if (isSerifDeco(el)) decos.push(el); });
        if (scoped) {
          var blocks = selectedBlocks(range, ctx);
          for (var i = 0; i < blocks.length; i++) cleanBlock(blocks[i]);
        } else {
          walkEls(ctx.root, function (el) {
            if (!isBlockEl(el, ctx.root)) return;
            cleanBlock(el);
          });
        }
        for (var q = 0; q < decos.length; q++) {
          var de = decos[q];
          var inScope = !scoped;
          if (scoped) { try { inScope = range.intersectsNode(de); } catch (e) { inScope = false; } }
          if (inScope && de.parentNode) de.parentNode.removeChild(de);
        }
        // ★ v2.6.25：清完格式后全篇重排编号 —— 不再是标题的块，编号自动摘掉；
        //   剩下的一级标题重新从 01 起编（幂等，随时点一次都对）。
        renumberHeads(ctx);
        toast('已清除格式（处理 ' + killed + ' 处）');
      }
    );
  }

  /* ── 7.10 清除空行（v2.6.32）────────────────────────────────────── */

  /*
   * 「空行」= 一个**块级元素**：里面没有一个可见文字，也没有任何承载物。
   * 现场形态就是微信编辑器按回车留下的那几种：
   *     <p style="margin:0 0 16px;"><br></p>          ← 最常见
   *     <p style="margin:0 0 16px;"><span leaf=""><br></span></p>
   *     <section style="margin:0 0 16px;"></section>   ← 完全空壳
   *
   * ★ 一次遍历就够，不需要多轮：walkEls 是**先序**（父在前），
   *   <section><p><br></p></section> 里父被摘掉时子已随父离树，
   *   轮到子时它的 isConnected 已为假 ⇒ walkEls 自己就跳过了。
   *   所以「先收后删」的循环体在这里是多余的（本轮真写过一版多轮扫，
   *   逐项对照后删掉：那一版在夹具上没有一条**只**靠它才过的断言）。
   *
   * 三个「不动」的口径。前两个来自需求（不含表格、引用块），第三个是判据的必然：
   *   ① **表格**：整张表连内部空格一起跳过。表格是 section + display:flex 重建的，
   *      空单元格跟空段落在结构上长得一模一样 —— 只按「有没有文字」判，
   *      会把空单元格连同边框一起删掉（表就破相了）。判据直接复用 v2.6.17
   *      为「一键最佳排版不得动表格」写的 inTableScope，不另造一套。
   *   ② **引用块**：引用块自身与内部一律不动 —— 与表格同理，容器无文字时也不该消失。
   *      本脚本的四种引用是 section，另外把原生 <blockquote> 也一起认下。
   *   ③ **承载物**：块里哪怕一个字都没有，只要含图片 / 分隔线 / 媒体 / 行内小件（<a>），
   *      就不是空行 —— 图片段天生没有文字，只看文字会把它整段删掉。
   *
   * ★ 刻意**不动裸 <br>**：编辑器根下直接挂的 <br> 只占半行、且常是「软换行」的真实内容，
   *   与「空段落」不是一回事。清空行只清块，半行不动。
   */

  // 表格 / 引用块作用域（含自身）—— 这两处一律不动
  function inProtectedScope(el, root) {
    if (inTableScope(el, root)) return true;
    var p = el;
    while (p && p !== root) {
      if (p.tagName === 'BLOCKQUOTE' || isQuoteEl(p)) return true;
      p = p.parentNode;
    }
    return false;
  }

  function isEmptyLineBlock(el, root) {
    if (!el || el.nodeType !== 1 || el === root) return false;
    if (!isBlockEl(el, root)) return false;
    if (isSerifDeco(el)) return false;              // 衬线标题的压线红段：天生无文字
    /* 承载物：它们天生不带文字，不能当成空行删掉。
       表放在函数里（而不是模块级）是有意的 —— 代价只是「每个候选块重建一个 11 键小对象」，
       换来的是「抽函数注入的装置世界也不会因为少带一个 var 而 ReferenceError」
       （v2.6.3 那次 50 条 FAIL 的教训：环境残缺会装成业务失败）。 */
    var KEEP = { IMG: 1, HR: 1, TABLE: 1, IFRAME: 1, VIDEO: 1, AUDIO: 1,
                 SVG: 1, CANVAS: 1, A: 1, INPUT: 1, BUTTON: 1 };
    var all = [], i;
    (function col(n) {
      var k;
      for (k = 0; k < n.children.length; k++) { all.push(n.children[k]); col(n.children[k]); }
    })(el);
    for (i = 0; i < all.length; i++) {
      if (KEEP[all[i].tagName]) return false;
      if (isSerifDeco(all[i])) return false;
    }
    /* 文字：剥掉空白与零宽字符后必须为空（&nbsp; 也算空 —— 它就是空行） */
    return !String(el.textContent || '').replace(/[\s\u00a0\u200b\u200c\u200d\ufeff]/g, '');
  }

  function clearEmptyLines() {
    var ctx = needCtx(); if (!ctx) return;
    snapshot('清除空行');
    var n = 0;
    walkEls(ctx.root, function (el) {
      if (!el.parentNode) return;
      if (inProtectedScope(el, ctx.root)) return;
      if (!isEmptyLineBlock(el, ctx.root)) return;
      el.parentNode.removeChild(el); n++;
    });
    toast(n ? ('已清除 ' + n + ' 处空行') : '没有找到空行');
  }

  /* ══════════════════════════════════════════════════════════════════
   * 8. 媒体粘贴 —— 图片继续走编辑器原生上传通道；外来 HTML 走白名单清洗
   * ══════════════════════════════════════════════════════════════════ */

  var WX_IMG_HOST = /(mmbiz\.qpic\.cn|mmbiz\.qlogo\.cn|wx\.qlogo\.cn|mmbiz\.qpic\.cn)/i;

  var TAG_MAP = {
    B: 'span', STRONG: 'span', I: 'span', EM: 'span', U: 'span',
    DEL: 'span', S: 'span', STRIKE: 'span', MARK: 'span', SMALL: 'span',
    CODE: 'span', KBD: 'span', TT: 'span', PRE: 'section',
    /* ★ v2.6.13：DIV 由 'p' 改 'section' —— 修好下面那个恒假正则之后，
       div 会真的变成 <p>，而它的子元素常是块级（段落/列表/表格）⇒ 非法嵌套，
       浏览器序列化时会把 <p> 拆开、留下一个空段。section 装块级没有这个问题，
       也与 ARTICLE/HEADER/NAV/ASIDE/MAIN 的映射保持一致。 */
    DIV: 'section', SECTION: 'section', ARTICLE: 'section', HEADER: 'section',
    FOOTER: 'section', NAV: 'section', ASIDE: 'section', MAIN: 'section',
    BLOCKQUOTE: 'section', FIGURE: 'section', FIGCAPTION: 'p',
    UL: 'section', OL: 'section', LI: 'p',
    H1: 'p', H2: 'p', H3: 'p', H4: 'p', H5: 'p', H6: 'p',
    TABLE: 'section', THEAD: 'section', TBODY: 'section', TFOOT: 'section',
    TR: 'p', TD: 'span', TH: 'span', CAPTION: 'p', COLGROUP: 'span', COL: 'span',
    VIDEO: 'section', AUDIO: 'section', SOURCE: 'span', TRACK: 'span',
    HR: 'section', FORM: 'section', INPUT: 'span', BUTTON: 'span', LABEL: 'span',
    IFRAME: 'span', SVG: 'span', CANVAS: 'span', NOSCRIPT: 'span'
  };

  var TAG_CSS = {
    B: 'font-weight:700;', STRONG: 'font-weight:700;',
    I: 'font-style:italic;', EM: 'font-style:italic;',
    DEL: 'text-decoration:line-through;', S: 'text-decoration:line-through;', STRIKE: 'text-decoration:line-through;',
    U: 'border-bottom:2px solid #9F312A;',
    MARK: 'background-color:#FBF3B2;',
    H1: 'font-size:22px;font-weight:700;', H2: 'font-size:20px;font-weight:700;',
    H3: 'font-size:18px;font-weight:700;', H4: 'font-size:17px;font-weight:700;',
    H5: 'font-size:16px;font-weight:700;', H6: 'font-size:16px;font-weight:700;',
    LI: 'padding-left:1.4em;text-indent:-1.4em;',
    BLOCKQUOTE: 'margin:0 0 16px;padding:14px 18px;background-color:#F4F4F5;border-left:4px solid #1A1A1A;'
  };

  var KEEP_STYLE = {};
  ('color,background-color,background-image,font-size,font-weight,font-style,font-family,'
    + 'text-decoration,text-align,text-indent,text-shadow,line-height,letter-spacing,word-break,white-space,'
    + 'margin,margin-top,margin-bottom,margin-left,margin-right,'
    + 'padding,padding-top,padding-bottom,padding-left,padding-right,'
    + 'border,border-top,border-bottom,border-left,border-right,border-radius,'
    + 'border-width,border-style,border-color,border-left-width,border-left-style,border-left-color,'
    + 'border-bottom-width,border-bottom-style,border-bottom-color,'
    /* ★ v2.6.13 新增：box-sizing / flex* / gap —— 圆角表格的列宽必须靠 box-sizing
       把 padding 计入 width，否则每格 33.33% + 24px 内距会撑破容器。
       这几个属性的存活有**线上实证**（见 TBL 常量注释）：该文正文里
       box-sizing 156 处、flex-shrink 5 处、gap 5 处，全部活着。 */
    + 'display,width,height,max-width,min-width,vertical-align,box-shadow,opacity,overflow,list-style,'
    + 'box-sizing,flex,flex-grow,flex-shrink,flex-basis,gap,align-items,justify-content')
    .split(',').forEach(function (p) { KEEP_STYLE[p] = 1; });

  function cleanForeignHTML(ctx, html) {
    var doc = ctx.doc;
    var box = doc.createElement('div');
    box.innerHTML = html;

    /* ★ v2.6.13：**先**重建表格，再走通用清洗。
       必须在 TreeWalker 之前 —— 通用清洗会把 TABLE->section / TR->p / TD->span
       拍平成散架结构，拍平之后就再也取不回行列信息了。 */
    rebuildTables(doc, box);

    var all = [], n;
    var w = doc.createTreeWalker(box, NodeFilter.SHOW_ELEMENT, null, false);
    while ((n = w.nextNode())) all.push(n);

    for (var i = 0; i < all.length; i++) {
      var el = all[i];
      if (!el.isConnected && !box.contains(el)) continue;
      var tag = el.tagName;

      // 危险 / 无意义标签直接删除（连同文本），避免把脚本源码当正文搬进来
      if (tag === 'SCRIPT' || tag === 'STYLE' || tag === 'NOSCRIPT' || tag === 'LINK'
        || tag === 'META' || tag === 'BASE' || tag === 'OBJECT' || tag === 'EMBED'
        || tag === 'TEMPLATE' || tag === 'HEAD' || tag === 'TITLE') {
        if (el.parentNode) el.parentNode.removeChild(el);
        continue;
      }

      if (tag === 'IMG') {
        var src = el.getAttribute('src') || '';
        if (!WX_IMG_HOST.test(src)) {
          // 外来图床无法在微信正文引用，直接丢弃占位说明
          var ph = doc.createElement('span');
          ph.setAttribute('style', 'color:#B36738;');
          ph.textContent = '［外来图片，请用编辑器图片按钮重新上传］';
          el.parentNode.replaceChild(ph, el);
          continue;
        }
        var keep = doc.createElement('img');
        keep.setAttribute('src', src);
        if (el.getAttribute('alt')) keep.setAttribute('alt', el.getAttribute('alt'));
        keep.setAttribute('style', 'max-width:100%;');
        el.parentNode.replaceChild(keep, el);
        continue;
      }
      if (tag === 'BR') continue;

      // ★ v2.6.22：正常路径下这里**不该再遇到 <table>** —— 上面的 rebuildTables() 已经把所有
      //   「真表格」重建成 section + flex 行（圆角随之落在那一层上）。能走到这儿还带着 <table>
      //   的，只有 buildFlexTable 认不出的那几种（>60 行 / >8 列 / 重建失败）⇒ 整棵子树跳过
      //   通用清洗，原样交给微信，**绝不静默拍平丢内容**。
      //   退化 1×1 壳仍交回通用清洗拍成段落（壳是复制粘贴的边角产物，不该当表格）。
      if (tag === 'TABLE' || (el.closest && el.closest('table'))) {
        var _t = (tag === 'TABLE') ? el : (el.closest ? el.closest('table') : null);
        if (_t && isRealTable(_t)) continue;
      }

      var mapped = TAG_MAP[tag] || 'span';

      // 收集允许保留的内联样式
      var keepDecl = '';
      var rawStyle = el.getAttribute('style') || '';
      var d = declsOf(rawStyle);
      for (var p in d) {
        if (KEEP_STYLE[p]) keepDecl += p + ':' + d[p] + ';';
      }
      if (TAG_CSS[tag]) keepDecl = TAG_CSS[tag] + keepDecl;

      /*
       * ★ v2.6.13 修一个**恒假分支**（本轮做圆角表格时被逼出来的）：
       *   原来是 `/^(P|SECTION)$/.test(mapped)` —— 但 TAG_MAP 的值全是**小写**
       *   （'p' / 'section' / 'span'…），大写正则永不匹配 ⇒ 这一支从未执行过，
       *   **所有元素一律退化成 span**。
       *   同族教训见踩坑日志「正确分支排在无条件兜底之后 ⇒ 静默永不执行」——
       *   这里不是排在后面，是**条件恒假**，一样没有断言看守。
       *
       *   后果（对外来粘贴）：整段文章被压成一团行内 span，段落结构全丢；
       *   更要命的是块级容器拿不到块级身份 —— `overflow:hidden` 在行内元素上
       *   **不生效**，圆角外壳就裁不出四角（本轮实测：样式全对、四角仍是直角）。
       *
       *   修法：按 TAG_MAP 的原意建 p / section；DIV 改映射到 section（见 TAG_MAP
       *   处注释）—— `<p>` 里嵌块级子元素是非法嵌套，浏览器会把它拆开留出空段。
       */
      var nu = doc.createElement(/^(p|section)$/i.test(mapped) ? mapped : 'span');
      if (keepDecl) nu.setAttribute('style', norm(keepDecl));
      // 其它属性（class/id/data-*）一律不带 —— 微信本来也会剥，这里提前清干净
      while (el.firstChild) nu.appendChild(el.firstChild);
      el.parentNode.replaceChild(nu, el);
    }

    // 去掉连续空段与首尾空段
    var kids = box.querySelectorAll('p, section');
    for (var j = kids.length - 1; j >= 0; j--) {
      var k = kids[j];
      if (!k.textContent.replace(/\s/g, '') && !k.querySelector('img') && !k.querySelector('br')) {
        k.parentNode.removeChild(k);
      }
    }
    return box.innerHTML;
  }

  /* ══════════════════════════════════════════════════════════════════
   * 7.85 表格重建与配色（v2.6.13 · 粘贴增强）
   *
   * 【做法来源】抓了一篇已发布公众号文章的原始 HTML 逐属性统计：
   *   它那张"表格"里 <table> / <tr> / <td> 计数**全为 0** —— 是 section +
   *   display:flex 拼出来的。圆角靠**包裹式两件套**（缺一不可）：
   *     ① 外层 border-radius   ② 外层 overflow:hidden
   *   缺 ② 时子元素的矩形背景会把四角盖回直角 —— 这正是该文正文里
   *   `overflow: hidden` **只出现 1 次**的原因（专为这个圆角容器加的）。
   *
   * 【为什么敢用 flex】先前把"清洗禁区"记成 flex，**记错了**（被剔的是 float）。
   *   线上实证：display:flex 存活 8 处、flex-shrink 5、gap 5、box-sizing 156；
   *   且它们挂在**块级 section** 上，不受「行内只有 7 个属性」那条约束。
   *
   * 【与既有通道的关系】不改动 TAG_MAP —— 那里仍然把 TABLE 映射成 section。
   *   本节的流程是**先重建、再清洗**：重建成 section 结构后，通用清洗循环会
   *   按 KEEP_STYLE 把我们的声明原样保住（这也是为什么必须先加 box-sizing）。
   * ══════════════════════════════════════════════════════════════════ */

  /* ★ v2.6.22：`radius` 已从 TPREF 移除 —— 圆角恒为 `TBL.radius`（10px），不再可调。 */
  var TPREF = { color: TBL.color, head: TBL.head, zebra: TBL.zebra };

  function loadTablePref() {
    var o = null;
    try { o = GMX.get('tablePref', null); } catch (e) { o = null; }
    if (!o || typeof o !== 'object') return;
    var c = String(o.color == null ? '' : o.color).trim();
    if (/^#[0-9a-fA-F]{6}$/.test(c)) TPREF.color = c.toUpperCase();
    TPREF.head = String(o.head) === '0' ? 0 : 1;
    TPREF.zebra = String(o.zebra) === '0' ? 0 : 1;
    // 越界一律拉回出厂值（持久化数据可能被手改坏）
    if (!/^#[0-9a-fA-F]{6}$/.test(TPREF.color)) TPREF.color = TBL.color;
    /* ★ v2.6.22：存档里的旧 radius 直接忽略（圆角不再进 TPREF）。 */
  }

  function saveTablePref() { try { GMX.set('tablePref', TPREF); } catch (e) {} }

  function tblPresetOf(hex) {
    var h = String(hex || '').toUpperCase(), i;
    for (i = 0; i < TBL.presets.length; i++) {
      if (String(TBL.presets[i].hex).toUpperCase() === h) return TBL.presets[i];
    }
    return null;
  }

  /*
   * 主色按 k 比例混白（k = 主色占比）。**只在用户自选主色、没有成对预设值时兜底** ——
   * 实测该文分隔线的 G/B 通道在 20% 混白时精确吻合、R 差 8，说明设计值不是纯公式产物，
   * 所以预设色板直接给成对搭配值。
   */
  function tblMix(hex, k) {
    var m = /rgb\((\d+),\s*(\d+),\s*(\d+)\)/.exec(hexToRgbStr(hex));
    if (!m) return '#FFFFFF';
    var r = Math.round(parseFloat(m[1]) * k + 255 * (1 - k));
    var g = Math.round(parseFloat(m[2]) * k + 255 * (1 - k));
    var b = Math.round(parseFloat(m[3]) * k + 255 * (1 - k));
    return 'rgb(' + r + ', ' + g + ', ' + b + ')';
  }

  function tblColors() {
    var hex = /^#[0-9a-fA-F]{6}$/.test(String(TPREF.color)) ? TPREF.color : TBL.color;
    var p = tblPresetOf(hex);
    return {
      hex: hex.toUpperCase(),
      main: hexToRgbStr(hex),
      /* ★ v2.6.17：预设可自带表头字色 ——「浅灰」那套是浅底深字，不能再用白字 */
      headFg: (p && p.headFg) ? p.headFg : '#FFFFFF',
      zebra: p ? p.zebra : tblMix(hex, 0.08),
      line: p ? p.line : tblMix(hex, 0.20),
      cellFg: BASE.color
    };
  }

  /* 表格字号由 BASE.size 派生（12 / 13 对应正文 17）—— 与「排版参数单一来源」同一条原则 */
  function tblFonts() {
    return {
      head: Math.max(11, Math.round(BASE.size * 0.72)),
      cell: Math.max(12, Math.round(BASE.size * 0.78))
    };
  }

  /* 表头分隔线用半透明白（深底上的浅线）—— 取自该文原文写法 */
  var TBL_HEAD_LINE = 'rgba(255,255,255,0.25)';

  function cellSpan(c) {
    var s = parseInt(c.getAttribute('colspan') || '1', 10);
    return (isFinite(s) && s > 0 && s <= 8) ? s : 1;
  }

  function tblCellAlive(el) {
    return !!String(el.textContent || '').replace(/\s/g, '')
      || !!el.querySelector('img') || !!el.querySelector('br');
  }

  /*
   * 把一张 <table> 重建成「圆角容器 + flex 行」的 section 结构。
   * 认不出 / 超限时返回 **null**（调用方按老路拍平，绝不静默丢内容）。
   */
  function buildFlexTable(doc, tbl) {
    var rows = [];
    try { rows = tbl.rows ? tbl.rows : tbl.querySelectorAll('tr'); } catch (e) { rows = []; }
    if (!rows || !rows.length || rows.length > 60) return null;

    // 列数 = 各行 colspan 之和的最大值；不足的行补一个填充格，保证列宽百分比一致
    var nCols = 0, i, j;
    for (i = 0; i < rows.length; i++) {
      var cells = rows[i].cells || [], sum = 0;
      for (j = 0; j < cells.length; j++) sum += cellSpan(cells[j]);
      if (sum > nCols) nCols = sum;
    }
    if (nCols < 1 || nCols > 8) return null;
    /* 退化表格守卫：1 行 1 列不是表格，是复制粘贴的边角产物（Word/Excel 常留下这种
       "包一层 table" 的壳）。给它套边框圆角只会让用户困惑 —— 交回通用清洗去拍平。 */
    if (rows.length < 2 && nCols < 2) return null;

    var C = tblColors(), F = tblFonts();
    var w = Math.round(10000 / nCols) / 100;   // 例：3 列 -> 33.33

    var box = doc.createElement('section');
    box.setAttribute('style', 'box-sizing:border-box;border:1px solid ' + C.line
      + ';border-radius:' + TBL.radius + 'px;overflow:hidden;');

    for (i = 0; i < rows.length; i++) {
      var isHead = !!TPREF.head && i === 0;
      var dataIdx = TPREF.head ? i - 1 : i;
      var isZebra = !isHead && !!TPREF.zebra && (dataIdx % 2 === 1);
      var rowEl = doc.createElement('section');
      var rs = 'box-sizing:border-box;display:flex;background-color:'
        + (isHead ? C.main : (isZebra ? C.zebra : '#FFFFFF')) + ';';
      if (i > 0) rs += 'border-top:1px solid ' + C.line + ';';
      rowEl.setAttribute('style', rs);

      var cs2 = rows[i].cells || [], used = 0;
      for (j = 0; j <= cs2.length; j++) {
        var src = j < cs2.length ? cs2[j] : null;
        var span = src ? cellSpan(src) : (nCols - used);
        if (span < 1) break;
        used += span;
        var cell = doc.createElement('section');
        var st = 'box-sizing:border-box;width:' + (w * span) + '%;padding:10px 12px;font-size:'
          + (isHead ? F.head : F.cell) + 'px;line-height:1.5;'
          + (isHead ? 'font-weight:700;color:' + C.headFg + ';' : 'color:' + C.cellFg + ';');
        if (j > 0) st += 'border-left:1px solid ' + (isHead ? TBL_HEAD_LINE : C.line) + ';';
        cell.setAttribute('style', st);
        if (src) { while (src.firstChild) cell.appendChild(src.firstChild); }
        /* ★ 空格子必须留个 <br>：cleanForeignHTML 尾部的「去空段」会把
           textContent 为空、又无 img/br 的 section 整块删掉 —— 空单元格被删
           就等于那一行少一列，列会对不齐。 */
        if (!tblCellAlive(cell)) cell.appendChild(doc.createElement('br'));
        rowEl.appendChild(cell);
        if (!src) break;
      }
      box.appendChild(rowEl);
    }
    return box;
  }

  /*
   * ★ v2.6.22：**回到「重建」路线**（撤销 v2.6.20 的「外套」变通）。
   *
   *   为什么撤：外套是 `<section 圆角><table>…</table></section>`，而受控编辑器
   *   （ProseMirror）的 schema **不允许 section 内嵌 table** —— 保存 / 归一化时它把
   *   `table` 拆到外面，正文里留下一只**空壳圆角框**（用户 2026-09-21 截图红框那个空框）。
   *   用户拍板：「表格改为圆角干净、丢列宽手柄」。
   *
   *   现在的形态与用户给的参考文章（`_tmp222/ref.html`）**逐层同构**：
   *     最外层 section（唯一一层：border-radius + 1px 描边 + overflow:hidden）
   *       └ 行 section（display:flex + 底色 / border-top）
   *           └ 格 section（width:x% + padding:10px 12px + font-size/color）
   *   那篇文章全文 **0 个 `<table>`** —— 微信自己产出的表格就是这套结构。
   *
   *   代价：微信原生表格的列宽拖拽手柄不再有（用户已明确接受）。
   */

  /* 把一张真表格**就地换成**重建后的圆角容器。返回 1 / 0。
     认不出 / 超限（>60 行 / >8 列 / 退化 1×1）返回 0 ⇒ 交给 cleanForeignHTML 的兜底跳过，
     **绝不静默丢内容**（与 buildFlexTable 的退化守卫同源）。 */
  function rebuildNativeTable(doc, tbl) {
    if (!isRealTable(tbl)) return 0;
    var box = buildFlexTable(doc, tbl);
    if (!box || !tbl.parentNode) return 0;
    try { tbl.parentNode.replaceChild(box, tbl); } catch (e) { return 0; }
    return 1;
  }

  function rebuildTables(doc, box) {
    if (!doc || !box) return 0;
    var tbls = [];
    try { tbls = box.querySelectorAll('table'); } catch (e) { tbls = []; }
    var n = 0, i;
    /* ★ v2.6.22：倒序处理 —— replaceChild 会让后面的节点位置前移，正序会错位漏表。 */
    for (i = tbls.length - 1; i >= 0; i--) {
      var tb = tbls[i];
      /*
       * ★★ v2.6.22 修正：这里**不许再查 isConnected**。
       *   本函数的唯一调用点是 cleanForeignHTML，而那儿的 box 是
       *   `doc.createElement('div')` 造出来的**游离节点** —— 里面的 <table>
       *   的 isConnected 恒为 false ⇒ 旧判据 `|| !tb.isConnected` 恒真 ⇒ continue
       *   ⇒ 整条「粘贴即重建」**一次都没执行过**（v2.6.13 起的隐性哑弹）。
       *   v2.6.21 没暴露：当时断言的是「原生表被保留（外套方案）」，
       *   正好把「没重建」读成了绿 —— 判据与实现一起错。
       *   游离树里 replaceChild 完全可用，parentNode 非空就够了。
       */
      if (!tb || !tb.parentNode) continue;
      try { n += rebuildNativeTable(doc, tb); } catch (e1) {}
    }
    return n;
  }

  /*
   * 结构识别：认出「本脚本生成的表格容器」。
   * 不能用 data-* 标记 —— 通用清洗循环会重建每个元素、只保留白名单 style，自定义属性全丢。
   * 改用结构特征：section + 样式含 overflow:hidden 与 border-radius，且**所有**子元素都是
   * display:flex 的 section。这三个条件同时成立，误伤的可能是极低的。
   */
  function isFlexTableBox(el) {
    if (!el || el.tagName !== 'SECTION') return false;
    var st = String(el.getAttribute('style') || '').replace(/\s+/g, '');
    if (st.indexOf('overflow:hidden') < 0 || st.indexOf('border-radius') < 0) return false;
    var kids = el.children;
    if (!kids || !kids.length) return false;
    for (var i = 0; i < kids.length; i++) {
      if (kids[i].tagName !== 'SECTION') return false;
      if (String(kids[i].getAttribute('style') || '').replace(/\s+/g, '').indexOf('display:flex') < 0) return false;
    }
    return true;
  }

  /*
   * v2.6.19：判定「真实表格」—— 只有真表格才在 cleanForeignHTML 里整棵跳过（保留原生列宽）；
   *   退化 1×1 壳（复制粘贴边角产物）不算表格，交回通用清洗拍平成段落。
   *   判据与 buildFlexTable 的退化守卫一致：列数 1–8、且「行数≥2 或 列数≥2」。   */
  function isRealTable(tbl) {
    if (!tbl || tbl.tagName !== 'TABLE') return false;
    var rows = tbl.rows || [];
    if (!rows || !rows.length) return false;
    var nCols = 0, i, j;
    for (i = 0; i < rows.length; i++) {
      var cells = rows[i].cells || [], sum = 0;
      for (j = 0; j < cells.length; j++) sum += cellSpan(cells[j]);
      if (sum > nCols) nCols = sum;
    }
    if (nCols < 1 || nCols > 8) return false;
    if (rows.length < 2 && nCols < 2) return false;   // 退化壳
    return true;
  }

  /* ── 表格单元收集（v2.6.34）──────────────────────────────────────────
   * 「一张表」的两种形态：外部粘进来的原生 <table>、本脚本以前建过的 flex 容器
   * （section + display:flex + 圆角）。**按文档序**收集 —— 索引即「第几张表」。
   *   ★ 传序号不传元素：宿主重渲染会把节点整个换掉，引用即脱线（skill 第十二节）。
   *   ★ 嵌套时只收最外层：内层容器随外层一起上色，收进来会重复计数。
   * ───────────────────────────────────────────────────────────────── */
  function collectTables(ctx) {
    var out = [];
    if (!ctx || !ctx.root) return out;
    var all = [], n;
    try {
      var w = ctx.doc.createTreeWalker(ctx.root, NodeFilter.SHOW_ELEMENT, null, false);
      while ((n = w.nextNode())) all.push(n);
    } catch (e0) { return out; }
    for (var i = 0; i < all.length; i++) {
      var el = all[i];
      if (el.tagName === 'TABLE') { if (isRealTable(el)) out.push(el); continue; }
      if (!isFlexTableBox(el)) continue;
      if (el.parentNode && isFlexTableBox(el.parentNode)) continue;   // 嵌套只收最外层
      out.push(el);
    }
    return out;
  }

  /* ── 选区落在哪几张表上（v2.6.34）────────────────────────────────────
   *   光标（折叠）  ：看它所在元素是否在某张表内 ⇒ 命中 1 张；
   *   选中（非折叠）：看哪些表与选区相交      ⇒ 命中 1~n 张。
   *   命中为空 ⇒ 调用方**只提示、不动正文**（这是本轮的需求：不再全篇一起改）。
   *   返回 { list, idx }：list = 全部表格（按文档序），idx = 命中的序号数组。
   * ───────────────────────────────────────────────────────────────── */
  function tableScopeOf(ctx) {
    var list = collectTables(ctx), idx = [], i;
    /*
     * 取选区走**块级操作同一口径**：现场选区 → 快照 → 光标快照。
     *   只认现场选区是不够的：用户是「先在编辑器里点/选表格，再点面板按钮」，
     *   而点按钮会让编辑器失焦 —— 有的宿主失焦即清选区，那一刻 liveRange 已是空，
     *   只认它就会报「没选中表格」（真机表现 = 点了没反应，同类坑踩过）。
     */
    var r = null;
    try {
      var g = grabRange(false);
      if (g && g.ctx && g.ctx.root === ctx.root) r = g.range;
    } catch (e0) {}
    if (!r) r = liveRange(ctx);
    if (!r) return { list: list, idx: idx };
    if (r.collapsed) {
      var c = r.startContainer;
      var el = c && (c.nodeType === 1 ? c : c.parentNode);
      for (i = 0; i < list.length; i++) {
        if (el && (list[i] === el || list[i].contains(el))) { idx.push(i); break; }
      }
      return { list: list, idx: idx };
    }
    for (i = 0; i < list.length; i++) {
      try { if (r.intersectsNode(list[i])) idx.push(i); } catch (e) {}
    }
    return { list: list, idx: idx };
  }

  /* 给**一张**表格上色：原生 <table> 先重建成圆角容器，已是容器就直接上色。
     返回被上色的容器；结构越界 / 认不出 → null（绝不静默丢内容）。 */
  function paintTableBox(ctx, t, C, F) {
    var box = t;
    if (t.tagName === 'TABLE') {
      var nb = buildFlexTable(ctx.doc, t);
      if (!nb || !t.parentNode) return null;
      t.parentNode.replaceChild(nb, t);
      box = nb;
    } else if (!isFlexTableBox(box)) return null;
    var bs = box.style;
    bs.setProperty('box-sizing', 'border-box');
    bs.setProperty('border', '1px solid ' + C.line);
    bs.setProperty('border-radius', TBL.radius + 'px');   // ★ v2.6.22：写死，不再可调
    bs.setProperty('overflow', 'hidden');
    var rows = box.children;
    for (var j = 0; j < rows.length; j++) {
      var rowEl = rows[j], rsz = rowEl.style;
      var isHead = !!TPREF.head && j === 0;
      var dataIdx = TPREF.head ? j - 1 : j;
      var isZebra = !isHead && !!TPREF.zebra && (dataIdx % 2 === 1);
      rsz.setProperty('background-color', isHead ? C.main : (isZebra ? C.zebra : '#FFFFFF'));
      if (j > 0) rsz.setProperty('border-top', '1px solid ' + C.line);
      else { try { rsz.removeProperty('border-top'); } catch (e2b) {} }
      var cells = rowEl.children, tot = cells.length || 1;
      var w = Math.round(10000 / tot) / 100;
      for (var k = 0; k < cells.length; k++) {
        var csz = cells[k].style;
        csz.setProperty('box-sizing', 'border-box');
        csz.setProperty('width', w + '%');
        csz.setProperty('font-size', (isHead ? F.head : F.cell) + 'px');
        csz.setProperty('color', isHead ? C.headFg : C.cellFg);
        csz.setProperty('font-weight', isHead ? '700' : '400');
        if (k > 0) csz.setProperty('border-left', '1px solid ' + (isHead ? TBL_HEAD_LINE : C.line));
        else { try { csz.removeProperty('border-left'); } catch (e3b) {} }
      }
    }
    return box;
  }

  /* ── 给表格重新上色（v2.6.34：**只处理选中的那些**）────────────────────
   *   onlyIdx = 序号数组（tableScopeOf 产出，来自选区）；
   *     · 给了且非空 → 只处理这几张（本轮需求：仅对选中的表格配色）；
   *     · 给了但是空数组 → 明确「一张都没命中」⇒ **不动任何表格**；
   *     · 没给（undefined / null）→ 全篇（保留给内部/诊断调用）。
   *   返回真正上了色的张数。
   * ───────────────────────────────────────────────────────────────── */
  function restyleTables(ctx, onlyIdx) {
    if (!ctx || !ctx.root) return 0;
    var list = collectTables(ctx), pick = [], i, n = 0;
    if (onlyIdx) {
      if (!onlyIdx.length) return 0;
      for (i = 0; i < onlyIdx.length; i++) {
        if (list[onlyIdx[i]]) pick.push(list[onlyIdx[i]]);
      }
    } else {
      pick = list;
    }
    var C = tblColors(), F = tblFonts();
    for (i = 0; i < pick.length; i++) {
      try { if (paintTableBox(ctx, pick[i], C, F)) n++; } catch (e4) {}
    }
    return n;
  }

  function tablePrefFields() {
    var sel = [], i, known = false;
    var cur = String(TPREF.color).toUpperCase();
    for (i = 0; i < TBL.presets.length; i++) {
      /* ★ v2.6.17：色板改为平铺色块 —— 每项带上 hex 供色块上色，label 只留中文名 */
      sel.push({ v: TBL.presets[i].hex, label: TBL.presets[i].label, hex: TBL.presets[i].hex });
      if (String(TBL.presets[i].hex).toUpperCase() === cur) known = true;
    }
    sel.push({ v: '__custom', label: '自定义' });
    return [
      { k: 'color', label: '表格主色（平铺点选；表头底 / 表头字 / 隔行底 / 分隔线都由它派生）',
        value: known ? cur : '__custom', type: 'swatches', options: sel, linked: 'hex' },
      /* ★ v2.6.22：`type:'color'` 只作语义标记（渲染仍是文本框，能手输）；
         点上面「自定义」那块会弹系统色卡，选完自动回填进这一格。 */
      { k: 'hex', label: '自定义主色（#RRGGBB；点上面「自定义」会直接弹系统色卡，也可手输）',
        value: cur, ph: '#D5281E', type: 'color', linked: 'color' },
      { k: 'head', label: '首行作表头（染主色底 + 反白字）', value: String(TPREF.head),
        type: 'select', options: [{ v: '1', label: '是' }, { v: '0', label: '否' }] },
      { k: 'zebra', label: '隔行浅底（数据行交替底色，长表更好横向读数）', value: String(TPREF.zebra),
        type: 'select', options: [{ v: '1', label: '开' }, { v: '0', label: '关' }] }
    ];
  }

  function applyTableStyle() {
    var ctx = needCtx(); if (!ctx) return;
    /* ★ v2.6.34：作用域收到「选中的表格」——
       用户要求：不再对全篇所有表格一起配色。取不到命中就**只提示、不动正文**。 */
    var sc = tableScopeOf(ctx);
    if (!sc.idx.length) {
      trace('fail', '表格配色 · 选区未落在任何表格上（正文共 ' + sc.list.length + ' 张表）');
      toast(sc.list.length
        ? '请先把光标点进要配色的表格里（或整块选中该表格）再点这个按钮 —— 全文共 '
          + sc.list.length + ' 张表'
        : '正文里还没有表格：从 Excel / Word / 网页复制表格粘进来即可');
      return;
    }
    loadTablePref();
    /* 序号在「点套用」那一刻重新换算成元素 —— 对话框开着的这段时间宿主可能重渲染，
       存元素引用会脱线（skill 第十二节：存位置，不存对象）。 */
    var idx = sc.idx;
    var tip = '将应用于：' + idx.map(function (x) { return '第 ' + (x + 1) + ' 张'; }).join('、')
      + '表（全文共 ' + sc.list.length + ' 张）';
    openDialog({
      title: '表格配色',
      msg: tip,
      /* ★ v2.6.28：这段「用于表格：…」的长说明**整段删掉**（用户框选要求删除）。
         它把圆角写死值 / 手柄代价 / 派生规则 / 字号来源全摊在用户面前，是**开发向**
         的说明；面板上留标题 + 字段就够。
         ⚠️ 桌面面板那颗「表格配色」按钮的**悬浮提示**（p4.js 的 chip tip）是另一处，
            保持不动 —— 它才是「不点开也能看」的入口。 */
      fields: tablePrefFields(),
      okText: '套用',
      ok: function (v) {
        var want = String(v.color == null ? '' : v.color).trim();
        if (want === '__custom') want = String(v.hex == null ? '' : v.hex).trim();
        if (!/^#[0-9a-fA-F]{6}$/.test(want)) {
          toast('主色要填 #RRGGBB 六位十六进制，这次保留原色');
          want = TPREF.color;
        }
        TPREF.color = want.toUpperCase();
        TPREF.head = String(v.head) === '0' ? 0 : 1;
        TPREF.zebra = String(v.zebra) === '0' ? 0 : 1;
        saveTablePref();
        snapshot('表格配色');
        var n = restyleTables(ctx, idx);
        toast('表格配色已保存：主色 ' + TPREF.color + ' / 圆角 ' + TBL.radius + 'px'
          + (n ? ('　·　已给 ' + n + ' 张表重上色') : '　·　选中的表格认不出结构，未改动'));
      }
    });
  }

  /* ══════════════════════════════════════════════════════════════════
   * 7.9 宽载体通道（v2.0 新增）
   *
   * 【为什么需要它 —— 一次判断错误的订正】
   *   微信有**两层**约束，作用点完全不同，混为一谈就会得出「微信不支持」的错结论：
   *     ① 编辑器 schema 层：在编辑器里改 DOM / 换节点时必须过这一关。
   *        行内只接纳 7 个属性（现场读回的 textstyle.attrs）：
   *        font-size / letter-spacing / background-color / color /
   *        font-weight / font-style / text-decoration。
   *     ② 投放白名单层（KEEP_STYLE）：最终发布的**实际支持范围**，
   *        border / border-width / border-style / border-color / border-radius /
   *        padding / display / width / height / vertical-align / box-shadow 都在里面。
   *   别的公众号做得出圆角矩形徽标（border + border-radius + padding），
   *   靠的正是第②层。我们缺的从来不是「微信支不支持」，
   *   而是「怎么让这些声明活着穿过第①层」。
   *
   * 【做法】
   *   对「配方里含差集声明」的样式，先试**粘贴导入链路**：派发一个带 DataTransfer
   *   的 paste 事件，让宿主自己的 HTML 导入处理器去接。那条链路是专门用来接纳
   *   **外部 HTML** 的（用户从第三方排版工具复制粘贴走的就是它），比 schema 直通宽。
   *   宿主接住了（preventDefault）即采纳；否则原样退回配方节点替换，功能不受影响。
   *
   * 【不押在它身上】
   *   宿主可能校验 isTrusted、或仍按自己的 schema 规范化。所以它是「先试」不是
   *   「唯一」，而且**实测结果写进报告** —— 下一轮不必再猜「到底卡在哪一层」。
   * ══════════════════════════════════════════════════════════════════ */

  var WIDE_TRIED = '';        // 最近一次宽载体的实测结果（写进诊断报告）

  // 配方里「编辑器接不住、但投放白名单支持」的声明（两层的差集）
  function wideDecls(css) {
    var d = declsOf(css), out = [];
    for (var k in d) { if (SCHEMA_ATTR_CSS.indexOf(k) < 0) out.push(k); }
    return out;
  }

  function escTxt(t) {
    return String(t).replace(/&/g, '&amp;').replace(/</g, '&lt;')
      .replace(/>/g, '&gt;').replace(/"/g, '&quot;');
  }

  // 派发粘贴；返回 true = 宿主接住了（preventDefault）
  function widePaste(ctx, html, plain) {
    var host = pmHostOf(ctx) || ctx.root;
    if (!host) { WIDE_TRIED = 'no-host'; return false; }
    var dt = null;
    try {
      dt = new DataTransfer();
      dt.setData('text/html', html);
      dt.setData('text/plain', plain || '');
    } catch (e) { WIDE_TRIED = 'no-DataTransfer'; return false; }
    var ev = null;
    try {
      ev = new ClipboardEvent('paste', { bubbles: true, cancelable: true, clipboardData: dt });
    } catch (e2) {
      try {
        ev = ctx.doc.createEvent('Event');
        ev.initEvent('paste', true, true);
        ev.clipboardData = dt;
      } catch (e3) { WIDE_TRIED = 'no-ClipboardEvent'; return false; }
    }
    /*
     * ★ 守卫必须挂 **document**，不能挂 ctx。
     *   bindPaste 是「一个 document 只绑一次」（doc.__mptbPaste 哨兵），
     *   绑定时闭包捕获的是 boot 期那个 ctx0 —— 与调用方手里的 ctx 不是同一个对象。
     *   守卫挂 ctx 就等于挂在一份没人看的副本上：自家清洗照样抢在前面把 HTML
     *   直接插进 DOM，受控编辑器随即把它剥回原样（『写了又白写』）。
     *   document 是监听器与调用方唯一共享的对象，只有挂这里才真正生效。
     */
    try { ctx.doc.__mptbInject = true; } catch (e5) {}
    ctx.__mptbInject = true;        // 兼容：老闭包若认 ctx 也一并认
    try { host.dispatchEvent(ev); } catch (e4) { WIDE_TRIED = 'dispatch-threw'; }
    finally {
      ctx.__mptbInject = false;
      try { ctx.doc.__mptbInject = false; } catch (e6) {}
    }
    var ok = !!ev.defaultPrevented;
    WIDE_TRIED = ok ? 'accepted' : 'ignored';
    return ok;
  }

  /*
   * 对选区走宽载体。刻意只处理「连续一段文字」：
   *   粘贴会替换当前选区，一次只能写一个 run；跨段时需要反复重定位，
   *   而粘贴会让编辑器重渲染、节点引用作废，风险远大于收益。
   *   跨段时如实返回原因，由调用方退回配方节点替换（不会静默失败）。
   */
  /*
   * ★ v2.6.14：请宿主自己按一次快捷键（undo / redo）。
   *
   *   为什么不用 PM 的 API：拿不到 EditorView（p2 实测「PM 的 ViewDesc 不持有 view」），
   *   而 paste 一旦进了宿主自己的 doc，**改 DOM 是撤不掉的** —— 它会用 doc 重渲染回来。
   *   唯一能真正撤销它的是宿主自己的撤销栈，也就是它自己的 Ctrl+Z 处理器。
   *   合成 keydown 不带 isTrusted，但 PM 的 keymap 只按 preventDefault 语义处理，不看这个标志。
   */
  function sendKey(ctx, key, shift) {
    var host = pmHostOf(ctx) || ctx.root;
    if (!host || typeof host.dispatchEvent !== 'function') return false;
    var up = String(key).toUpperCase(), code = up.charCodeAt(0);
    /*
     * ★ v2.6.15：修饰键必须**按平台只给一个**。
     *   旧写法把 ctrlKey / metaKey 同时置真 —— 而 prosemirror-keymap 的 keyName()
     *   是「按修饰键逐个拼前缀」，两个都真就拼成 "Meta-Ctrl-z"，
     *   与 keymap 里登记的 "Mod-z"（Windows 上归一成 "Ctrl-z"）**永不相等**
     *   ⇒ 宿主压根不处理这次 keydown ⇒ ev.defaultPrevented 恒为 false
     *   ⇒ 「撤销」从 v2.6.14 上线起一次都没真正执行过（而流水还报「已自动撤销」，
     *     因为它把「文档本来就没变」误当成了「撤销成功」，见 wideRollback）。
     *   现在按平台先给首选的那一个，没被接住再试另一个 —— 两套都试过才认输。
     */
    var isMac = false;
    try {
      isMac = /mac|iphone|ipad/i.test(String(
        (ctx.win && ctx.win.navigator
          && (ctx.win.navigator.platform || ctx.win.navigator.userAgent)) || ''));
    } catch (e0) { isMac = false; }
    var mods = isMac ? [{ metaKey: true }, { ctrlKey: true }]
                     : [{ ctrlKey: true }, { metaKey: true }];
    for (var mi = 0; mi < mods.length; mi++) {
      if (fireKey(ctx, host, key, up, code, shift, mods[mi])) return true;
    }
    return false;
  }

  /*
   * 派发一次 keydown；返回 true = 宿主接住了（preventDefault）。
   *   单独拆出来只为了「能换一套修饰键再试一次」—— 合成事件不能复用。
   */
  function fireKey(ctx, host, key, up, code, shift, mod) {
    var ev = null;
    try {
      ev = new KeyboardEvent('keydown', {
        key: key, code: 'Key' + up, keyCode: code, which: code,
        ctrlKey: !!mod.ctrlKey, metaKey: !!mod.metaKey,
        shiftKey: !!shift, bubbles: true, cancelable: true
      });
    } catch (e) {
      try {
        ev = ctx.doc.createEvent('Event');
        ev.initEvent('keydown', true, true);
        ev.key = key; ev.keyCode = code; ev.which = code;
        ev.ctrlKey = !!mod.ctrlKey; ev.metaKey = !!mod.metaKey;
        ev.shiftKey = !!shift;
      } catch (e2) { return false; }
    }
    try { host.dispatchEvent(ev); } catch (e3) { return false; }
    return !!ev.defaultPrevented;
  }

  /*
   * ★ v2.6.14：撤销「宽载体这次合成粘贴」留下的痕迹。
   *
   *   现场（2026-09-21 10:02 用户报告）：点一次徽标，被设置的那段文字**在开头又多出一遍**。
   *   根因两条：
   *     ① 判据错：「落点自检」只比 **textContent 长度**。粘贴把内容插到文首、宿主同时
   *        把选区原文换掉时长度恰好抵消 ⇒ grew=0 ⇒ 漏判 ⇒ 当成「落点没问题」往下走；
   *     ② 处置错：旧代码发现异常时只报一句「请按 Ctrl+Z 撤销后重试」，自己不撤 ——
   *        用户没按（或按晚了），重复内容就留在正文里，再点一次又叠一层。
   *
   *   撤销手段是**宿主自己的撤销栈**（按一次 Ctrl+Z），不是改 DOM：
   *     · 不能压自己的快照栈（上方注释：重复压一层会让用户撤两次才回原状）；
   *     · 粘贴确实改过 doc —— 那一步必然在宿主的撤销栈里，按一次就回到起点。
   *   撤完**用指纹复核**：没回到起点说明撤过了头，立刻 redo 还回去 ——
   *   绝不把用户的文档留在「撤了一半」的状态。两条都不成时如实告知，让用户自己按。
   */
  function wideRollback(ctx, sig0, nowSig) {
    if (sig0 == null) return false;
    var now = (nowSig != null) ? nowSig : pmSigOf(ctx);
    if (now == null) return false;
    if (now === sig0) return true;                 // 文档本来就没变，无需撤销
    /*
     * ★ v2.6.15：成败**只看指纹**，不再信 sendKey 的返回值。
     *   sendKey 的判据是 ev.defaultPrevented —— 宿主换个写法（只 return true
     *   不 preventDefault）就会假报失败；而「按下去之后文档到底动没动」
     *   本身才是最硬的证据。三条出口：
     *     回到 sig0        ⇒ 真的撤销成功；
     *     一步没动          ⇒ 这次 undo 没被宿主接住，如实报失败（别谎报已撤销）；
     *     动了但不是 sig0   ⇒ 撤过了头，先 redo（Ctrl+Y）再 shift+Ctrl+Z 还回去。
     */
    var before = now;
    sendKey(ctx, 'z', false);
    var s1 = pmSigOf(ctx);
    if (s1 === sig0) return true;                  // 回到粘贴前 ⇒ 干净
    if (s1 === before) return false;               // 压根没动 ⇒ 这次 undo 没生效
    sendKey(ctx, 'y', false);                      // 撤过了头 ⇒ 还回去
    if (pmSigOf(ctx) === sig0) return true;
    sendKey(ctx, 'z', true);                       // Ctrl+Y 不认的宿主再试 shift+Ctrl+Z
    return pmSigOf(ctx) === sig0;
  }

  function widePasteRuns(ctx, range, css) {
    var runs = [];
    try { runs = collectRuns(range, ctx); } catch (e) { runs = []; }
    if (!runs.length) return { done: false, why: '选区内没有文字' };
    if (runs.length > 1) return { done: false, why: '选区跨 ' + runs.length + ' 段' };
    var node = null;
    try { node = isolateRun(runs[0]); } catch (e2) { node = null; }
    if (!node || !node.nodeValue) return { done: false, why: '拆不出文本' };
    var body = node.nodeValue;
    /* ★ v2.6.7：粘贴前的行内样式基线 —— 验真只认「相对基线发生变化」的目标声明，
       否则正文自带的 span[color…;font-size…] 会让纯文字样式的验真恒真（详见 wideVerify）。 */
    var beforeMap = inlineChainStyle(node, ctx.root);
    /* ★ v2.6.14：粘贴前的 doc 指纹 —— 「这次粘贴到底有没有改动静止的文档」的权威判据。 */
    var sig0 = pmSigOf(ctx);
    var rr = ctx.doc.createRange();
    try { rr.setStart(node, 0); rr.setEnd(node, body.length); } catch (e3) { return { done: false, why: '选区构造失败' }; }
    /*
     * ★★ v2.6.17：focus 必须**在设选区之前**，并且设完要**验一次**。
     *   旧顺序（applySel → hs.focus）里，元素 focus 会把 caret 打回元素起点，
     *   紧跟着 dispatch 的 selectionchange 让 PM 采纳了「文首」选区 —— 合成粘贴于是落到文首，
     *   现场就是「开头多出一份带样式的副本」。
     */
    try { var hs0 = pmHostOf(ctx) || ctx.root; if (hs0 && hs0.focus) hs0.focus(); } catch (e8a) {}
    applySel(ctx, rr);
    try {
      var s0 = ctx.doc.getSelection ? ctx.doc.getSelection()
        : (ctx.win.getSelection && ctx.win.getSelection());
      if (!s0 || s0.rangeCount === 0 || s0.anchorNode !== node) applySel(ctx, rr);
    } catch (e8b) {}
    /*
     * ★ v2.5.1：派发前先把**宿主自己的选区**对齐，并留一份正文长度。
     *   合成 paste 的落点由宿主编辑器自己的 selection 决定（不是我们设的 DOM 选区）：
     *   PM 的 onSelectionChange 头一句是 `if (!hasFocusAndSelection(view)) return`，
     *   而 hasFocus() 要求 activeElement 在编辑器内 —— 用户刚点过面板按钮、焦点还在面板上，
     *   它就整段跳过同步，粘贴便落到它上一次记得的位置（常见是文首）。
     *   两步补齐：① 把焦点交还宿主元素；② 补一次 selectionchange 让它立刻采纳这个选区。
     */
    /*
     * ★ v2.6.15：粘贴前除了正文长度，再记两样**结构层**的事实 ——
     *   顶层块数、首块文字。textContent 长度会被「插到文首 + 换掉选区原文」
     *   这类组合抵消（v2.6.14 之前就用它当唯一判据，漏判过），doc 指纹又要
     *   等到宿主 dispatch 之后才变；块数与首块文字是当场就能读到的铁证。
     */
    var len0 = -1, nk0 = -1, head0 = '', selInFirst = false;
    try {
      len0 = String(ctx.root.textContent || '').length;
      nk0 = ctx.root.children.length;
      head0 = String((ctx.root.children[0] && ctx.root.children[0].textContent) || '').slice(0, 24);
    } catch (e7) {}
    /* 选区本来就在首块里时，首块文字**必然**变 —— 不是错位证据 */
    try { selInFirst = !!(ctx.root.children[0] && ctx.root.children[0].contains(node)); } catch (e7b) {}
    /* ★ v2.6.17：这里**不再 focus** —— 元素 focus 会把 caret 打回元素起点，冲掉上面刚设好的选区；
       focus 已提前到 applySel 之前做过。 */
    try { ctx.doc.dispatchEvent(new Event('selectionchange')); } catch (e9) {}
    /*
     * ★ v2.6.5：纯文字样式用**语义标签**包裹（加粗 ⇒ <strong style="font-weight:bold">）。
     *   终端原生渲染语义标签，不依赖内联属性透传 —— 这正是「编辑器里粗、手机不粗」的
     *   正面修法（微信编辑器自己产出的加粗就是 <strong style="font-weight: 700;…">）。
     *   含外框 / 底色的配方装不进语义标签 ⇒ 仍用 span（外部排版工具的徽标正是这种形态）。
     */
    /*
     * ★ v2.6.6：送进去的 HTML 必须是**配方原文写法**，不能自造裸 <span style>。
     *   真机（2026-09-20 16:49）证明：裸 <span style="display:inline-block;…">
     *   被宿主解析器直接丢掉 —— 流水的原话是「宿主接了粘贴，但没有一个行内包裹
     *   带上差别声明」。原因：宿主的解析器只接纳 schema 里登记过的写法
     *     · link 标记      ← a[href]            （attrs 含 style ⇒ 是唯一能带整条 style 的）
     *     · textstyle 标记 ← span[textstyle]
     *   一个不在这个接纳面里的裸 span 只会被剥成纯文字。
     *   配方原文（rec.attrs 带 linktype / data-linktype / href …）正是宿主自己
     *   toDOM 出来、且经它自己 getAttrs 回读判定过的写法 ⇒ 才进得了这个面。
     */
    /*
     * ★ v2.6.8：语义标签档**提到配方原文之前** —— 加粗 / 朱红加粗改送「内联 HTML 源码」。
     *
     *   为什么必须在这一档（v2.6.5~v2.6.7 把它排在「永不可达」的兜底位上）：
     *     ① mkWrapEl 末尾是**无条件返回**的裸 span 兜底 ⇒ 只要它不抛异常，html 必非空
     *        ⇒ 这一档一次都不会执行（通道写了却没有任何断言看守它被走到 —— 本轮错因）；
     *     ② mkWrapEl 内的语义档走 semWrapFor → semTagForCtx，它**查 schema**：
     *        真机 schema 行内标记只有 7 个、【语义标记=无】（报告二·B/C）⇒ 必空 ⇒
     *        加粗只能落到 pmRecipe 的 span[textstyle]（自定义属性形态）；
     *     ③ 报告二·C 的判决：「安卓端只认**内联 style**……写法里只有自定义属性
     *        （textstyle）而 style 被宿主丢掉时，桌面预览看着正常、手机端会
     *        『只剩颜色、不见加粗』」 —— 这正是「编辑器里粗、手机不粗」的现场。
     *
     *   所以改用**只看值不看 schema** 的 semTagForHtml 推导标签，再用线上实证白名单
     *   （wxKnownSem）放行；送出物**必带内联 style**（安卓端只认它），与报告二·D
     *   给加粗的「该写」同构：
     *     <strong style="font-weight:bold">              （加粗）
     *     <strong style="color:#9F312A;font-weight:bold">（朱红加粗）
     *
     *   白名单闸的边界（本档只吞这两个按钮，其余按钮逐字回落 mkWrapEl，行为不变）：
     *     · 橙高亮 / 行内代码 / 键盘键 / 徽标 / 标签 → 配方含 display·padding·border
     *       ⇒ SEM_DECL_OK 不放行 ⇒ semTagForHtml 返回 '' ⇒ 回落；
     *     · 黄高亮 → background-color 不在 SEM_DECL_OK ⇒ 返回 '' ⇒ 回落；
     *     · 链接 → text-decoration:none 不匹配任何语义规则 ⇒ 返回 '' ⇒ 回落；
     *     · 朱红下划线 → semTagForHtml 会给 'u'，但 u 无实证 ⇒ wxKnownSem 挡掉 ⇒ 回落。
     */
    var html = '';
    var semTag = '';
    try { semTag = semTagForHtml(css) || ''; } catch (eS1) { semTag = ''; }
    if (semTag) {   // ★ v2.6.23：semTagForHtml 已统一返回 ''，本分支恒不进入（纯字重样式改走下方内联源码档 <span style>）
      /*
       * ★ v2.6.9：补上宿主正文的活形态 —— <span leaf=""> 内层。
       *   真机「正文首块原文」里那个**活着**的 strong 是
       *     <strong style="font-weight:bold;" data-pm-slice="0 0 []"><span leaf="">文字</span></strong>
       *   宿主自己对所有正文文字都套 leaf span；粘贴进来的 HTML 若自带该结构，
       *   就与它的原生形态同构（自带则原样保留，不自带则由它自己补 —— 代价为零）。
       */
      html = '<' + semTag + ' style="' + norm(css) + '"><span leaf="">' + escTxt(body) + '</span></' + semTag + '>';
    }
    /*
     * ★ v2.6.12：内联源码档 —— `semTag` 为空 ⇒ 这是一条**非纯文字样式**的配方
     *   （含 display / margin / padding / border / border-radius / background-color
     *   里的至少一条）。这类配方在 schema 里**只有 `<a>` 能带整条 style**
     *   （link / poi_link / weapp_link —— 行内标记 7 个里能带 style 的全是 `<a>`），
     *   而 `<a>` 在微信保存链路上必被剥：
     *     · 真机实证：保存前 `<a>` ×4 → 保存后 `<a>` ×0，而同批 `strong[…]` 存活；
     *     · 排版编辑器源码（md-wechat · src/lib/renderer.js）独立写着同一结论：
     *       「其余外链在粘贴时会被微信编辑器直接剥离（只剩文字，网址也丢失）……
     *         链接外壳换成 span：保留链接的视觉样式，但不再是 <a>（微信会剥掉）」。
     *   ⇒ 改送 `<span style="整条配方">`：形态与 md-wechat 的输出完全一致，
     *     不带 href（不再是清洗目标），全部分量原样保留。
     *
     *   内层 `<span leaf="">` 与 v2.6.9 的语义档同理 —— 宿主正文里每个文字 run
     *   都套着 leaf span，自带该结构就与它的原生形态同构（自带则原样保留，
     *   不自带由它自己补，代价为零）。
     *
     *   ★ v2.6.23：三档已塌成「内联源码档」一档 —— semTagForHtml 统一返回 ''，
     *     故 `!semTag` 对**所有**样式恒成立：上方语义档（<strong>）与本档之后的
     *     配方档回落，在真机 schema 无语义标记下均不再触发，一律走本档 <span style>。
     *     历史分档说明（v2.6.8~v2.6.22）：加粗/朱红加粗 ⇒ semTag='strong' 语义档、
     *     朱红下划线 ⇒ semTag='u' 配方档、其余 ⇒ semTag='' 本档 —— 现已全部归并。
     *
     *   最坏情形：宿主仍不接纳 ⇒ wideVerify 判「未全部达标」⇒ 未采纳 ⇒ 自动回退
     *   配方节点替换 —— 与 v2.6.11 逐字等价（不更差）。这条回退由既有链路负责，
     *   本档只改「送出去的 HTML」。
     */
    if (!html && !semTag && norm(css)) {
      html = '<span style="' + norm(css) + '"><span leaf="">' + escTxt(body) + '</span></span>';
    }
    if (!html) {                                 // semTag 给了非白名单语义标签：仍送配方原文
      var wrapEl = null;
      try { wrapEl = mkWrapEl(ctx, ctx.doc, css); } catch (eW0) { wrapEl = null; }
      if (wrapEl) {
        try { wrapEl.textContent = body; html = String(wrapEl.outerHTML); } catch (eW1) { html = ''; }
      }
    }
    if (!html) {                       // 连裸 span 都造不出时，退回手写串（行为不更差）
      var wTag = semTagForHtml(css) || 'span';
      html = '<' + wTag + ' style="' + norm(css) + '">' + escTxt(body) + '</' + wTag + '>';
    }
    var sent = String(html).slice(0, 180);   // 取证：送进去的写法（失败流水回显）
    var ok = widePaste(ctx, html, body);
    /*
     * ★ v2.5.1：落点自检。
     *   粘贴只会**替换选区**，正文总长不该变。一旦变长，就说明它插到了别处
     *   （典型是文首多出一份）—— 此时必须当场说清楚，不能按「已送达」报成功，
     *   否则用户拿到的是一篇开头多一截的稿子，而提示还在说「已应用」。
     */
    var grew = 0, moved2 = '';
    try {
      var t1 = String(ctx.root.textContent || '').length;
      if (len0 >= 0) grew = t1 - len0;
      var nk1 = ctx.root.children.length;
      if (nk0 >= 0 && nk1 !== nk0) moved2 = '顶层块数 ' + nk0 + '→' + nk1;
      var head1 = String((ctx.root.children[0] && ctx.root.children[0].textContent) || '').slice(0, 24);
      if (!selInFirst && head0 && head1 && head0 !== head1) moved2 += (moved2 ? '；' : '') + '首块文字变了';
    } catch (e10) {}
    /*
     * ★ v2.6.15：判据从两重（长度 / doc 指纹）扩到三重（再加结构层）。
     *   三条任意一条为真就按「落点不对」处理，并**当场撤销**这次粘贴。
     */
    var sigPasted = pmSigOf(ctx);
    /*
     * ★★ v2.6.17：**删掉 docMoved 这个判据**。
     *   v2.6.14 引入它是为了捕「长度互相抵消」的露判，但它把「粘贴成功替换选区」也算成了错位：
     *   把文字包上样式，doc 指纹**必然**变 ⇒ 每一次成功的宽载体粘贴都被判「落点错误」并撤销，
     *   然后回退到配方节点替换（保存后被微信剥）—— 两条腿同时断。
     *   真正指向「错位」的只有两条：
     *     · grew > 0：正文总长变长（粘贴只会替换选区，不该变长）；
     *     · moved2：顶层块数变了 / 选区不在首块时首块文字变了。
     */
    if (grew > 0 || moved2) {
      WIDE_TRIED = 'misplaced+' + grew + (moved2 ? '+dom' : '');
      var rbA = wideRollback(ctx, sig0, sigPasted);
      /* ★ v2.6.15：撤销后**复核**正文长度有没有真的回到粘贴前 ——
         没回去就如实说，不许报「已自动撤销」（v2.6.14 就是这么谎报的）。 */
      var backA = false;
      try { backA = (len0 >= 0) && String(ctx.root.textContent || '').length === len0; } catch (e11) {}
      return { done: false, touched: ok, sent: sent,
        why: '粘贴没落在选区上（落点由编辑器自己的光标决定，很可能插到了文首）'
          + (moved2 ? '　现场：' + moved2 : '')
          + (rbA && backA ? '　已自动撤销这次粘贴'
             : (rbA ? '　已撤销，但正文长度没回原样，请核对开头'
                : '　自动撤销没成功，请按 Ctrl+Z 撤销后重试')) };
    }

    // touched：宿主**动过手**（哪怕只是把选区内容换成同样的文字）。
    // 只有动过手才需要事后重新定位选区；没动过手就原样退回，零代价。
    // ★ v2.6.15：这一条恢复 v2.6.12 的语义。v2.6.14 曾把它改成「回滚失败」——
    //   那是**混用了两个不同的量**：「文档回到起点了」不等于「宿主没动过手」。
    //   宿主只要接了粘贴（ok=true），它自己的渲染管线就跑过一轮，我们先前
    //   isolateRun 切出来的那些文本节点很可能已经作废（v2.0 补丁 H 的注释
    //   把这条写得很清楚）。所以 touched 恒取 ok，撤销成不成只影响 why 文案。
    if (!ok) return { done: false, why: WIDE_TRIED || 'unknown', touched: false, sent: sent };

    /*
     * ★ 事后验真（v2.0）
     *   「宿主 preventDefault 了」只证明它**看**了这次粘贴，不证明它**收下**了这些声明 ——
     *   受控编辑器的剪贴板解析器同样只认 schema 里有的属性，差集声明照样会被静默丢掉。
     *   本项目已经因为「假接纳」栽过一次（探针在游离元素上读得回、真插进文档却建不起来），
     *   所以这里不接受「它没拒绝」当作成功。
     *   粘贴之后回头查一遍：被点名的那几个差别声明，有没有真的落到内联 style 上。
     *   没落地就如实返回失败原因，由调用方退回配方节点替换 —— 宁可退让，不许谎报。
     */
    var dl = wideDecls(css);
    var vf = wideVerify(ctx, body, dl, { before: beforeMap, targets: declsOf(css) });
    if (!vf.ok) {
      /*
       * ★ v2.6.14：验真失败也必须**当场撤销**这次粘贴。
       *   宿主接了粘贴就说明它动过文档；那份没落地的内容照样留在正文里 ——
       *   不撤销，用户每点一次就多一份（现场报告里连着 4 次操作全走这条路）。
       *   撤销后 touched=false ⇒ 调用方不必重新选、也不再弹「请重新选中文字再点一次」。
       */
      var rbB = wideRollback(ctx, sig0, null);
      var backB = false;
      try { backB = (len0 >= 0) && String(ctx.root.textContent || '').length === len0; } catch (e12) {}
      return { done: false, touched: ok, sent: sent,
        why: '宿主接了粘贴，但正文里没有一个行内包裹带上目标声明（'
          + (dl.length ? dl : Object.keys(declsOf(css))).slice(0, 5).join('、') + '）'
          + ((vf.partial && vf.partial.length) ? '　只落地了=[' + vf.partial.join('、') + ']' : '')
          + '　基线已有=[' + Object.keys(beforeMap || {}).slice(0, 8).join('、') + ']'
          + (rbB && backB ? '　已自动撤销这次粘贴'
             : (rbB ? '　已撤销，但正文长度没回原样，请核对开头'
                : '　自动撤销没成功，请按 Ctrl+Z 撤销')) };
    }
    return { done: true, why: WIDE_TRIED || 'accepted', hit: vf.hit, ev: vf.ev, pre: !!vf.pre, touched: true, sent: sent };
  }

  /*
   * ★ v2.6.7：行内包裹「祖先链有效样式」（内层优先）—— 用于取粘贴前的样式基线。
   *   只合并行内白名单元素（INLINE_WRAP），块级容器（section / p / div）自带的外框声明
   *   一律不算 —— 那条坑 v2.0 补丁 G 已经栽过一次（块级 padding / display 骗过验真）。
   *   为什么要向上走而不是只取 parentNode：编辑器自己的正文结构是
   *   <包裹><span leaf>文字</span></包裹>（报告二·C「正文首块原文」），
   *   文字的直接父元素是那个不带样式的 leaf span —— 只查一层必然漏判。
   */
  function inlineChainStyle(node, root) {
    var out = {}, el = node && node.parentNode, hop = 0;
    while (el && el.nodeType === 1 && hop++ < 12) {
      if (INLINE_WRAP[el.tagName]) {
        var d = declsOf(el.getAttribute('style') || '');
        for (var k in d) { if (!(k in out)) out[k] = d[k]; }
      }
      if (el === root) break;
      el = el.parentNode;
    }
    return out;
  }

  /*
   * ★ v2.6.7：颜色写法归一（#RGB / #RRGGBB / rgb() / rgba() 统一成 rgb(r,g,b)）。
   *   刻意自带转换、不调 p2 的 hexToRgbStr —— 本函数会被装置单独抽出注入，
   *   每多一层跨模块依赖，就多一个「引用不到 ⇒ 静默 ReferenceError」的机会。
   */
  function hexNorm(v) {
    var t = String(v == null ? '' : v).replace(/\s+/g, '');
    var m6 = /^#([0-9a-f]{6})$/.exec(t);
    if (m6) {
      var n = parseInt(m6[1], 16);
      return 'rgb(' + ((n >> 16) & 255) + ',' + ((n >> 8) & 255) + ',' + (n & 255) + ')';
    }
    var m3 = /^#([0-9a-f]{3})$/.exec(t);
    if (m3) {
      var h = m3[1];
      var n2 = parseInt(h.charAt(0) + h.charAt(0) + h.charAt(1) + h.charAt(1) + h.charAt(2) + h.charAt(2), 16);
      return 'rgb(' + ((n2 >> 16) & 255) + ',' + ((n2 >> 8) & 255) + ',' + (n2 & 255) + ')';
    }
    var mr = /^rgba?\(([0-9.]+),([0-9.]+),([0-9.]+)/.exec(t);
    if (mr) return 'rgb(' + Math.round(+mr[1]) + ',' + Math.round(+mr[2]) + ',' + Math.round(+mr[3]) + ')';
    return t;
  }

  /*
   * ★ v2.6.7：样式值等价判定（跨写法归一）。只用于两处判定：
   *     ① 值相对「粘贴前基线」有没有**变化**  ② 值是否就是配方目标
   *   归一三件事：小写去空白 / 颜色写法 / 字重别名（bold ↔ 700、normal ↔ 400）。
   */
  function valSame(a, b) {
    var x = String(a == null ? '' : a).trim().toLowerCase().replace(/\s+/g, '');
    var y = String(b == null ? '' : b).trim().toLowerCase().replace(/\s+/g, '');
    if (!x || !y) return x === y;
    var wa = { bold: '700', normal: '400', bolder: '700', lighter: '300' };
    if (x.charAt(0) === '#' || x.indexOf('rgb(') === 0 || x.indexOf('rgba(') === 0) x = hexNorm(x);
    if (y.charAt(0) === '#' || y.indexOf('rgb(') === 0 || y.indexOf('rgba(') === 0) y = hexNorm(y);
    if (wa[x]) x = wa[x];
    if (wa[y]) y = wa[y];
    return x === y;
  }

  /*
   * 宽载体的「事后验真」：在正文里找到那段文字，看它所在元素身上
   * 有没有真的带上被点名的差别声明，且**必须落在内联 style 属性上** ——
   * 写在自定义属性（textstyle 一类）里不算数，安卓端根本不认它。
   *
   * 判据刻意只收「差别声明」这一小撮（display / padding / border* / border-radius）：
   * 它们正是徽标与标签**唯一**的区别所在，也是 schema 层最爱丢的那几个。
   * line-height 这类与形状无关的声明不参与判定 —— 拿它当判据会把
   * 「border 其实丢了、只有 line-height 活着」误判成成功。
   */
  var SHAPE_DECLS = ['display', 'padding', 'padding-top', 'padding-right', 'padding-bottom',
    'padding-left', 'border', 'border-width', 'border-style', 'border-color', 'border-radius'];

  // 行内包裹元素的白名单 —— 只有这些才可能承载「这次粘贴给某几个字加的样式」
  var INLINE_WRAP = { SPAN: 1, A: 1, EM: 1, STRONG: 1, B: 1, I: 1, U: 1, S: 1, DEL: 1, INS: 1, CODE: 1, MARK: 1 };

  /*
   * ★ v2.6.6：文本匹配归一。
   *   旧判据是**全等**（node.nodeValue === text）——真机里宿主会把粘贴进来的文字
   *   并入相邻文本节点（或拆开），nodeValue 于是不再是「完整那一段」，
   *   判据就变成「明明写进去了却找不到」的假失败。改成「包含 + 去空白」。
   */
  function squashWs(t) { return String(t == null ? '' : t).replace(/\s+/g, ''); }

  function nodeHasText(n, text) {
    var nv = String((n && n.nodeValue) || '');
    if (nv === text || nv.indexOf(text) >= 0) return true;
    return squashWs(nv).indexOf(squashWs(text)) >= 0;
  }

  function wideVerify(ctx, text, decls, opts) {
    var i, need = [];
    var before = (opts && opts.before) || null;      // 粘贴前的行内样式基线（v2.6.7）
    var tgt = (opts && opts.targets) || null;        // 配方原文的声明表（v2.6.7）
    for (i = 0; i < decls.length; i++) {
      if (SHAPE_DECLS.indexOf(decls[i]) >= 0) need.push(decls[i]);
    }
    if (!need.length) need = decls.slice();          // 没有形状声明时，退而看任意差集声明
    /*
     * 要查的目标属性：
     *   ① 有配方声明表 ⇒ 用它（纯文字样式这才查得到 font-weight 一类，旧版这里恒真）；
     *   ② 没有（装置直调本函数）⇒ 退回差集声明，行为与 v2.6.6 一致。
     */
    var keys = [], tk;
    if (tgt) { for (tk in tgt) { if (tgt[tk] != null && tgt[tk] !== '') keys.push(tk); } }
    if (!keys.length) keys = need.slice();
    var hit = [], ev = '', found = false, preOk = false, partial = [];
    try {
      var w = ctx.doc.createTreeWalker(ctx.root, 4, null, false), n;   // 4 = SHOW_TEXT
      while ((n = w.nextNode())) {
        /*
         * ★ v2.6.6：匹配放宽（全等 ⇒ 包含 + 去空白）。
         *   宿主把粘贴的文字并入相邻文本节点后，nodeValue 不再是「完整那一段」，
         *   旧的全等判据于是报假失败 —— 明明写进去了，却找不到。
         */
        if (!nodeHasText(n, text)) continue;
        var pEl = n.parentNode;
        if (!pEl || pEl.nodeType !== 1) continue;
        if (!keys.length) {
          /*
           * ★ 无目标表、也无差集声明的退化路径（只为兼容装置直调：
           *   它问的是「宿主到底接没接住这种形态」，不是「样式有没有真的变」）。
           *   真机主链路上 keys 永远非空 ⇒ 走不到这里。
           */
          if (INLINE_WRAP[pEl.tagName] && String(pEl.getAttribute('style') || '')) {
            found = true; ev = String(pEl.outerHTML).slice(0, 200); break;
          }
          continue;
        }
        /*
         * ★ v2.6.7：判据从「有没有带 style 的包裹」升级为
         *   「**这次粘贴**有没有带来【值发生变化】的目标声明」。
         *   旧判据在现场恒真：正文文字本来就包在 span[color…;font-size…] 里
         *   （报告二·C 抓到 11 个）⇒ 任何纯文字样式都被判「已采纳」⇒ 调用方
         *   随即 return ⇒ 直连回退一次都没跑过（加粗在手机上不粗的真因）。
         *   现在只认「相对基线新增 / 改变」的属性，既有包裹再漂亮也不算数。
         *   包裹沿祖先链找（inlineChainStyle 同一白名单），漏判 leaf span 包裹外层的问题一并修掉。
         */
        var chain = inlineChainStyle(n, ctx.root);
        /*
         * ★ v2.6.9：判据收口到「**基线未达标**的目标声明，现在达标了」。
         *
         *   v2.6.7 的 changed（值相对基线变了就算命中）有两个致命缺口，
         *   2026-09-20 20:37 的真机报告把两个都现了形：
         *     ① 值**变错方向**也算命中 —— 默认徽标选中的文字原本在 strong 里
         *        （基线 font-weight=bold），粘贴后 strong 被剥、字重退回 normal
         *        ⇒ 「变了」⇒ 报「已采纳　验真命中=[font-weight]」，而它想验的
         *        font-weight:600 压根没落地。这是**假成功**：调用方见到 done
         *        就 return，公式路径一次都不会跑。
         *     ② 基线**已经**等于目标时 changed 恒 false ⇒ 同一份报告里加粗那条
         *        成了**假失败**（文字本来就粗，再怎么粘也「没变化」）。
         *
         *   现在两层都修，判据只剩一句话：
         *     目标声明里，凡是基线**不**满足的，必须真的变成目标值；
         *     基线已满足的那些不参与判定（它们本来就对，不该拿来充功）。
         *     若目标声明基线已全部满足 ⇒ 这一处「本来就带这套样式」，
         *     记 preOk（调用方据此说「无需改动」，不再假报「完整送达」）。
         */
        /*
         * ★ v2.6.10：判据再收一步 —— 从「**至少一条**目标声明达标」
         *   改为「基线未达标的那些目标声明【全部】达标」。
         *
         *   v2.6.9 的 ok = hit.length > 0 还剩最后一层假成功壳：
         *   目标含两条声明（如朱红加粗 = color + font-weight）时，
         *   只落地一条也算通过 ⇒ 调用方 return ⇒ 配方回退一次都不跑。
         *   真机实证（2026-09-20 21:03:37）：
         *     朱红加粗 · 宽载体已采纳　验真命中=[font-weight]　证据=<span leaf="">…
         *     目标 color:#9F312A 压根没落地，却报了「已采纳」；
         *     随后 ok 字符 -326 / revert（编辑器回滚）⇒ 净结果什么也没成。
         *   而同一会话的「加粗」只差一条 ⇒ 被判未采纳 ⇒ 正确回退 ⇒ 全绿。
         *   ⇒ 一条判据之差，决定了用户看到的是「成功」还是「静默失败」。
         *
         *   判据（一句话）：把目标声明按「基线是否已达标」分成两拨 ——
         *     · 基线已达标的：不参与判定（本来就对，不该拿来充功）；
         *     · 基线未达标的：**每一条**都必须真落到目标值。
         *   全落 ⇒ 通过；缺任何一条 ⇒ 不通过（partial 记下落了哪几条，供诊断）。
         *   基线已全部达标 ⇒ preOk（调用方说「无需改动」，不假报送达）。
         */
        var got = [], gotD = [], pend = 0, k2, av2, tv2, hasTgt = false;
        for (i = 0; i < keys.length; i++) {
          k2 = keys[i];
          av2 = chain[k2];
          tv2 = (tgt && tgt[k2] != null) ? tgt[k2] : null;
          if (tv2 == null) {
            /*
             * 拿不到目标值（装置直调 wideVerify，或配方没给这个键的值）。
             * ★ 退回 v2.6.7 的「相对基线发生变化」判据 —— 这里必须是**退化**路径，
             *   不能算进 preOk：否则「全部键都拿不到目标值」时 pend 恒为 0，
             *   判据会退化成恒真（rep258 H1 当场抓到这个假绿）。
             *   v2.6.10：退化命中另记 gotD —— 不能与「待达标已满足」混在一个计数里，
             *   否则 1 条退化 + 1 条待达标只落 0 条也会凑够数（新的假绿）。
             */
            if (av2 != null && av2 !== '' && (!before || !valSame(av2, before[k2]))) gotD.push(k2);
            continue;
          }
          hasTgt = true;
          if (before && valSame(before[k2], tv2)) continue;  // 基线已达标 ⇒ 无需变化
          pend++;
          if (av2 != null && av2 !== '' && valSame(av2, tv2)) got.push(k2);
        }
        /* 只有「确实存在目标值、且基线里已全部达标」才算「本来就带这套样式」 */
        if (hasTgt && !pend) {
          if (!hit.length) { preOk = true; hit = keys.slice(); ev = String(pEl.outerHTML).slice(0, 200); }
          break;
        }
        if (hasTgt) {
          if (got.length >= pend) { hit = got.slice(); ev = String(pEl.outerHTML).slice(0, 200); break; }
          if (got.length > partial.length) partial = got.slice();   // 只落一部分 ⇒ 不接受，记证
          continue;
        }
        if (gotD.length) { hit = gotD.slice(); ev = String(pEl.outerHTML).slice(0, 200); break; }
      }
    } catch (e) {}
    if (!keys.length) {
      return { ok: found, hit: found ? ['inline-wrap'] : [], ev: ev || '(未找到带样式的行内包裹)' };
    }
    return { ok: hit.length > 0, hit: hit, ev: ev, pre: preOk, partial: partial };
  }

  function insertHTMLAtCursor(ctx, html) {
    var sel = ctx.win.getSelection();
    if (!sel || !sel.rangeCount) { toast('请先把光标放到正文里再粘贴'); return; }
    var r = sel.getRangeAt(0);
    r.deleteContents();
    var frag = r.createContextualFragment(html);
    var last = frag.lastChild;
    r.insertNode(frag);
    if (last) {
      var rr = ctx.doc.createRange();
      rr.setStartAfter(last);
      rr.collapse(true);
      applySel(ctx, rr);
    }
  }

  function bindPaste(ctx) {
    var doc = ctx.doc;
    if (doc.__mptbPaste) return;
    doc.__mptbPaste = true;
    doc.addEventListener('paste', function (e) {
      // 宽载体（脚本自己派发的合成粘贴）要走宿主通道，自家的清洗监听必须让路。
      // 判据以 doc 上的标记为准 —— ctx 是闭包捕获的副本，靠不住（v2.0 补丁 H）。
      if (doc.__mptbInject || ctx.__mptbInject) return;
      var dt = e.clipboardData;
      if (!dt) return;

      // ① 图片/视频文件：不抢上传通道（鉴权、素材库写入都由编辑器自己做）
      var items = dt.items || [];
      for (var i = 0; i < items.length; i++) {
        if (items[i].kind === 'file') {
          var tp = items[i].type || '';
          if (/^image\//i.test(tp) || /^video\//i.test(tp)) {
            toast(/^video\//i.test(tp)
              ? '检测到视频：请用编辑器的「视频」按钮上传，粘贴通道不接管视频'
              : '检测到图片：正在交给编辑器上传…');
            return;
          }
        }
      }

      // ② 外来 HTML：白名单清洗后再插入
      var html = dt.getData('text/html');
      if (!html) return;
      loadTablePref();                       // 表格配色取最新设置
      var hasTbl = /<table[\s>]/i.test(html);
      var cleaned = cleanForeignHTML(ctx, html);
      if (!cleaned) return;
      snapshot('清洗粘贴');
      e.preventDefault();
      /* ★ v2.6.13：含表格时**优先走宿主自己的导入通道**（合成 paste）。
         理由：insertHTMLAtCursor 是直接改 DOM、绕过 ProseMirror 的 state ——
         对行内片段可行，对**块级新结构**风险大（可能被下一次归一化吃掉）。
         而宿主那条通道本来就是用来接纳「第三方编辑器粘进来的 HTML」的：
         我们取证的那篇线上文章的 flex 表格，正是从这条路进去并活到了发布。
         宿主不收（defaultPrevented 为假）再退回直插，功能不丢。 */
      if (hasTbl && widePaste(ctx, cleaned, dt.getData('text/plain') || '')) {
        toast('已清洗并重建表格（走宿主导入通道）');
        return;
      }
      insertHTMLAtCursor(ctx, cleaned);
      toast(hasTbl
        ? '已清洗并重建表格（宿主未接纳合成粘贴，改为直接插入）'
        : '已按微信白名单清洗粘贴内容');
    }, true);
  }
  /* ══════════════════════════════════════════════════════════════════
   * 9. 提示与对话框（全部挂在主文档，避免被编辑器 iframe 吞掉）
   * ══════════════════════════════════════════════════════════════════ */

  var toastTimer = null;

  function toast(msg) {
    var el = document.getElementById('mptb-toast');
    if (!el) {
      el = document.createElement('div');
      el.id = 'mptb-toast';
      document.body.appendChild(el);
    }
    el.textContent = msg;
    el.classList.add('on');
    clearTimeout(toastTimer);
    toastTimer = setTimeout(function () { el.classList.remove('on'); }, 1900);
  }

  function closeDialog() {
    var old = document.getElementById('mptb-dlg');
    if (old && old.parentNode) old.parentNode.removeChild(old);
  }

  function openDialog(opt) {
    closeDialog();
    var mask = document.createElement('div');
    mask.id = 'mptb-dlg';
    mask.className = 'mptb-mask';

    var box = document.createElement('div');
    box.className = 'mptb-box';

    var hd = document.createElement('div');
    hd.className = 'mptb-box-hd';
    hd.textContent = opt.title || '';
    box.appendChild(hd);

    if (opt.msg) {
      var mg = document.createElement('div');
      mg.className = 'mptb-box-msg';
      mg.textContent = opt.msg;
      box.appendChild(mg);
    }

    // 诊断报告这类多行文本：用 pre 原样呈现，方便直接圈选复读
    if (opt.pre) {
      var pre = document.createElement('pre');
      pre.className = 'mptb-diag';
      pre.textContent = opt.pre;
      box.appendChild(pre);
    }

    var inputs = {};
    (opt.fields || []).forEach(function (f) {
      var row = document.createElement('div');
      row.className = 'mptb-box-row';
      /* ★ v2.6.17：字段行挂语义 id —— 断言/自动化按**字段语义**取元素，
         不再靠 qa('#mptb-dlg input')[1] 这种位置索引。
         位置索引的代价本轮刚付过：主色由 select 改成平铺色板（多一个 hidden
         input 插在最前），后面每个索引整体错位，且错位后有一半断言仍然**假绿**。 */
      row.id = 'mptb-f-' + f.k;
      var lb = document.createElement('label');
      lb.className = 'mptb-box-lb';
      lb.textContent = f.label || f.k;
      /*
       * ★ v2.6.13：字段支持 type:'select'。
       *   表格配色是「从几个色板里挑一个」而不是敲数字 —— 用下拉比让人手打
       *   #RRGGBB 友好得多，也就不会再出现「打错了不知道」的静默失败。
       *   其余字段一切照旧走文本框（含 ph 占位提示）。
       */
      var ip;
      if (f.type === 'select' && f.options && f.options.length) {
        ip = document.createElement('select');
        ip.className = 'mptb-box-ip mptb-box-sel';
        (f.options).forEach(function (o) {
          var op = document.createElement('option');
          op.value = String(o.v);
          op.textContent = String(o.label == null ? o.v : o.label);
          if (String(o.v) === String(f.value)) op.selected = true;
          ip.appendChild(op);
        });
      } else if (f.type === 'swatches' && f.options && f.options.length) {
        /*
         * ★ v2.6.17：平铺色板 —— 一眼看到全部方案，单击即选中。
         *   比下拉少一步（不用展开），也不会像手打 hex 那样静默打错。
         *   值存在 hidden input 里 ⇒ ok() 取值的地方（v[k] = inputs[k].value）一行都不用改。
         */
        ip = document.createElement('input');
        ip.type = 'hidden';
        ip.className = 'mptb-box-ip';
        ip.value = f.value == null ? '' : String(f.value);
        var sw = document.createElement('div');
        sw.className = 'mptb-box-sw';
        /*
         * ★ v2.6.22：点「自定义」直接弹**系统色卡**（原生 `<input type="color">`）。
         *   选完把色值回填到下一行的「自定义主色」输入框（字段间由 f.linked 串起来，
         *   不靠位置索引 —— 位置索引在本项目已经错过两次，见 v2.6.17 的注释）。
         *   ⚠️ picker 必须**挂在 DOM 里**才弹得出来（游离节点在部分浏览器不弹）。
         */
        var picker = null, dotC = null;
        (f.options).forEach(function (o) {
          var sb = document.createElement('button');
          sb.type = 'button';
          sb.className = 'mptb-box-swc';
          /* data-v = 本块的取值。断言要「点第二块」时不该数序号，
             而应点「藏青那块」——序号会随色板增删漂移。 */
          sb.setAttribute('data-v', String(o.v));
          var isCustom = (String(o.v) === '__custom');
          var dot = document.createElement('span');
          dot.className = 'mptb-box-swdot' + (isCustom ? ' mptb-swdot-custom' : '');
          if (/^#[0-9a-fA-F]{6}$/.test(String(o.v))) {
            dot.style.background = String(o.v);
          } else {
            dot.textContent = '?';
            dot.style.lineHeight = '12px';
            dot.style.fontSize = '9px';
            dot.style.textAlign = 'center';
            dot.style.color = '#999';
            dot.style.background = '#fff';
          }
          var tx = document.createElement('span');
          tx.textContent = String(o.label == null ? o.v : o.label);
          sb.appendChild(dot); sb.appendChild(tx);
          if (String(o.v) === String(ip.value)) sb.classList.add('on');
          if (isCustom) dotC = dot;
          sb.addEventListener('click', function () {
            ip.value = String(o.v);
            var all = sw.querySelectorAll('.mptb-box-swc');
            for (var q = 0; q < all.length; q++) all[q].classList.remove('on');
            sb.classList.add('on');
            if (!isCustom || !picker) return;
            /* 弹色卡前先把当前值同步进去 —— 手输过 #RRGGBB 的用户不该被重置回默认色 */
            var rH = document.getElementById('mptb-f-' + (f.linked || 'hex'));
            var iH = rH ? rH.querySelector('input.mptb-box-ip') : null;
            if (iH && /^#[0-9a-fA-F]{6}$/.test(String(iH.value).trim())) {
              picker.value = String(iH.value).trim();
            }
            picker.click();
          });
          sw.appendChild(sb);
        });
        /* 色卡本体：隐藏着挂在行内，只在「自定义」块被点时才弹 */
        picker = document.createElement('input');
        picker.type = 'color';
        picker.className = 'mptb-box-colorpick';
        picker.value = '#D5281E';
        picker.setAttribute('data-v', '__custom');
        picker.addEventListener('input', function () {
          var v2 = String(picker.value || '').toUpperCase();
          if (!/^#[0-9A-F]{6}$/.test(v2)) return;
          ip.value = '__custom';
          if (dotC) { dotC.style.background = v2; dotC.textContent = ''; }
          var rH2 = document.getElementById('mptb-f-' + (f.linked || 'hex'));
          var iH2 = rH2 ? rH2.querySelector('input.mptb-box-ip') : null;
          if (iH2) iH2.value = v2;
        });
        row.appendChild(lb);
        row.appendChild(sw);
        row.appendChild(ip);
        /*
         * ★★ v2.6.22 修正①：色卡必须**真的挂进 DOM**才弹得出来
         *   （上面那行注释写的就是这件事，代码却漏了这一步 ⇒ 点「自定义」永远不弹）。
         *   CSS 把它置成 fixed + 1px + opacity:0 + pointer-events:none
         *   ⇒ 不占位、不遮挡、不可点，只作为「触发原生色卡」的锚。
         * ★★ 修正②：必须挂在 **ip 之后**，不许塞进 sw。
         *   脚本与装置都用 `#mptb-f-<k> input` 取字段值，而 querySelector 返回的
         *   是**树序第一个** input —— 色卡插在取值框之前就会被当成取值框
         *   ⇒ 主色 / 自定义主色 全部读错（实测 T91a4 / T91b2 / T93b / T93c 四条红）。
         *   两条分别由 T91a3（在不在、挂没挂）与 T91a3b（有没有顶掉取值处）看守。
         */
        row.appendChild(picker);
        box.appendChild(row);
        inputs[f.k] = ip;
        return;
      } else {
        ip = document.createElement('input');
        ip.className = 'mptb-box-ip';
        ip.type = 'text';
        ip.value = f.value || '';
        ip.spellcheck = false;
        if (f.ph) ip.placeholder = f.ph;
      }
      row.appendChild(lb);
      row.appendChild(ip);
      box.appendChild(row);
      inputs[f.k] = ip;
    });

    var ft = document.createElement('div');
    ft.className = 'mptb-box-ft';

    var cancel = document.createElement('button');
    cancel.type = 'button';
    cancel.className = 'mptb-chip gh';
    cancel.textContent = '取消';
    cancel.addEventListener('click', closeDialog);

    var ok = document.createElement('button');
    ok.type = 'button';
    ok.className = 'mptb-chip pri';
    ok.textContent = opt.okText || '确定';
    ok.addEventListener('click', function () {
      var v = {};
      for (var k in inputs) v[k] = inputs[k].value;
      closeDialog();
      setTimeout(function () {
        // 确认框里的操作同样要有流水 + 宿主通知，「确定」之后没人知道成没成
        /*
         * ★ v2.6.15：补上 beforeKids，并把 nextActSeq() 提到最前。
         *   ① safeSolid 的第 3 参 beforeKids 是「改动前的顶层子节点清单」，
         *      solidPM 靠它逐块比对，才能把**结构级**改动（如 <table> 重建成
         *      <section>）翻译成节点替换交给宿主；漏传时结构变更会被宿主整块
         *      重渲染回去 —— 现场表现就是「点了套用，表格没变」
         *      （失败报告 2026-09-21 10:45）。
         *   ② nextActSeq() 必须**先于** safeSolid 取号（runAct 里就是这个顺序）；
         *      反了会让本次改动自己那一次操作也被代号闸门挡住。
         */
        var c0 = pickEditor();
        var before = c0 ? c0.root.innerHTML : null;
        var beforeKids = c0 ? kidsHTML(c0.root) : null;
        var seq = nextActSeq();
        var sig0 = c0 ? pmSigOf(c0) : null;
        try {
          if (opt.ok) opt.ok(v);
        } catch (err) {
          trace('err', (opt.title || '对话框') + ' · ' + (err && err.message));
          toast('执行失败：' + (err && err.message));
        }
        if (c0) finishEdit(c0, before, opt.title || '确认操作', safeSolid(c0, before, beforeKids), seq, sig0);
      }, 0);
    });

    ft.appendChild(cancel);
    (opt.extra || []).forEach(function (ex) {
      var eb = document.createElement('button');
      eb.type = 'button';
      eb.className = 'mptb-chip gh';
      eb.textContent = ex.text;
      eb.addEventListener('click', function (ev) {
        ev.preventDefault();
        /* 把 inputs 透给回调：
         * 「恢复默认 16 / 1.8 / 0 / 0」这类附加按钮必须能把新值**写回输入框**，
         * 否则用户点了看不到任何变化，只能自己再手打一遍。 */
        try { ex.fn(inputs); } catch (err) { trace('err', (ex.text || '附加按钮') + ' · ' + (err && err.message)); }
      });
      ft.appendChild(eb);
    });
    ft.appendChild(ok);
    box.appendChild(ft);

    mask.appendChild(box);
    document.body.appendChild(mask);

    setTimeout(function () {
      var first = box.querySelector('input');
      if (first) { first.focus(); first.select(); }
      else ok.focus();
    }, 30);

    mask.addEventListener('keydown', function (e) {
      if (e.key === 'Enter') { e.preventDefault(); ok.click(); }
      else if (e.key === 'Escape') { e.preventDefault(); closeDialog(); }
    });
  }

  function openConfirm(title, msg, onOk) {
    openDialog({ title: title, msg: msg, fields: [], okText: '确定执行', ok: function () { onOk(); } });
  }

  /* ══════════════════════════════════════════════════════════════════
   * 9b. 「执行一次排版操作」的统一包装
   *
   *   所有按钮都必须走这里，因为它兜住三件不能靠人眼保证的事：
   *     ① 出错必须说出来 —— 以前 handler 里抛异常，用户看到的只是一句
   *        「点了没反应」，连报错都没有；
   *     ② 操作后必须通知宿主，否则草稿里存的还是旧内容；
   *     ③ 改动有没有真的落地 / 有没有被宿主回滚 —— 记进流水供诊断导出。
   * ══════════════════════════════════════════════════════════════════ */

  /*
   * ★ v1.9 操作代号（generation token）。
   *   回滚探针是延迟采样的，它必须能判断「我离开之后有没有人再动过」——
   *   否则用户紧接着点「取消」，DOM 恰好回到本次操作前的样子，
   *   过期探针就会把「用户撤销」误判成「编辑器回滚」，弹一句吓人的话。
   *   规则很简单：一次操作只对它自己造成的状态负责；代号变了就闭嘴。
   */
  var ACT_SEQ = 0;

  function nextActSeq() { ACT_SEQ++; return ACT_SEQ; }

  function runAct(label, fn) {
    var seq = nextActSeq();
    var c0 = pickEditor();    var before = c0 ? c0.root.innerHTML : null;
    /*
     * ★ v2.5.1：改动前顺手记下「顶层子节点清单」。
     *   solidPM 要拿它跟改动后的清单逐块比对；以前是拿 before 字符串**反解**回去
     *   （等于每次点击让浏览器重建一整棵文档树，只为了取 children 的 outerHTML）。
     *   这里多抓一份清单，就把那次整篇解析彻底省掉 —— 正文越长省得越多。
     */
    var beforeKids = c0 ? kidsHTML(c0.root) : null;
    /* 每次操作前先给编辑器照一张「内容指纹」，判回滚用它（比 innerHTML 稳） */
    var sigBefore = c0 ? pmSigOf(c0) : null;
    if (c0) trace('act', label + ' · ' + ctxDesc(c0));
    else trace('act', label + ' · 未定位到编辑器');
    try {
      fn();
    } catch (e) {
      trace('err', label + ' · ' + (e && e.message));
      toast('执行失败：' + (e && e.message));
      return;
    }
    if (!c0) return;
    /*
     * 确认框类操作要等用户点「确定」之后才真正改 DOM —— 那一步由 openDialog
     * 自己核对（见上），这里就不能再判一次「没改动」，否则会误报。
     */
    var openedDialog = !!document.getElementById('mptb-dlg');
    if (openedDialog) return;

    /*
     * ★ v1.6 关键时序：固化必须**同步**做完，一刻都不能等。
     *   受控编辑器用 MutationObserver 盯 DOM，回调跑在**微任务**里 ——
     *   本函数中任何 setTimeout 都排在它后面，「等一会儿再处理」等于
     *   对着一个已经被回滚的 DOM 干活。所以这里立刻把属性级改动翻译成
     *   节点级替换，让编辑器看到的是「用户换了节点」。
     */
    var solid = safeSolid(c0, before, beforeKids);
    /*
     * ★ 铁证采集：此刻编辑器的 MutationObserver 还没跑（它排在微任务/
     *   下一帧），所以改动**还摆在 DOM 上**。立刻读一次 innerHTML，
     *   这一份 mid 就是「脚本想写什么」的确切证据。
     *   没有它，nochange 永远分不清是「没写到」还是「被剥了」。
     */
    var mid = null;
    try { mid = c0.root.innerHTML; } catch (e) { mid = null; }
    if (mid != null && mid !== before) {
      trace('write', label + ' · 脚本写入：' + summarizeWrite(before, mid));
    }
    setTimeout(function () { finishEdit(c0, before, label, solid, mid, seq, sigBefore); }, 420);
  }

  /*
   * 找两段 HTML 的第一个差异位置。
   * 用途：把「脚本新写进去的那一小段」从整篇 HTML 里抠出来。
   * 前缀相同是常态（改动永远在中间某处），逐字符比对即可，不必上 diff 算法。
   */
  function firstDiffAt(a, b) {
    var n = Math.min(a.length, b.length), i = 0;
    while (i < n && a.charCodeAt(i) === b.charCodeAt(i)) i++;
    return i;
  }

  // 把「新写进去的那一段」摘成一行，供流水直接读
  function summarizeWrite(before, mid) {
    try {
      var i = firstDiffAt(before || '', mid || '');
      var s = String(mid || '').slice(Math.max(0, i - 20), i + 130);
      s = s.replace(/\s+/g, ' ');
      if (!s) s = String(mid || '').slice(0, 130).replace(/\s+/g, ' ');
      if (String(mid || '').length > i + 130) s += '…';
      return s;
    } catch (e) { return ''; }
  }

  // 固化包装：任何异常都不许打断用户操作，只记流水
  function safeSolid(ctx, before, beforeKids) {
    try { return solidPM(ctx, before, beforeKids); }
    catch (e) { trace('err', 'PM 固化异常 · ' + (e && e.message)); return -1; }
  }

  function finishEdit(ctx, before, label, solid, mid, seq, sigBefore) {
    if (!ctx || before == null || !ctx.root || !ctx.root.isConnected) return;
    notifyEdit(ctx);
    var after = ctx.root.innerHTML;
    if (after === before) {
      /*
       * ★ v2.6.9：只有「确实写进去过、又被剥回原样」才叫 nochange（才置红点）。
       *   旧写法把「脚本压根没改 DOM 的动作」也一并报成
       *   「★ 脚本确实写进去过…是被编辑器剥回原样的」—— 这句结论**有方向性**，
       *   它把「没发生过的事」说成了「被剥掉的事」，而诊断流水是下一轮定位的
       *   唯一依据（v2.6.7 与 v2.6.8 两轮都据此误判过方向）。
       *   真机实证（2026-09-20 20:37:32）：打开现场体检（纯只读入口）后留下一条
       *   nochange + 一个红点；而现场体检本来就不改 DOM ⇒ 判据必然成立 ⇒ 必然误报。
       *   两件事从此分开报：
       *     · 脚本没写任何东西   ⇒ noop（中性：不置红点，不误导排查方向）；
       *     · 写了又被剥回原样   ⇒ nochange（保持原样，这确实是失败）。
       *   顺带 mid 用 typeof 兜一道：非字符串时不再算出一句「净增 NaN 字符」
       *   （真机同一份报告里出现过的噪音）。
       */
      var wrote = (typeof mid === 'string' && mid !== before);
      if (!wrote) {
        trace('noop', label + ' · 未改动正文（只读动作，或写与不写没有差别）');
        return;
      }
      trace('nochange', label + ' · DOM 无变化'
        + '　固化=' + (solid >= 0 ? solid + ' 个节点' : '未触发')
        + '　★ 脚本确实写进去过（净增 ' + (mid.length - before.length) + ' 字符），是被编辑器剥回原样的'
        + (pmHostOf(ctx) ? '　※ 该写法不在编辑器方言里（红点看二·C／二·D）' : ''));
      markNoChange();
      return;
    }
    var d = after.length - before.length;
    var extra = (solid > 0) ? '　受控编辑器已固化 ' + solid + ' 个节点' : '';
    trace('ok', label + ' · 字符 ' + (d >= 0 ? '+' : '') + d + extra);
    /*
     * 回滚检测：受控编辑器若仍不认，会用自己的 doc 重新渲染回来。
     * 「已固化仍被回滚」= 该样式不在编辑器允许范围内 —— 这条必须报出来，
     * 否则用户看到的永远只是一句「没反应」。
     */
    /*
     * 回滚检测必须**轮询至收敛**，单次采样会假报。
     * 受控编辑器的回滚不是瞬时的：它先按自己的 doc 重渲染一帧，再按新 doc 落定。
     * 900ms 单采正好会撞上「中间态恰好等于改动前」的那个窗口 ——
     * v1.9 装置实测到过：取消「橙高亮」明明成功（DOM 里 span 已消失、doc 已认账），
     * 却弹了「编辑器回滚了本次改动」，用户会因此以为功能坏了。
     * 现在：连续两次都等于改动前，才判回滚（期间只要变过一次就清零重来）。
     */
    var hits = 0;
    var probe = function () {
      /*
       * ★ 代号闸门：醒来先看一眼「我离开之后有没有人再动过」。
       *   动过就说明现在这个 DOM 状态不归我，直接退出 —— 既不判回滚也不弹窗。
       *   （这条正是装置里「取消成功却弹出『编辑器回滚了』」的根因。）
       */
      if (seq != null && seq !== ACT_SEQ) return;
      if (!ctx.root.isConnected) return;
      /*
       * 判据优先用编辑器自己的 doc 指纹（pmSigOf）：
       *   innerHTML 是序列化结果，受控编辑器每次重渲染都可能换写法，
       *   全等比较会假阴性 —— 装置实测到过「样式真被摘掉了，探针却一声不吭」。
       */
      var same;
      if (sigBefore != null) {
        var nowSig = pmSigOf(ctx);
        same = (nowSig != null && nowSig === sigBefore);
      } else {
        same = (ctx.root.innerHTML === before);
      }
      if (!same) { hits = 0; return; }
      hits++;
      if (hits < 2) { setTimeout(probe, 900); return; }
      trace('revert', label + ' · 编辑器把本次改动回滚了'
        + (solid > 0 ? '（已固化仍被回滚 → 该样式很可能不在编辑器允许范围内）' : ''));
      toast('编辑器回滚了本次改动 —— 点标题栏红点把诊断发我');
    };
    setTimeout(probe, 900);
  }

  // 给当前可见的提示补一句「没检测到改动」，让「点了没反应」当场就有解释
  function markNoChange() {
    var el = document.getElementById('mptb-toast');
    if (!el || !el.classList.contains('on')) return;
    if (el.textContent.indexOf('未检测到改动') >= 0) return;
    el.textContent += '　·　未检测到改动';
  }

  function copyText(txt) {
    var done = function (okFlag) { toast(okFlag ? '诊断已复制到剪贴板' : '复制失败，请手动截图'); };
    try {
      if (navigator.clipboard && navigator.clipboard.writeText) {
        navigator.clipboard.writeText(txt).then(function () { done(true); }, function () { done(false); });
        return;
      }
    } catch (e) {}
    try {
      var ta = document.createElement('textarea');
      ta.value = txt;
      ta.style.cssText = 'position:fixed;left:-9999px;top:0;';
      document.body.appendChild(ta);
      ta.select();
      var ok2 = document.execCommand('copy');
      document.body.removeChild(ta);
      done(ok2);
    } catch (e) { done(false); }
  }

  // 时间戳，用于报告文件名（20260919-164230 这种）
  function stamp() {
    var d = new Date();
    return '' + d.getFullYear() + two(d.getMonth() + 1) + two(d.getDate())
      + '-' + two(d.getHours()) + two(d.getMinutes()) + two(d.getSeconds());
  }

  // 「距今多久」——用来证明诊断本身没刷新选区记忆
  function ageOf(ts) {
    if (!ts) return '无';
    return Math.round((Date.now() - ts) / 1000) + 's 前';
  }

  /*
   * 报告落盘。
   *   复制到剪贴板有两处不可控：长文本可能被截断、聊天工具可能改写换行。
   *   存成 txt 再发文件，内容是原样字节，证据不会在路上失真。
   */
  function downloadText(name, txt) {
    try {
      var blob = new Blob([txt], { type: 'text/plain;charset=utf-8' });
      var url = URL.createObjectURL(blob);
      var a = document.createElement('a');
      a.href = url;
      a.download = name;
      a.style.cssText = 'position:fixed;left:-9999px;top:0;';
      document.body.appendChild(a);
      a.click();
      setTimeout(function () {
        try { document.body.removeChild(a); URL.revokeObjectURL(url); } catch (e) {}
      }, 300);
      toast('报告已下载：' + name);
    } catch (e) { toast('下载失败，请改用「复制诊断」'); }
  }

  /*
   * 落点演练 —— 把「点下去会发生什么」提前算一遍，但**一个字都不改 DOM**。
   *   它把「按钮没反应」拆成两条互相独立的结论：
   *     · 定位/选区那一环断了 → 演练直接说「取不到选区」，并给出光标在哪、快照有没有；
   *     · 选区有了但包裹没法做 → 演练说「命中 0 段文本」，并附上首段样本。
   *   这两种故障的修法完全不同，有这一行字就不用再来回猜。
   */
  function dryRunReport() {
    /*
     * 只读保证：下面要走一遍**真实取参链路**（这样演练结论才等于点击的真实结论），
     * 而 grabRange 会顺手刷新「最近现场光标」的时间戳 —— 那等于诊断本身改变了状态，
     * 会让随后的块级操作重新判优先级。所以先把两份记忆存下来，算完原样放回，
     * 让「演练」真正做到零副作用。
     */
    var bkS = { sc: SNAP.sc, so: SNAP.so, ec: SNAP.ec, eo: SNAP.eo, t: SNAP.t };
    var bkC = { c: CUR.c, o: CUR.o, t: CUR.t };
    var L = [];
    try {
    var g = grabRange(true);
    if (!g.ctx) {
      L.push('行内：✗ 没定位到编辑器 → 所有行内按钮都会失败');
    } else if (!g.range) {
      L.push('行内：✗ 编辑器=' + ctxDesc(g.ctx) + '，但取不到选区（没有选中任何文字）');
      L.push('      现场=' + liveSelDesc(g.ctx)
        + '　光标=' + (curValid() ? (inRootOf(CUR.c, g.ctx.root) ? '在本编辑器' : '在别处') : '无')
        + '　快照=' + (snapPtsValid() ? '有效' : (SNAP.sc ? '有但已失效' : '无')));
    } else {
      var runs = [];
      try { runs = collectRuns(g.range, g.ctx); } catch (err) { runs = []; }
      /*
       * ★ v2.6.2 修正：量具取错字段（现场「✓ 能包 5 段文本 / 共 0 字」）。
       *
       * 【症状】落点演练报「能包 5 段文本 / 共 0 字」，首段样本是 "undefined"。
       *   段落数对了（5），字数却是 0 —— 两个数来自同一次遍历，必然有一个量错了。
       *
       * 【根因】`collectRuns()` 返回的是 `{ node, s, e }`（见 p2.js），
       *   而这里读的是 `runs[i].nodeValue` —— 那个字段**不存在** ⇒ 恒为 undefined
       *   ⇒ `String(undefined || '')` 恒为空串 ⇒ 字数恒为 0；样本 JSON.stringify 出来
       *   正是 "undefined"。**段落数用的是 runs.length，所以它是对的**，
       *   两个数字方向不一致本身就是「量具错」的指纹。
       *
       * 【为什么必须按 s/e 截取】run 只覆盖文本节点的一个**片段**（选区起止所在的节点
       *   往往只被选了一半）。直接取 `node.nodeValue.length` 会把整节点都算进去，
       *   比用户实际选中的字数多 —— 那不是「修好」，是换了个错法。
       *   必须用 `slice(s, e)` 取真实被覆盖的那一段。
       */
      var chars = 0;
      for (var i = 0; i < runs.length; i++) {
        var rn = runs[i] && runs[i].node;
        var rv = (rn && rn.nodeValue) || '';
        var rs = Math.max(0, (runs[i] && runs[i].s) || 0);
        var re2 = (runs[i] && runs[i].e);
        if (re2 == null || re2 > rv.length) re2 = rv.length;
        chars += Math.max(0, re2 - rs);
      }
      L.push('行内：' + (runs.length ? '✓' : '✗') + ' 能包 ' + runs.length + ' 段文本 / 共 ' + chars + ' 字'
        + '　（' + (g.range.collapsed ? '光标' : '选中 ' + g.range.toString().length + ' 字') + ' · ' + ctxDesc(g.ctx) + '）');
      if (!runs.length && !g.range.collapsed) L.push('      ⚠ 明明选中了字却拆不出文本 run → 行内样式必然失败');
      if (runs.length) {
        var head = [];
        for (var h = 0; h < runs.length && h < 3; h++) {
          var hn = runs[h] && runs[h].node;
          var hv2 = (hn && hn.nodeValue) || '';
          var hs = Math.max(0, (runs[h] && runs[h].s) || 0);
          var he = (runs[h] && runs[h].e);
          if (he == null || he > hv2.length) he = hv2.length;
          head.push(JSON.stringify(hv2.slice(hs, he).slice(0, 12)));
        }
        L.push('      首段样本：' + head.join('　'));
      }
    }

    var g2 = grabRange(false);
    if (!g2.ctx) {
      L.push('块级：✗ 没定位到编辑器 → 引用/标题/对齐都会失败');
    } else if (!g2.range) {
      L.push('块级：✗ 编辑器=' + ctxDesc(g2.ctx) + '，但拿不到光标位置（先把光标点进正文某一段再试）');
    } else {
      var bl = [];
      try { bl = selectedBlocks(g2.range, g2.ctx); } catch (err) { bl = []; }
      L.push('块级：' + (bl.length ? '✓' : '✗') + ' 能作用到 ' + bl.length + ' 个段落'
        + (bl.length
          ? '（' + bl.slice(0, 4).map(function (b) { return '<' + String(b.tagName).toLowerCase() + '>'; }).join(' ') + '）'
          : ' → 引用/标题会失败'));
    }
    } finally {
      SNAP.sc = bkS.sc; SNAP.so = bkS.so; SNAP.ec = bkS.ec; SNAP.eo = bkS.eo; SNAP.t = bkS.t;
      CUR.c = bkC.c; CUR.o = bkC.o; CUR.t = bkC.t;
    }
    return L;
  }

  /*
   * 诊断报告：一次把「定位到了谁 / 候选都有哪些、各得几分 / 选区什么状态 /
   * 最近做了什么」全部摊开。点一下红点就能拿走，不用再来回猜。
   */
  function diagReport() {
    var ctx = pickEditor();
    var live = ctx ? liveRange(ctx) : null;
    var L = [];
    L.push('【公众号排版助手 · 现场体检】' + new Date().toLocaleString() + '　ver ' + VER);
    L.push('（把这一整段发我即可，越长越好，不用删）');
    L.push('');

    // ① 结论：脚本此刻认了谁
    L.push('══ 一、结论 ══');
    L.push('★ 脚本认定的编辑器：' + ctxDesc(ctx) + (ctx && ctx.score != null ? '（得分 ' + ctx.score + '）' : ''));
    L.push('   得分构成：' + (ctx && ctx.why ? ctx.why : '—'));
    L.push('   现场选区：' + (live ? (live.collapsed ? '光标（没选中文字）' : '选中 ' + live.toString().length + ' 字') : '无'));
    L.push('   现场光标：' + (curValid() ? (inRootOf(CUR.c, ctx && ctx.root) ? '属于本编辑器' : '属于别处（会干扰）') : '无')
      + '　快照：' + (SNAP.sc ? (snapPtsValid() ? '有效' : '有但已失效') : '无'));
    L.push('   记忆时间戳：快照 ' + ageOf(SNAP.t) + '　光标 ' + ageOf(CUR.t) + '　（打开诊断不该刷新它们）');

    // ② 环境事实：窗口 / iframe / contenteditable / UEditor
    L.push('');
    L.push('══ 二、环境事实 ══');
    L.push('页面：' + decodeURIComponent(String(location.href)).slice(0, 130));
    var env = envReport();
    for (var e = 0; e < env.length; e++) L.push(env[e]);

    // ②b 受控编辑器：回答「哪些样式能被保留」——最该给用户的答案
    var pmh = pmHostOf(ctx);
    if (pmh) {
      L.push('');
      L.push('══ 二·B、受控编辑器（ProseMirror）══');
      L.push('   宿主：div.' + String(pmh.className || '').split(/\s+/)[0]
        + '　顶层子节点 ' + pmh.children.length + ' 个');
      var sl = pmSchemaLines(pmh);
      for (var s2 = 0; s2 < sl.length; s2++) L.push(sl[s2]);
      L.push('   ※ 编辑器只保留上面列出的节点/标记，不在其中的样式会被自动剥离。');
      L.push('   ※ 已启用「节点级固化」：属性改动会先翻译成节点替换再交给编辑器。');

      L.push('');
      L.push('══ 二·C、编辑器方言（我们该照抄它怎么写）══');
      var dlg = dialectLines(pmh);
      for (var d3 = 0; d3 < dlg.length; d3++) L.push(dlg[d3]);

      // ②c 样式配方 —— 直接调编辑器自己的 toDOM，并当场验回读
      L.push('');
      L.push('══ 二·D、样式配方（★ 直接调用编辑器自己的 toDOM 得到）══');
      var rp = recipeLines(ctx);
      for (var r4 = 0; r4 < rp.length; r4++) L.push(rp[r4]);
    }

    // ②d 图片圆角 —— 「圆角到底留不留得住」当场回答（图片节点 schema + 实测计数）
    L.push('');
    L.push('══ 二·E、图片圆角 ══');
    var il = imgLines(ctx);
    for (var i8 = 0; i8 < il.length; i8++) L.push(il[i8]);

    // ③ 候选表：★=采用，-=淘汰，并给出「为什么」
    L.push('');
    L.push('══ 三、可编辑候选（★采用 / - 淘汰）══');
    var sorted = LAST_ALL.slice().sort(function (a, b) { return b.score - a.score; });
    if (!sorted.length) L.push('   （一个可编辑候选都没有 —— 脚本拿不到编辑器）');
    for (var i = 0; i < sorted.length && i < 14; i++) {
      var c = sorted[i];
      L.push((c.score < 0 ? ' - ' : (ctx && c.root === ctx.root ? ' ★ ' : '   '))
        + String(c.score) + '　' + ctxDesc(c));
      L.push('        　' + (c.score < 0 ? '淘汰原因：' : '得分项：') + (c.why || '—'));
    }

    // ④ 落点演练：不改 DOM，只算「点下去会落在哪」
    L.push('');
    L.push('══ 四、落点演练（只计算，不改 DOM）══');
    var dr = dryRunReport();
    for (var q = 0; q < dr.length; q++) L.push(dr[q]);

    // ⑤ 操作流水：最近 40 条，新→旧
    L.push('');
    L.push('══ 五、最近操作流水（越靠下越新）══');
    var tt = traceText();
    if (!tt.length) L.push('   （一条都没有 —— 若你点过按钮，说明点击根本没进脚本）');
    for (var j = 0; j < tt.length; j++) L.push('   ' + tt[j]);

    L.push('');
    L.push('══ 六、怎么读这份报告 ══');
    L.push('   看「二·D、样式配方」：OK 的行 ＝ 脚本已经知道该怎么写才对；');
    L.push('   X 的行 ＝ 编辑器方言里没有能承载它的标记（不是脚本的错，是它不支持）。');
    L.push('   若按钮仍然没效果，把这份报告整段发我即可 —— 不用再做别的动作。');

    L.push('');
    L.push('撤销栈：' + undoStack.length + ' 步　脚本实例标记：'
      + (document.documentElement.__mptbBooted || '未标记（脚本未运行）'));
    return L.join('\n');
  }

  function openDiag() {
    openDialog({
      title: '排版助手 · 现场体检',
      msg: '点「复制诊断」或「下载报告」，把内容发我即可。报告已包含：脚本认了哪个容器、候选得分与淘汰原因、编辑器方言与样式配方、落点演练、最近操作流水。',
      pre: diagReport(),
      fields: [],
      okText: '复制诊断',
      ok: function () { copyText(diagReport()); },
      extra: [
        { text: '下载报告', fn: function () { downloadText('mptb-diag-' + stamp() + '.txt', diagReport()); } },
        { text: '刷新', fn: function () { openDiag(); } }
      ]
    });
  }

  /*
   * 事件委托兜底（capture 阶段）。
   *   SPA 后台常有「在 document 捕获阶段 stopPropagation」的全局处理，
   *   一旦命中，绑在按钮自身上的 click 就再也收不到 —— 表现同样是
   *   「所有按钮都没反应」。把执行入口再挂一份到 document 捕获阶段就绕开了
   *   这类拦截：同节点上的监听器不会被 stopPropagation 干掉。
   */
  /*
   * 未捕获异常 → 操作流水。
   *   以前按钮 handler 里抛异常，用户看到的只有「点了没反应」——
   *   异常被浏览器吞进 console，反馈里自然永远缺这一条最关键的信息。
   *   挂上监听之后，任何一次抛错都会以 err 行出现在诊断报告里。
   */
  function bindErrorTrace() {
    if (window.__mptbErrTrace) return;
    window.__mptbErrTrace = true;
    window.addEventListener('error', function (e) {
      if (!e) return;
      var src = String(e.filename || '').split('/').pop();
      trace('err', '未捕获异常：' + (e.message || '') + (src ? ' @' + src + ':' + e.lineno : ''));
    });
    window.addEventListener('unhandledrejection', function (e) {
      var r = e && e.reason;
      trace('err', '未处理的 Promise 拒绝：' + ((r && r.message) || String(r || '')));
    });
  }

  function bindActDelegate() {
    if (document.__mptbActDelegate) return;
    document.__mptbActDelegate = true;
    document.addEventListener('click', function (e) {
      var t = e.target;
      var el = (t && t.closest) ? t.closest('[data-mptb-act]') : null;
      if (!el || !el.__mptbAct) return;
      if (el.__mptbFired === e.timeStamp) return;      // 元素自身的监听已经处理过
      el.__mptbFired = e.timeStamp;
      try { e.preventDefault(); } catch (err) {}
      el.__mptbAct();
    }, true);
  }

  /* ══════════════════════════════════════════════════════════════════
   * 10. 工具栏 UI
   * ══════════════════════════════════════════════════════════════════ */

  var CSS = `
#mptb-bar, #mptb-bar *, #mptb-dlg, #mptb-dlg *, #mptb-toast, #mptb-tip { box-sizing: border-box; }

#mptb-bar {
  position: fixed; z-index: 2147483000;
  width: 400px; max-width: calc(100vw - 20px); max-height: calc(100vh - 20px);
  display: flex; flex-direction: column;
  font: 13px/1.5 -apple-system, BlinkMacSystemFont, "PingFang SC", "Microsoft YaHei", sans-serif;
  color: #2c2c2c; background: #fff;
  border: 1px solid #e2e2e6; border-radius: 10px;
  box-shadow: 0 10px 30px rgba(0,0,0,.13), 0 1px 3px rgba(0,0,0,.06);
  overflow: hidden; user-select: none; -webkit-user-select: none;
}
#mptb-bar.mptb-min { width: 168px; }
#mptb-bar.mptb-min .mptb-bd { display: none; }
#mptb-bar.mptb-hide { display: none; }

#mptb-bar .mptb-hd {
  display: flex; align-items: center; gap: 6px;
  padding: 8px 9px; background: #fafafb; border-bottom: 1px solid #ececef;
  cursor: move; flex: 0 0 auto;
}
/* 红点同时兼任「选区诊断」入口：外观还是 7px 圆点，但点击热区放大到 16px */
#mptb-bar .mptb-dot {
  width: 16px; height: 16px; flex: 0 0 auto; cursor: pointer;
  position: relative; border-radius: 50%;
}
#mptb-bar .mptb-dot::before {
  content: ""; position: absolute; left: 50%; top: 50%;
  width: 7px; height: 7px; margin: -3.5px 0 0 -3.5px;
  border-radius: 50%; background: #9F312A;
}
#mptb-bar .mptb-dot:hover::before { box-shadow: 0 0 0 3px rgba(159,49,42,.16); }
#mptb-bar .mptb-title { flex: 1 1 auto; font-size: 12px; font-weight: 600; letter-spacing: .2px; color: #2c2c2c; white-space: nowrap; }
#mptb-bar .mptb-ib {
  appearance: none; border: 0; background: transparent; color: #8a8a92;
  width: 22px; height: 22px; border-radius: 5px; cursor: pointer; padding: 0;
  display: inline-flex; align-items: center; justify-content: center; flex: 0 0 auto;
}
#mptb-bar .mptb-ib:hover { background: #eef0f5; color: #2c3e6b; }

#mptb-bar .mptb-bd {
  padding: 10px; overflow-y: auto; overflow-x: hidden;
  display: flex; flex-direction: column; gap: 9px; flex: 1 1 auto;
}
#mptb-bar .mptb-row { display: flex; flex-direction: column; gap: 5px; }
#mptb-bar .mptb-lb { font-size: 11px; color: #93939c; letter-spacing: .4px; }
#mptb-bar .mptb-grp { display: flex; flex-wrap: wrap; gap: 4px; }
#mptb-bar .mptb-sep { height: 1px; background: #f0f0f3; margin: 1px 0; }

#mptb-bar .mptb-chip {
  appearance: none; border: 1px solid #e0e0e5; background: #fff; color: #3a3a42;
  font: inherit; font-size: 12px; line-height: 1;
  padding: 5px 9px; border-radius: 6px; cursor: pointer;
  transition: background-color .12s, border-color .12s, color .12s;
  white-space: nowrap;
}
#mptb-bar .mptb-chip:hover { background: #f4f6fb; border-color: #c8d3ea; color: #2c3e6b; }
#mptb-bar .mptb-chip:active { background: #e9eefb; }
#mptb-bar .mptb-chip.pri { background: #2c3e6b; border-color: #2c3e6b; color: #fff; }
#mptb-bar .mptb-chip.pri:hover { background: #3a4f85; border-color: #3a4f85; color: #fff; }
#mptb-bar .mptb-chip.gh { background: #fafafb; color: #6b6b74; }
#mptb-bar .mptb-chip.gh:hover { background: #f1f2f6; color: #2c3e6b; }

/* 样式预览配色 —— 让按钮本身就长得像它产出的效果 */
/* ★ v2.6.12：橙高亮 → 朱红高亮、黄高亮 → 绿高亮（配色与产出物同源） */
#mptb-bar .mptb-chip.c-hlO { background: #FBEAEA; border-color: #EFD2D2; color: #9F312A; border-radius: 4px; }
#mptb-bar .mptb-chip.c-hlO:hover { background: #F6DEDE; border-color: #E5BEBE; color: #9F312A; }
#mptb-bar .mptb-chip.c-hlY { background: #D1F4E0; border-color: #AEE3C5; color: #0F7A3D; border-radius: 4px; }
#mptb-bar .mptb-chip.c-hlY:hover { background: #C2EED6; border-color: #96D8B2; color: #0F7A3D; }
/* 「字幕条」按钮已下线（样式在两端表现不稳，且与「黄高亮」语义重叠）。
   原位换成「朱红下划线」——按钮自身就带朱红字 + 朱红下划线，与产出物同形。 */
#mptb-bar .mptb-chip.c-rbU { color: #9F312A; text-decoration: underline; border-color: #E5C4C1; }
#mptb-bar .mptb-chip.c-rbU:hover { background: #FCF3F2; border-color: #D9A9A5; color: #9F312A; }
#mptb-bar .mptb-chip.c-code { background: #F5F5F5; color: #9F312A; font-family: Consolas, Menlo, monospace; }
/*
 * ★ v2.6.22：徽标 / 标签的按钮外观**整体下线** —— 面板里已无这两个分组。
 *   现在这两条只服务「黄高亮」：它的按钮就是它产出的色块（浅黄底 + 深黄字 + 4px 圆角），
 *   与 .c-hlO / .c-hlY 三条并列成同一族（都是「按钮 = 色块」）。
 */
#mptb-bar .mptb-chip.c-hlW { background: #FEF3C7; border-color: #F0DC9A; color: #92400E; border-radius: 4px; }
#mptb-bar .mptb-chip.c-hlW:hover { background: #FBEBB4; border-color: #E5CE7E; color: #92400E; }
#mptb-bar .mptb-chip.c-q { border-left: 4px solid #1A1A1A; background: #F4F4F5; }
#mptb-bar .mptb-chip.c-q2 { border-left: 4px solid #4A4A4A; background: #F4F4F5; }
#mptb-bar .mptb-chip.c-q3 { border-left: 4px solid #AC4333; background: #FBF3F2; color: #8F4E43; }

/* 杂志风标题按钮 —— 让按钮本身长得像它产出的标题 */
#mptb-bar .mptb-chip.c-hBar { border-left: 3px solid #9F312A; font-weight: 700; }
#mptb-bar .mptb-chip.c-hUnder { border-bottom: 3px solid #1A1A1A; font-weight: 700; }
/* 按钮外观直接预告成品：宋体字面 + 底部一道砖红短下沿。
   用 inset box-shadow 而不是 border-bottom —— 后者会把按钮撑高 1px，
   在工具栏的 flex 行里会造成整行错位。 */
#mptb-bar .mptb-chip.c-hSerif {
  font-family: 'SimSun', 'Songti SC', 'STSong', serif;
  font-weight: 700; letter-spacing: .5px;
  box-shadow: inset 0 -3px 0 #B0463F;
}
/* 双线一级（★ v2.6.25 新增）：按钮外观直接预告成品 —— 左竖条 + 底部虚线下沿。
   用 border 而不是 box-shadow：它本来就该占位，4px 左条 + 1px 底虚线与产出一致。 */
#mptb-bar .mptb-chip.c-hTwo {
  border-left: 3px solid #1A1A1A;
  border-bottom: 1px dashed #1A1A1A;
  font-weight: 700;
}

/* 嵌套强调引用 —— 与强调引用按钮同族，左条更深、底色更浅，一眼看出是「再嵌一层」 */
#mptb-bar .mptb-chip.c-q4 { border-left: 4px solid #8F2B1E; background: #F7E9E7; color: #7A3F35; padding-left: 7px; }

/* ★ v2.6.22：表格配色对话框里的隐藏色卡（点「自定义」时弹系统取色器）。
   不用 display:none —— 少数浏览器对隐藏元素不弹；改用「1px + 全透明 + 不吃鼠标」。 */
#mptb-dlg .mptb-box-colorpick { position: fixed; left: 0; top: 0; width: 1px; height: 1px;
  padding: 0; border: 0; opacity: 0; pointer-events: none; }

#mptb-bar .mptb-bd::-webkit-scrollbar { width: 8px; }
#mptb-bar .mptb-bd::-webkit-scrollbar-thumb { background: #dcdce2; border-radius: 4px; }
#mptb-bar .mptb-bd::-webkit-scrollbar-thumb:hover { background: #c8c8d0; }

/* 收起按钮：位置由 JS 写 left/top（默认左上角，可拖），不写 right/bottom ——
   两者同时存在时 right/bottom 会赢，按钮永远回不到左上角。 */
#mptb-ball {
  position: fixed; z-index: 2147483000;
  width: 40px; height: 40px; border-radius: 50%;
  background: #2c3e6b; color: #fff; border: 0; cursor: grab;
  touch-action: none;
  box-shadow: 0 6px 18px rgba(44,62,107,.35);
  display: none; align-items: center; justify-content: center;
  font: 600 11px/1 -apple-system, "PingFang SC", "Microsoft YaHei", sans-serif;
}
#mptb-ball.on { display: flex; }
#mptb-ball:hover { background: #3a4f85; }
#mptb-ball.dragging { cursor: grabbing; }

/*
 * 悬浮提示气泡 —— 定标自参考图（程序化取色，非肉眼估色）：
 *   填充 #2C2C2F ／ 文字纯白 ／ 圆角 20px@2x（即 10px@1x）／ 无描边、几乎无阴影。
 * 本处气泡比参考图略矮（6px+6px padding vs 参考图 ~10px），圆角按高度等比收到 8px。
 * 自绘而不用原生 title 的三个理由：
 *   ① 原生提示延迟约 1s、样式完全不可控；
 *   ② 原生提示会盖住光标，划过一排按钮时反复闪；
 *   ③ 原生提示走 OS 层，截图取证拿不到，无法做回归断言。
 */
#mptb-tip {
  position: fixed; z-index: 2147483003; left: 0; top: 0;
  max-width: 280px; padding: 6px 11px; border-radius: 8px;
  background: #2C2C2F; color: #fff;
  font: 12.5px/1.5 -apple-system, BlinkMacSystemFont, "PingFang SC", "Microsoft YaHei", sans-serif;
  letter-spacing: .2px; text-align: left; word-break: break-word;
  box-shadow: 0 6px 18px rgba(0,0,0,.2);
  opacity: 0; pointer-events: none;
  transition: opacity .13s ease;
}
#mptb-tip.on { opacity: 1; }

/* 朱红加粗：按钮自身就渲染成它产出的效果 */
#mptb-bar .mptb-chip.c-rb { color: #9F312A; font-weight: 700; border-color: #E5C4C1; }
#mptb-bar .mptb-chip.c-rb:hover { background: #FCF3F2; border-color: #D9A9A5; color: #9F312A; }

#mptb-toast {
  position: fixed; z-index: 2147483001; left: 50%; bottom: 46px;
  transform: translate(-50%, 10px);
  max-width: 380px; padding: 8px 16px; border-radius: 8px;
  background: rgba(28,28,32,.93); color: #fff;
  font: 13px/1.5 -apple-system, "PingFang SC", "Microsoft YaHei", sans-serif;
  opacity: 0; pointer-events: none;
  transition: opacity .18s ease, transform .18s ease;
  box-shadow: 0 6px 20px rgba(0,0,0,.22);
}
#mptb-toast.on { opacity: 1; transform: translate(-50%, 0); }

#mptb-dlg.mptb-mask {
  position: fixed; inset: 0; z-index: 2147483002;
  background: rgba(20,20,24,.32);
  display: flex; align-items: center; justify-content: center;
}
#mptb-dlg .mptb-box {
  width: 380px; max-width: calc(100vw - 32px);
  background: #fff; border-radius: 10px; overflow: hidden;
  box-shadow: 0 18px 50px rgba(0,0,0,.24);
  font: 13px/1.5 -apple-system, "PingFang SC", "Microsoft YaHei", sans-serif;
  color: #2c2c2c;
}
#mptb-dlg .mptb-box-hd { padding: 13px 16px 9px; font-size: 14px; font-weight: 600; }
#mptb-dlg .mptb-box-msg { padding: 0 16px 12px; font-size: 12.5px; color: #61616b; line-height: 1.7; }
/* 诊断报告：等宽小字 + 可滚动，方便整段圈选复制 */
#mptb-dlg .mptb-diag {
  margin: 0 16px 12px; padding: 10px 12px; max-height: 320px; overflow: auto;
  background: #F7F7F9; border: 1px solid #E6E6EB; border-radius: 8px;
  font: 11.5px/1.65 Consolas, Menlo, Monaco, "Courier New", monospace;
  color: #2C2C33; white-space: pre-wrap; word-break: break-all;
  user-select: text; -webkit-user-select: text;
}
#mptb-dlg .mptb-box-row { padding: 0 16px 10px; display: flex; flex-direction: column; gap: 5px; }
#mptb-dlg .mptb-box-lb { font-size: 11.5px; color: #93939c; }
#mptb-dlg .mptb-box-ip {
  width: 100%; border: 1px solid #e0e0e5; border-radius: 6px;
  padding: 7px 10px; font: inherit; font-size: 12.5px; color: #2c2c2c; background: #fff;
}
#mptb-dlg .mptb-box-ip:focus { outline: none; border-color: #93a8d6; box-shadow: 0 0 0 3px rgba(147,168,214,.18); }
/* v2.6.13：下拉字段与文本框视觉一致。
   刻意**保留系统箭头** —— 自绘箭头要么走 CSS 渐变、要么走 data: 图，
   两者都会给 _build.py 的「调用未定义函数」静态体检造假阳性（体检按「名字+左括号」
   的形态扫全产物，连注释里的 CSS 渐变函数名也会被当成 JS 函数调用）。
   监控项一旦长期有噪声，真问题就看不见了，不值得为一个箭头付这个代价。 */
#mptb-dlg .mptb-box-sel { cursor: pointer; }
/* v2.6.17：色板平铺 —— 一眼看到全部方案、单击即选中（比下拉少一步，也不会打错 hex）。
   每块 = 色点 + 名称；当前生效的那块加 .on 描边。 */
#mptb-dlg .mptb-box-sw { display: flex; flex-wrap: wrap; gap: 6px; flex: 1; padding: 1px 0; }
#mptb-dlg .mptb-box-swc {
  display: inline-flex; align-items: center; gap: 5px; appearance: none;
  border: 1px solid #e0e0e5; background: #fff; color: #3a3a42;
  font: inherit; font-size: 12px; padding: 5px 9px; border-radius: 6px; cursor: pointer;
}
#mptb-dlg .mptb-box-swc:hover { background: #f4f5f9; }
#mptb-dlg .mptb-box-swc.on { border-color: #2c3e6b; box-shadow: 0 0 0 2px rgba(44,62,107,.14); }
#mptb-dlg .mptb-box-swdot {
  display: inline-block; width: 12px; height: 12px; border-radius: 3px;
  border: 1px solid rgba(0,0,0,.12); box-sizing: border-box;
}
#mptb-dlg .mptb-box-ft {
  padding: 12px 16px; display: flex; justify-content: flex-end; gap: 8px;
  background: #fafafb; border-top: 1px solid #ececef;
}
#mptb-dlg .mptb-chip {
  appearance: none; border: 1px solid #e0e0e5; background: #fff; color: #3a3a42;
  font: inherit; font-size: 12.5px; padding: 6px 14px; border-radius: 6px; cursor: pointer;
}
#mptb-dlg .mptb-chip.pri { background: #2c3e6b; border-color: #2c3e6b; color: #fff; }
#mptb-dlg .mptb-chip.pri:hover { background: #3a4f85; }
#mptb-dlg .mptb-chip.gh:hover { background: #f1f2f6; }
`;

  /* ══════════════════════════════════════════════════════════════════
   * 10.0 悬浮提示气泡（自绘，彻底替代原生 title）
   *   - 默认出现在目标按钮「正上方」，因为鼠标一定在按钮上，放上方就不会被光标压住；
   *   - 上方空间不够时自动翻到下方；
   *   - 延时 160ms 出现：快速划过一排按钮时不会每个都闪一下。
   * ══════════════════════════════════════════════════════════════════ */

  var TIP = { el: null, timer: null, host: null };

  function tipNode() {
    if (TIP.el && TIP.el.isConnected) return TIP.el;
    var el = document.createElement('div');
    el.id = 'mptb-tip';
    document.body.appendChild(el);
    TIP.el = el;
    return el;
  }

  function hideTip() {
    clearTimeout(TIP.timer);
    TIP.timer = null;
    TIP.host = null;
    if (TIP.el) TIP.el.classList.remove('on');
  }

  function placeTip(el, host) {
    var r = host.getBoundingClientRect();
    var w = el.offsetWidth, h = el.offsetHeight;
    var left = r.left;
    var top = r.top - h - 7;                        // 默认上方
    if (top < 6) top = r.bottom + 7;                // 顶到上边就翻到下方
    if (left + w > window.innerWidth - 6) left = window.innerWidth - w - 6;
    if (left < 6) left = 6;
    if (top + h > window.innerHeight - 6) top = window.innerHeight - h - 6;
    el.style.left = Math.round(left) + 'px';
    el.style.top = Math.round(Math.max(4, top)) + 'px';
  }

  function showTip(host, text) {
    if (!text) return;
    clearTimeout(TIP.timer);
    TIP.host = host;
    TIP.timer = setTimeout(function () {
      if (TIP.host !== host || !host.isConnected) return;
      var el = tipNode();
      el.textContent = text;
      el.classList.add('on');
      placeTip(el, host);
    }, 160);
  }

  function bindTip(host, text) {
    if (!host || !text) return host;
    host.setAttribute('data-tip', text);            // 留在 DOM 上，便于回归断言与诊断
    host.addEventListener('mouseenter', function () { showTip(host, text); });
    host.addEventListener('mouseleave', hideTip);
    host.addEventListener('mousedown', hideTip);
    return host;
  }

  /*
   * 视口变化时的处置：优先「重定位」，而不是「收掉」。
   * 早先版本这里直接 hideTip，踩到两个坑：
   *   ① 无头截图时 Chromium 必然派发一次 resize，气泡当场被清空，永远截不到图；
   *   ② 真实使用中用户调整窗口后鼠标没动 → 不会再触发 mouseenter → 提示再也回不来。
   * 所以只要宿主还在、气泡正显示着，就按新坐标重新摆一次；否则才收掉。
   */
  function onViewportChange() {
    if (TIP.host && TIP.host.isConnected && TIP.el && TIP.el.classList.contains('on')) {
      placeTip(TIP.el, TIP.host);
    } else {
      hideTip();
    }
  }

  // 滚动 / 缩放会让 fixed 坐标失准 —— 纠正它，而不是把提示收掉
  function bindTipGuards() {
    document.addEventListener('scroll', onViewportChange, true);
    window.addEventListener('resize', onViewportChange);
  }

  var IC = {
    up: '<path d="m18 15-6-6-6 6"/>',
    down: '<path d="m6 9 6 6 6-6"/>',
    // lucide minimize-2：两个向内的对角箭头 =「收起来，只剩一个小按钮」
    min: '<polyline points="4 14 10 14 10 20"/><polyline points="20 10 14 10 14 4"/>'
      + '<line x1="14" y1="10" x2="21" y2="3"/><line x1="3" y1="21" x2="10" y2="14"/>'
  };

  function svgIcon(d, size) {
    return '<svg viewBox="0 0 24 24" width="' + (size || 14) + '" height="' + (size || 14) + '"'
      + ' fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">'
      + d + '</svg>';
  }

  function chip(label, tip, onClick, cls) {
    var b = document.createElement('button');
    b.type = 'button';
    b.className = 'mptb-chip' + (cls ? ' ' + cls : '');
    b.innerHTML = label;
    bindTip(b, tip);
    var act = function () { runAct(String(b.textContent || label).trim().slice(0, 20), onClick); };
    b.__mptbAct = act;
    b.setAttribute('data-mptb-act', '');       // 供 capture 阶段的事件委托兜底
    // 双保险：先固化一次选区快照（万一编辑器在失焦时清空选区，快照还在），
    // 再阻止默认行为，从根上不让编辑器失焦。
    b.addEventListener('mousedown', function (e) { snapSel(); e.preventDefault(); });
    b.addEventListener('click', function (e) {
      e.preventDefault();
      e.stopPropagation();
      if (b.__mptbFired === e.timeStamp) return;
      b.__mptbFired = e.timeStamp;
      act();
    });
    return b;
  }

  function iconBtn(icon, tip, onClick) {
    var b = document.createElement('button');
    b.type = 'button';
    b.className = 'mptb-ib';
    b.innerHTML = svgIcon(icon, 14);
    bindTip(b, tip);
    var act = function () { runAct(String(tip || '图标按钮').slice(0, 20), onClick); };
    b.__mptbAct = act;
    b.setAttribute('data-mptb-act', '');
    b.addEventListener('mousedown', function (e) { e.preventDefault(); });
    b.addEventListener('click', function (e) {
      e.preventDefault(); e.stopPropagation();
      if (b.__mptbFired === e.timeStamp) return;
      b.__mptbFired = e.timeStamp;
      act();
    });
    return b;
  }

  function row(label) {
    var r = document.createElement('div');
    r.className = 'mptb-row';
    if (label) {
      var l = document.createElement('div');
      l.className = 'mptb-lb';
      l.textContent = label;
      r.appendChild(l);
    }
    var g = document.createElement('div');
    g.className = 'mptb-grp';
    r.appendChild(g);
    r._grp = g;
    return r;
  }

  /*
   * ═══ v2.6.16：收起按钮的位置语义 ═══
   *
   * 需求（用户原话）：
   *   「收起按钮位置默认在左上角，点击后从收起位置处展开浮窗，
   *     收起后自动回到展开前的位置，支持拖动按钮位置。」
   *
   * 四条各自落在哪：
   *   ① 默认左上角   —— ballPos 初值 { x:10, y:58 }，与浮窗默认落点同一点；
   *   ② 从收起位置展开 —— expandBar() 把浮窗左上角对齐到按钮当前位置；
   *   ③ 收起回原位   —— collapseBar() 只认 ballPos，不读浮窗的临时坐标；
   *   ④ 可拖动       —— bindBallDrag()，位移 < 4px 算「点」，否则算「拖」。
   *   ⑤ 展开不溢出屏幕 —— placeBar() 统一做二维钳制：左上角先对齐按钮，
   *      再整体向内收（只挪不缩）。★ 这是**唯一出处** —— 开机 / 点开 /
   *      窗口缩放 / 折叠回大条 全部走它；各写一遍就必漏（开机那处原来
   *      只 Math.max(0, …)，按钮被拖到右下角后浮窗开机就顶出屏幕）。
   *
   * ★ 按钮与浮窗共用**同一个**位置状态（ballPos）：
   *   拖按钮改它、拖浮窗也改它 —— 于是「收起后按钮在哪」永远等于
   *   「浮窗最后停在哪」，展开与收起连成一段动作，不会各记各的坐标。
   *   （旧版存的是浮窗独立的 'pos'；那份从本版起退役、不再读取。）
   */
  var BALL_SIZE = 40;

  // 收起按钮的位置。默认左上角 —— 与浮窗默认落点同一点，
  // 视觉上就是「面板从这里长出来，又收回这里」。
  var ballPos = { x: 10, y: 58 };

  function loadBallPos() {
    var p = GMX.get('ballPos', null);
    if (p && typeof p.x === 'number' && typeof p.y === 'number') {
      ballPos = { x: p.x, y: p.y };
    }
  }

  // 把任意坐标钳进视口（按钮是 40x40 的圆，别让它跑出屏幕外找不回来）
  function ballClamp(x, y) {
    return {
      x: Math.max(0, Math.min(Math.max(0, window.innerWidth - BALL_SIZE), x)),
      y: Math.max(0, Math.min(Math.max(0, window.innerHeight - BALL_SIZE), y))
    };
  }

  // 把按钮摆回 ballPos
  function placeBall() {
    var ball = document.getElementById('mptb-ball');
    if (!ball) return;
    var p = ballClamp(ballPos.x, ballPos.y);
    ball.style.left = p.x + 'px';
    ball.style.top = p.y + 'px';
  }

  /*
   * 把浮窗摆到 (x, y)，**并保证不溢出屏幕**。
   *   左上角先对齐目标点，再整体向内收 —— 只挪位置、不缩放，
   *   于是「没贴边时严格从按钮位置长出来」这条视觉关系原样保留。
   *   ★ 视口钳制的**唯一出处**：开机 / expandBar / resize / 折叠回大条
   *     全走它；再各写一遍就必漏（实证：开机那处只 Math.max(0, …)，
   *     按钮被拖到右下角后，浮窗一开机就顶出屏幕右 / 下边）。
   *   尺寸先与视口取小，保证 maxX / maxY 不为负 ⇒ 四边都不越界。
   */
  function placeBar(x, y) {
    var bar = document.getElementById('mptb-bar');
    if (!bar) return;
    bar.style.right = 'auto';
    bar.style.bottom = 'auto';
    // 隐藏态 offsetWidth/Height 为 0 ⇒ 退回样式表里的定值，避免把 0 当尺寸
    var w = Math.min(bar.offsetWidth || 400, window.innerWidth);
    var h = Math.min(bar.offsetHeight || 240, window.innerHeight);
    var maxX = Math.max(0, window.innerWidth - w);
    var maxY = Math.max(0, window.innerHeight - h);
    bar.style.left = Math.max(0, Math.min(maxX, x)) + 'px';
    bar.style.top = Math.max(0, Math.min(maxY, y)) + 'px';
  }

  /*
   * 展开：浮窗从「收起按钮所在的位置」长出来。
   *   左上角跟按钮对齐，而不是跳到某个记忆坐标 —— 用户最后一眼看到的是按钮，
   *   按钮在哪、面板就从哪冒出来，否则视觉上断成两截。
   *   浮窗 400 宽、高度不定，靠边时向左上收进视口，但**不反过来挪按钮**。
   */
  function expandBar() {
    var bar = document.getElementById('mptb-bar');
    var ball = document.getElementById('mptb-ball');
    if (!bar) return;
    bar.classList.remove('mptb-hide');
    // 从按钮当前位置展开 + 视口钳制（不溢出屏幕）—— 量高度必须在解除隐藏之后
    placeBar(ballPos.x, ballPos.y);
    if (ball) ball.classList.remove('on');
    hideTip();
  }

  /*
   * 收起：浮窗隐去，按钮回到 ballPos ——「展开前它所在的位置」。
   *   这里刻意**不读浮窗的实时坐标**：浮窗这一轮被临时拖走过也不影响，
   *   按钮回的是它自己的家。而拖浮窗会同步更新 ballPos（见 bindDrag 的 onUp），
   *   所以「把面板拖到顺手的地方 -> 收起」这个动作天然连成一气。
   */
  function collapseBar() {
    var bar = document.getElementById('mptb-bar');
    var ball = document.getElementById('mptb-ball');
    if (bar) bar.classList.add('mptb-hide');
    hideTip();
    if (ball) { ball.classList.add('on'); placeBall(); }
  }

  /*
   * 收起按钮的拖动。
   *   与浮窗拖动（bindDrag）分开写，关键差别是**要区分「点」和「拖」**：
   *   位移不到 4px 算点（展开面板），超过算拖（只挪位置，不展开）。
   *   不区分的话，拖完松手会立刻把面板弹开 —— 等于白拖。
   *   这是「可点又可拖」这类控件的经典坑，别把 click 单独挂。
   */
  function bindBallDrag(ball) {
    var dragging = false, moved = false, sx = 0, sy = 0, ox = 0, oy = 0;
    var nx = 0, ny = 0;

    ball.addEventListener('mousedown', function (e) {
      if (e.button !== 0) return;
      dragging = true;
      moved = false;
      sx = e.clientX; sy = e.clientY;
      var r = ball.getBoundingClientRect();
      ox = r.left; oy = r.top;
      nx = ox; ny = oy;
      e.preventDefault();                 // 防拖动时把页面文字选中
      document.addEventListener('mousemove', onMove, true);
      document.addEventListener('mouseup', onUp, true);
    });

    function onMove(e) {
      if (!dragging) return;
      if (!moved && Math.abs(e.clientX - sx) + Math.abs(e.clientY - sy) < 4) return;
      moved = true;
      ball.classList.add('dragging');
      var p = ballClamp(ox + e.clientX - sx, oy + e.clientY - sy);
      nx = p.x; ny = p.y;
      // ★ v2.6.16：同 bindDrag —— 同步直写，不依赖 rAF 的调度时机
      ball.style.left = nx + 'px';
      ball.style.top = ny + 'px';
    }

    function onUp() {
      if (!dragging) return;
      dragging = false;
      ball.classList.remove('dragging');
      document.removeEventListener('mousemove', onMove, true);
      document.removeEventListener('mouseup', onUp, true);
      if (!moved) return;                 // 没动 = 交给 click 去展开
      ballPos = { x: Math.round(nx), y: Math.round(ny) };
      GMX.set('ballPos', ballPos);
      /*
       * 标记「这次点击是拖动的尾巴」，让紧随其后的 click 失效。
       * ★ 必须带超时兜底：真机在拖动松手后会自动补发一次 click（标记当场被消费掉），
       *   但**无头装置不会补发** —— 没有兜底的话标记会一直挂着，
       *   把用户「下一次正常点击」也吞掉（装置里表现为后续展开断言全红）。
       */
      ball.__mptbDragTail = true;
      clearTimeout(ball.__mptbTailT);
      ball.__mptbTailT = setTimeout(function () { ball.__mptbDragTail = false; }, 300);
    }
  }

  function bindDrag(bar, handle) {
    var dragging = false, sx = 0, sy = 0, ox = 0, oy = 0, nx = 0, ny = 0;

    handle.addEventListener('mousedown', function (e) {
      if (e.button !== 0) return;
      if (e.target && e.target.closest && e.target.closest('.mptb-ib')) return;
      dragging = true;
      sx = e.clientX; sy = e.clientY;
      var r = bar.getBoundingClientRect();
      ox = r.left; oy = r.top;
      bar.style.right = 'auto';
      bar.style.bottom = 'auto';
      e.preventDefault();
      document.addEventListener('mousemove', onMove, true);
      document.addEventListener('mouseup', onUp, true);
    });

    function onMove(e) {
      if (!dragging) return;
      var w = bar.offsetWidth, h = bar.offsetHeight;
      nx = ox + e.clientX - sx;
      ny = oy + e.clientY - sy;
      nx = Math.max(8 - w + 72, Math.min(window.innerWidth - 72, nx));
      ny = Math.max(4, Math.min(window.innerHeight - 34, ny));
      /*
       * ★ v2.6.16：位置**同步直写**，不再走 requestAnimationFrame 节流。
       *   rAF 的调度取决于页面可见性 —— 后台标签 / 无头环境里会被暂停，
       *   于是同一次拖动里「界面跟着动」与「松手落盘」两段行为分叉
       *   （装置实录：拖动中几何零位移，而 ballPos 已经写成了新坐标）。
       *   代价只有一次 left/top 赋值，浏览器自己会在渲染帧合并。
       */
      bar.style.left = nx + 'px';
      bar.style.top = ny + 'px';
    }

    function onUp() {
      if (!dragging) return;
      dragging = false;
      document.removeEventListener('mousemove', onMove, true);
      document.removeEventListener('mouseup', onUp, true);
      /*
       * 拖浮窗 = 同时挪动「锚点」。浮窗停在哪儿，收起后按钮就在哪儿 ——
       * 这样「收起 -> 再展开」是一段连续动作，而不是按钮自己飞回老位置。
       */
      ballPos = { x: Math.round(nx), y: Math.round(ny) };
      GMX.set('ballPos', ballPos);
    }
  }

  function buildUI() {
    var bar = document.createElement('div');
    bar.id = 'mptb-bar';

    /* ── 头部 ── */
    var hd = document.createElement('div');
    hd.className = 'mptb-hd';
    /*
     * 标题栏红点 = 选区诊断入口。
     * 「点了样式却没反应」这类反馈，最怕的是信息只剩一句"还是不行"。
     * 点一下这里就能看到：编辑器定位到哪了、页面上有几个可编辑区、
     * 现场选区到底是什么状态、快照有没有存下来 —— 一眼定位卡在哪一环。
     */
    var dot = document.createElement('span');
    dot.className = 'mptb-dot';
    bindTip(dot, '点我查看诊断报告（编辑器定位到哪、候选得分、最近操作流水）');
    dot.setAttribute('data-mptb-act', '');
    dot.__mptbAct = function () { openDiag(); };
    dot.addEventListener('mousedown', function (e) { e.preventDefault(); });
    dot.addEventListener('click', function (e) {
      e.preventDefault(); e.stopPropagation();
      if (dot.__mptbFired === e.timeStamp) return;
      dot.__mptbFired = e.timeStamp;
      openDiag();
    });
    var title = document.createElement('span');
    title.className = 'mptb-title';
    // 版本号直接写在标题栏：截一张图就能确认「装的到底是哪一版」，省掉一轮来回
    title.textContent = '公众号排版助手 ' + VER;
    /*
     * 标题栏只留「折叠」一个按钮：
     *   撤销 —— 交给 Ctrl+Z（栈空时自动放行给编辑器原生撤销，见 bindUndoKey）；
     *   隐藏 —— 不占按钮位，挪进脚本菜单（油猴/脚本猫面板 →「隐藏排版工具栏」），
     *          右下角圆钮仍可唤回。
     * 这样标题栏不再有会「一点就找不着工具栏」的按钮，误触成本归零。
     */
    var bMin = iconBtn(IC.up, '折叠 / 展开', function () {
      hideTip();
      bar.classList.toggle('mptb-min');
      var min = bar.classList.contains('mptb-min');
      bMin.innerHTML = svgIcon(min ? IC.down : IC.up, 14);
      // 宽度 168 ↔ 400 一变就可能顶出右边（展回大条时尤其明显）⇒ 重新钳一次
      placeBar(parseFloat(bar.style.left) || 0, parseFloat(bar.style.top) || 0);
    });
    /*
     * 「收起」—— 把浮窗整个隐去，只留左上角的收起按钮（v2.6.16）。
     *   与「折叠」是两件事，别合并：
     *     折叠 —— 还想接着点按钮，只是不想占屏（缩成小条，标题栏还在）；
     *     收起 —— 这一轮干完了，把屏幕让出来（只剩一个 40px 的圆）。
     *   收起后按钮回它自己的位置（ballPos），不跟着浮窗被拖到的地方跑。
     */
    var bHide = iconBtn(IC.min, '收起面板，只留收起按钮', function () {
      hideTip();
      collapseBar();
    });
    hd.appendChild(dot); hd.appendChild(title);
    hd.appendChild(bMin);
    hd.appendChild(bHide);
    bar.appendChild(hd);

    /* ── 主体 ── */
    var bd = document.createElement('div');
    bd.className = 'mptb-bd';

    // 1) 全局
    /*
     * 1) 全局
     *   从「一键套默认值」改成「打开设置面板」：
     *     字号 17、行距 1.8、行前 0、行后 14（v2.6.11 出厂值）。
     *   字号与段间距写**绝对 px**、行距写**无单位倍数** —— 微信用 em 会随两端
     *   基准字号漂移，后台看着对、手机端就变了。设置持久化在脚本存储里。
     */
    var r1 = row('全局');
    r1._grp.appendChild(chip('全局默认', '设置并套用正文：字号（推荐 17）/ 行距（推荐 1.8 倍）/ 段后距（推荐 14px）；只作用于正文段落，标题、引用块、列表、图片、表格一律不动。行前间距推荐 0 = 不干预', applyGlobalDefault, 'pri'));
    /*
     * v2.6.11 新增：面板是「先看值、可改、再套用」（两下），
     *   这一颗是「一键到位」（一下）—— 参数直接取自 BASE，
     *   与面板里那颗「填入推荐值」同一个常量，不会各写一份数字。
     */
    r1._grp.appendChild(chip('一键最佳排版', '一次点击把正文排版参数复位成最佳阅读值并立即套用：16px / 行距 1.8 / 段后 13px。只动这四项排版参数，全篇字体保持你当前的选择不动；表格（含外部粘进来的原生 <table>）一律不动', applyBestPreset));
    /*
     * v2.6.13 新增：表格配色（粘贴增强）。
     *   从 Excel / Markdown / 第三方编辑器粘进来的 <table> 会被重建成圆角表格；
     *   这一颗是它的配色入口。放在「全局」组 —— 它和正文字号一样是**全篇偏好**，
     *   不是对选中内容的操作。
     */
    r1._grp.appendChild(chip('表格配色', '★ 先做一件事：把光标点进要配色的那张表格里（或整块选中它）—— 只给这一张配色，不再动全篇。表格会被重建成「一层圆角容器 + flex 行」的 section 结构（圆角写死 10px，靠「外层圆角 + overflow:hidden」两件套：只写圆角的话，表头那条底色会把四角盖回直角）；容器内没有第二个框，也不会留下空壳。代价：原生列宽拖拽手柄不再有。主色平铺在下面，点一下即选中，表头字 / 隔行浅底 / 分隔线都由它派生；点「自定义」会直接弹系统色卡', applyTableStyle));
    bd.appendChild(r1);

    /*
     * 2) 段落字体（v2.6 恢复 · A 档）
     *
     * ⚠️ 与 v2.4 删除的「字体」**不是同一个东西**，别看错：
     *   v2.4 删的是**行内**字体（选中的几个字换字体）—— 那个确实物理不可能，
     *        因为 font-family 不在 textstyle 的 7 属性内，行内必被剥。
     *   v2.6 做的是**段落**字体（整段换字体）—— 写容器，与「衬线标题宋体」
     *        和「全局排版的字号」同一条通道，微信放行。
     *   对照依据：工具集门户 wechat-md 的思源宋体就写在容器上、能生效。
     *
     *   按钮文案里直接写出粒度（「整段」），避免用户以为是"只改选中的字"。
     */
    /* v2.7：字体清单由 FONTS 单一来源驱动（当前 3 项 → 2 个字体按钮 + 1 个清字体）。
     *       'c-f-*' 是历史遗留类名，样式表里从来没有对应 CSS ⇒ 去掉，只留 'gh'/'go'。 */
    var rFont = row('段落字体　（光标落在段落里即可 · 整段生效）');
    FONTS.forEach(function (f) {
      if (f.k === 'none') {
        rFont._grp.appendChild(chip('清字体', f.tip + '；清掉该段落的 font-family，回微信默认',
          function () { applyParaFont('none'); }, 'gh'));
      } else {
        rFont._grp.appendChild(chip(f.label, f.tip + '；整段生效（微信行内不认 font-family）',
          function () { applyParaFont(f.k); }, 'go'));
      }
    });
    bd.appendChild(rFont);

    bd.appendChild(Object.assign(document.createElement('div'), { className: 'mptb-sep' }));

    // 3) 行内样式
    var r2 = row('行内样式　（选中文字后点击；再点一次取消）');
    /* 斜体 / 删除线 / 下划线 已下线：保留下来的「加粗」是唯一一个
       纯字重件（内联 font-weight，安卓端才认）；朱红加粗 / 朱红下划线
       是它的两个带色变体，都靠内联 style 承载，不依赖语义标签。 */
    r2._grp.appendChild(chip('加粗', STYLES.bd.tip, function () { applyInline('bd'); }));
    r2._grp.appendChild(chip('朱红加粗', STYLES.rb.tip + '；再点一次取消', function () { applyInline('rb'); }, 'c-rb'));
    r2._grp.appendChild(chip('朱红下划线', STYLES.rbU.tip + '；再点一次取消', function () { applyInline('rbU'); }, 'c-rbU'));
    r2._grp.appendChild(chip('朱红高亮', STYLES.hlO.tip, function () { applyInline('hlO'); }, 'c-hlO'));
    r2._grp.appendChild(chip('绿高亮', STYLES.hlY.tip, function () { applyInline('hlY'); }, 'c-hlY'));
    /* ★ v2.6.22：黄高亮（原「警告徽标」移位改名）—— 紧跟「绿高亮」之后。
       效果与朱红 / 绿高亮同规则：只写底色 + 字色，字号继承正文。 */
    r2._grp.appendChild(chip('黄高亮', STYLES.hlW.tip, function () { applyInline('hlW'); }, 'c-hlW'));
    r2._grp.appendChild(chip('行内代码', STYLES.code.tip, function () { applyInline('code'); }, 'c-code'));
    r2._grp.appendChild(chip('键盘键', STYLES.kbd.tip, function () { applyInline('kbd'); }));
    r2._grp.appendChild(chip('链接', STYLES.a.tip, applyLink));
    r2._grp.appendChild(chip('取消链接', '拆掉选中文字上的 <a>，文字保留', removeLink, 'gh'));
    bd.appendChild(r2);

    /* ★ v2.6.22：徽标整行已下线 —— 唯一残党「警告」移到「行内样式」行的
       「绿高亮」之后，改名「黄高亮」（效果按 v2.6.19 朱红高亮规则）。 */
    bd.appendChild(Object.assign(document.createElement('div'), { className: 'mptb-sep' }));

    /*
     * 5) 一级标题（块级）· 四款并列一行
     *   竖条 / 下划 / 衬线 / 双线 —— 每款只有一个档位（24px），
     *   横排一行最省竖向空间，也不必再比档位。
     *   v2.3 已先下线「层级标题（序号系列）」；★ v2.6.25 再把二 / 三级整批下线，
     *   并让四款一级标题自带**自动编号**：点任一颗 = 套样式 + 全篇重排编号。
     */
    var HROWS = [
      ['一级标题', ['hBar', 'hUnder', 'hSerif', 'hTwo']]
    ];
    HROWS.forEach(function (hr) {
      var r = row(hr[0] + '　（块级，光标落在段落里即可；点任意一颗 = 套样式并重排全篇编号；再点一次取消）');
      hr[1].forEach(function (k) {
        var st = STYLES[k];
        r._grp.appendChild(chip(st.label, st.tip + '；再点一次取消',
          function () { applyHead(k); }, 'c-' + k));
      });
      bd.appendChild(r);
    });

    // 6) 引用
    var r5 = row('引用　（块级，光标落在段落里即可）');
    r5._grp.appendChild(chip('引用', STYLES.q1.tip + '；再点一次取消', function () { applyQuote('toggle'); }, 'c-q'));
    r5._grp.appendChild(chip('嵌套引用', STYLES.q2.tip, function () { applyQuote('nest'); }, 'c-q2'));
    r5._grp.appendChild(chip('强调引用', STYLES.q3.tip, function () { applyQuote('accent'); }, 'c-q3'));
    r5._grp.appendChild(chip('嵌套强调引用', STYLES.q4.tip + '；再点一次取消',
      function () { applyQuote('nestAccent'); }, 'c-q4'));
    bd.appendChild(r5);

    // 7) 段落与列表
    var r6 = row('段落与列表');
    r6._grp.appendChild(chip('圆点列表', '悬挂缩进圆点列表；再点一次取消', function () { applyList(false); }));
    r6._grp.appendChild(chip('数字列表', '悬挂缩进数字列表；再点一次取消', function () { applyList(true); }));
    r6._grp.appendChild(chip('段前空一行', '在光标所在段落之前插入一个空段', function () { insertBlankParagraph(true); }));
    r6._grp.appendChild(chip('段后空一行', '在光标所在段落之后插入一个空段', function () { insertBlankParagraph(false); }));
    r6._grp.appendChild(chip('软换行', '把选中的多段合并为一段，段间紧贴（1 个 <br>），适合地址 / 诗句', function () { joinBlocks(1, '软换行'); }));
    r6._grp.appendChild(chip('硬换行', '把选中的多段合并为一段，段间留一行（2 个 <br>），间距略大', function () { joinBlocks(2, '硬换行'); }));
    bd.appendChild(r6);

    /*
     * 7b) 图片（v2.1）
     *   微信图文的图片本来就在内联 style 上带 width 等声明，圆角写进同一条内联 style
     *   是最短的路径 —— 不改文件、不损画质。上传完成后自动补，开关默认开。
     *   一个开关 + 一个手动补跑：关掉时自动与手动都停手，避免「以为开着其实没开」。
     */
    var r8 = row('图片　（上传后自动加圆角）');
    IMG_CHIP = chip(imgChipLabel(),
      '点击切换「图片自动圆角」（默认开）：开 = 上传后自动按《结构规则》补内联 border-radius'
      + '（单图 ' + IMG_R_SINGLE + 'px / 并排拼贴 ' + IMG_R_GAL + 'px；'
      + '图片落在卡片或引用块里时取「外弧 − 内边距」的同心值，容器直角则图片直角）',
      toggleImgRound, 'pri');
    r8._grp.appendChild(IMG_CHIP);
    r8._grp.appendChild(chip('立即处理',
      '对正文里已有的图片补一轮圆角（只加 border-radius，不动宽度、不动左右对齐）',
      applyImgRound, 'gh'));
    bd.appendChild(r8);

    bd.appendChild(Object.assign(document.createElement('div'), { className: 'mptb-sep' }));

    // 8) 维护
    var r7 = row('维护');
    r7._grp.appendChild(chip('清除格式', '剥掉选中范围（未选中则全文）的行内样式包裹与引用/列表样式', clearFormat, 'gh'));
    r7._grp.appendChild(chip('清除空行',
      '一键删除全文正文里的空行（按回车留下的空段落）。表格与引用块内部一律不动；'
      + '含图片 / 分隔线 / 链接的空块也不算空行。清错了可以用「撤销」还原', clearEmptyLines, 'gh'));
    bd.appendChild(r7);

    bar.appendChild(bd);

    /*
     * 收起按钮（旧称「圆钮」）：收起态下唯一的入口（v2.6.16）。
     *   可拖：拖到顺手的位置，位置会被记住，下次就从那儿展开；
     *   可点：点一下从它当前位置展开浮窗。
     *   ★ click 里必须先看 __mptbDragTail —— 拖完松手浏览器仍会补一个 click，
     *     不拦的话「拖一下」会变成「拖完立刻弹开面板」；
     *     标记由 setTimeout 兜底复位，防「装置不补 click ⇒ 标记常挂 ⇒ 吞掉下次点击」。
     */
    var ball = document.createElement('button');
    ball.id = 'mptb-ball';
    ball.type = 'button';
    ball.textContent = '排版';
    bindTip(ball, '点一下展开排版面板；按住可以拖到顺手的位置（位置会被记住）');
    ball.addEventListener('click', function (e) {
      e.preventDefault();
      e.stopPropagation();
      if (ball.__mptbDragTail) {
        ball.__mptbDragTail = false;          // 消费掉这次「拖动的尾巴」
        clearTimeout(ball.__mptbTailT);
        return;
      }
      expandBar();
    });
    document.body.appendChild(ball);

    document.body.appendChild(bar);

    /*
     * ★ v2.6.12：工具栏**默认收起**（定稿 C1A）—— 只留「排版」按钮
     *   （v2.6.16 起默认落左上角，并可拖动记住位置）。
     *   与「微众号HTML源码内联.user.js」的默认收起态一致：脚本一进来不占屏，
     *   需要时点圆钮唤出（圆钮可拖可点，见上面 ball 的 click 绑定）。
     *   收起 = 工具栏加 mptb-hide（display:none）+ 圆钮加 on（display:flex），
     *   与 hideBar() 的收尾状态完全同形 —— 只是把开机态改成它。
     *   两点与 hideBar() 保持同步，别只改一处：
     *     · 圆钮的 on 类必须同时加上，否则工具栏藏了、圆钮也不见 ⇒ 唤不回来；
     *     · 这里**不调 hideTip()** —— 开机时本就没有悬浮提示需要收。
     */
    bar.classList.add('mptb-hide');
    ball.classList.add('on');

    /*
     * 位置：按钮（收起态）与浮窗共用 ballPos，默认左上角。
     *   收起态与展开态同一个坐标 ——「从这里展开 / 收回这里」是同一处，
     *   不会出现按钮在左上角、面板却在别处冒出来的割裂感。
     *   默认贴左侧：微信后台正文编辑区居中，左侧留白最干净，
     *   也不会压住右侧的字号/预览/发布等原生控件。
     *   （v2.6.16 起浮窗独立记忆的 'pos' 退役，只留这一份 ballPos。）
     */
    loadBallPos();
    placeBall();
    // 开机也走同一套钳制（此刻是隐藏态、量不到真实高度 ⇒ 展开时会用真实值重算）
    placeBar(ballPos.x, ballPos.y);

    bindDrag(bar, hd);
    bindBallDrag(ball);

    // 窗口尺寸变了（分屏 / 缩窗口）别把按钮留在屏幕外
    window.addEventListener('resize', function () {
      placeBall();
      if (!bar.classList.contains('mptb-hide')) {
        placeBar(parseFloat(bar.style.left) || 0, parseFloat(bar.style.top) || 0);
      }
    });
    return bar;
  }

  /* ══════════════════════════════════════════════════════════════════
   * 11. 启动
   * ══════════════════════════════════════════════════════════════════ */

  var watchTimer = null;

  /*
   * Ctrl+Z = 撤销脚本的排版操作。
   *
   * 与编辑器原生撤销的关系（这是这个键位的核心设计，别改）：
   *   脚本栈里有货 → 抢下这次按键，阻止默认行为，撤掉自己那一步；
   *   脚本栈里没货 → 原样放行，交给编辑器自己的 Ctrl+Z。
   * 于是「Ctrl+Z」永远能撤上一步，用户不需要记住两套撤销，
   * 也不会出现「按下去没反应」。
   *
   * 为什么要传入 doc：编辑器跑在 iframe 里时 keydown 不会冒泡到主文档，
   * 只挂主文档等于在 iframe 场景下完全失效。
   */
  function bindUndoKey(doc) {
    var d = doc || document;
    if (d.__mptbUndoKey) return;
    d.__mptbUndoKey = true;
    d.addEventListener('keydown', function (e) {
      if (!(e.ctrlKey || e.metaKey) || e.shiftKey || e.altKey) return;
      if (e.key !== 'z' && e.key !== 'Z') return;
      var t = e.target;
      if (t && (t.tagName === 'INPUT' || t.tagName === 'TEXTAREA')) return;   // 输入框里保留原生文本撤销
      if (t && t.closest && t.closest('#mptb-dlg')) return;
      if (!undoStack.length) return;                                          // 栈空 → 让编辑器自己撤
      e.preventDefault();
      e.stopPropagation();
      doUndo();
    }, true);
  }

  /*
   * 脚本菜单入口。v2.6.16 起与标题栏那颗「收起」按钮**同一动作** ——
   * 两处各写一遍状态切换，迟早会漂移（历史上「藏了唤不回」就出在这）。
   */
  function hideBar() {
    collapseBar();
  }

  /*
   * 工具栏的「全局守卫」：只要 mousedown 落在工具栏 / 对话框上，
   * 就抢在编辑器失焦之前把当前选区固化成快照。
   * 比逐个按钮去挂更保险 —— 下拉框、滚动条、按钮内部的子元素都可能把事件吞掉。
   */
  function bindGlobalGuards() {
    document.addEventListener('mousedown', function (e) {
      var t = e.target;
      if (!t || !t.closest) return;
      if (t.closest('#mptb-bar') || t.closest('#mptb-dlg')) snapSel();
    }, true);
  }

  /*
   * 给**所有**同域文档都挂上「选区固化 / 撤销键 / 粘贴接管」。
   *   只挂最佳上下文那一份是不够的：编辑器换 iframe、或者页面里还有别的
   *   可编辑区时，选区固化漏挂一份，快照就永远是空的 —— 这恰恰是上一版
   *   在真实后台里失效的隐藏原因之一。广撒网，成本可忽略。
   */
  function bindAllDocs() {
    var docs = collectDocs();
    bindSelWatch(document);
    bindUndoKey(document);
    for (var i = 0; i < docs.length; i++) {
      var d = docs[i];
      bindSelWatch(d.doc);
      bindUndoKey(d.doc);
      if (d.frame) { try { bindPaste({ doc: d.doc, win: d.win, root: d.doc.body, frame: d.frame }); } catch (e) {} }
      bindImgWatch(d.doc);      // 图片上传完成 → 自动补圆角（v2.1）
    }
  }

  function boot() {
    /*
     * 防重复注入：脚本管理器（脚本猫 / 油猴）在 SPA 场景下可能对同一个
     * 页面重复执行脚本。重复注入 = 两个面板 + 两套 document 监听，
     * 点击会被另一份先吃掉 —— 表现同样是「点了没反应」。
     * 用 documentElement 上的标记当哨兵，比 @noframes 靠得住（各管理器对
     * 该元数据的支持并不一致，不能把正确性押在它身上）。
     */
    if (document.documentElement.__mptbBooted) return;
    document.documentElement.__mptbBooted = VER;
    if (document.getElementById('mptb-bar')) return;
    GMX.style(CSS);
    buildUI();
    bindUndoKey(document);
    bindTipGuards();
    bindGlobalGuards();
    bindErrorTrace();
    bindActDelegate();
    bindAllDocs();

    // 编辑器可能延迟创建 / iframe 重建 → 定时补挂监听
    var tick = 0;
    watchTimer = setInterval(function () {
      tick++;
      bindAllDocs();
      if (tick > 200) { clearInterval(watchTimer); watchTimer = null; }
    }, 3000);
    var ctx0 = pickEditor();
    if (ctx0) { bindPaste(ctx0); bindImgWatch(ctx0.doc); }
    trace('boot', '就绪 · ' + ctxDesc(ctx0) + ' · 候选 ' + LAST_SCAN.length + ' 个');

    GMX.menu('撤销上一步排版（等同 Ctrl+Z）', function () { doUndo(); });
    GMX.menu('收起排版面板（只留角落的收起按钮）', hideBar);
    GMX.menu('全局正文排版设置…', function () { runAct('全局面板', applyGlobalDefault); });
    GMX.menu('清除全文排版格式', function () { runAct('清全文格式', clearFormat); });
    GMX.menu('查看诊断报告', function () { openDiag(); });
    /*
     * 行内小件载体开关（v2.2）
     *   <a> 外框版：小件由 <a href> 承载 ⇒ 能显示圆角矩形外框 + 内边距（默认）；
     *   <span> 扁平版：退回 span[textstyle] ⇒ 只剩底色 / 字色 / 字重 / 字距。
     * 放菜单里是为了「面板折叠着也能改」，两处共用 carryLinkOn() 一份状态。
     */
    GMX.menu('切换「行内小件载体」（当前 ' + (carryLinkOn() ? '<a> 外框版' : '<span> 扁平版') + '）', function () {
      var on = carryLinkOn();
      GMX.set('carryLink', !on);
      toast('行内小件载体已切成「' + (!on ? '<a> 外框版（能显示外框 / 内边距）' : '<span> 扁平版（只有底色字色）')
        + '」；重新选中文字再点按钮即可生效');
    });
    /*
     * 图片自动圆角开关（与面板上那颗按钮同一份状态）。
     *   「上传图片后自动按《结构规则》补圆角」是这个开关的默认行为（开）。
     *   放菜单里是为了「面板折叠着也能改」，两处共用 GMX 里的同一条配置。
     */
    GMX.menu('切换「图片自动圆角」（当前 ' + (imgRoundOn() ? '开' : '关') + '）', toggleImgRound);
    /*
     * 降级模式开关。
     * 「降级」= 新版编辑器承载不了全部声明时，按它能承载的部分写
     * （例如徽标退化成「底色 + 字色 + 加粗」的扁平标签），而不是干脆不写。
     * 关掉则：承载不了就不写、只告知 —— 视觉严格，但按钮会「点了没反应」。
     */
    GMX.menu('切换「降级模式」（当前 ' + (GMX.get('degrade', DEGRADE_DEFAULT) !== false ? '开' : '关') + '）', function () {
      var on = GMX.get('degrade', DEGRADE_DEFAULT) !== false;
      GMX.set('degrade', !on);
      toast('降级模式已' + (on ? '关闭' : '开启') + '（立即生效）');
    });
    /*
     * 宽载体（合成 paste）开关 —— v2.5.1 默认关闭。
     *   关着的时候，行内小件的样式由「直连载体 / 配方节点替换」写在**我们自己的选区**上，
     *   落点可控；打开后脚本会尝试把 HTML 通过宿主的粘贴通道送进去，
     *   但落点由宿主自己决定（历史现场：内容被插到文首），仅在必要时才开。
     */
    GMX.menu('切换「宽载体（合成粘贴）」（当前 ' + (wideCarrierOn() ? '开' : '关') + '）', function () {
      var on = wideCarrierOn();
      GMX.set('wideCarrier', !on);
      toast('宽载体已' + (on ? '关闭（推荐：落点由脚本选区决定）' : '开启（落点由编辑器决定，可能插到文首）') + '；重新选中文字再点按钮即可生效');
    });
  }

  if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', function () { setTimeout(boot, 600); });
  } else {
    setTimeout(boot, 600);
  }
  /* ══════════════════════════════════════════════════════════════════
   * 12. 图片圆角（v2.1 新增）—— 上传完成即自动按《结构规则》补圆角
   *
   * 规则依据（用户给定的《图片圆角 · 结构规则 / 实现层》）：
   *   ① 同心圆角：图片落在卡片 / 引用块里时 r_img = r_card − padding（≥0）。
   *      内外弧不同心，一眼就看得出错位 —— 容器本身是直角时，图片也必须直角。
   *   ② 并排拼贴：r_gallery ≈ 0.6~0.8 × r_img，且**同一排必须相同**。
   *   ③ 同篇一致性：整篇最多两级（单图一档 + 拼贴一档），逐图乱变最伤观感。
   *   ④ 圆角不等于缩进：只改圆角，绝不碰 width / margin / 左右对齐。
   *   ⑤ 描边配比：1px 描边 ⇒ 半径 ≤8px；≥2px 描边 ⇒ ≤6px —— 描边越粗，
   *      弧线越容易在直角处"漏出方形断面"，半径要跟着收。
   *   ⑥ 实现层：内联 CSS（<img style="border-radius:Npx">），不改文件、不损画质；
   *      单位必须 px（% 按元素宽度算，长图会算出巨大弧；em 会随字体漂）；
   *      半径取整数，不用 border-radius:50%（除非要正圆头像）。
   *
   * 为什么要在「写完之后」再固化一次（v1.6 的老结论，这里同样适用）：
   *   微信正文编辑器是 ProseMirror —— 外部直接改属性会被它整块重渲染回滚，
   *   只有「换节点」会被它 parse 接纳。所以写入后**同步**走 solidPM。
   *
   * 为什么监听回调里不能等一拍：
   *   MutationObserver 的回调跑在**微任务**队列，PM 的观察者也在那儿；
   *   任何 setTimeout 都是宏任务，醒来时 DOM 早被回滚了。所以处理一律在
   *   回调内**同步**完成（这与 runAct 里「固化必须同步」是同一条时序规律）。
   *
   * 为什么「向上找卡片」必须有边界（★ v2.1 装置实测，四条断言因此全红）：
   *   图片常常直接坐在一个无样式的 <section> 里（＝普通段落）。若无边界地向上找，
   *   迟早会撞到编辑器自己的外框（有 border + border-radius + padding），于是
   *   每张图都被算成「坐在直角卡片里 ⇒ 圆角 0」，整篇圆角全部失效。
   *   实测：外框 border-radius:6px − padding:20px ⇒ 0px。见 imgContentRoot()。
   * ══════════════════════════════════════════════════════════════════ */

  var IMG_ON_DEFAULT = true;   // 图片自动圆角：默认开
  var IMG_R_SINGLE = 8;        // 单图档（px 整数）
  var IMG_R_GAL = 6;           // 拼贴档 ≈0.75 × 单图档，落在规则的 0.6~0.8 区间内
  var IMG_R_BORDER1 = 8;       // 描边档：1px 描边 ⇒ 半径上限 8
  var IMG_R_BORDER2 = 6;       // 描边档：≥2px 描边 ⇒ 半径上限 6（描边越粗，弧线越要收）
  var IMG_STRIP_WARNED = false;              // 「被编辑器剥掉」只提示一次，不刷屏
  var IMG_STAT = { applied: 0, stripped: 0, throttled: 0 };  // 供诊断报告回显
  var IMG_CHIP = null;                        // 面板上的开关按钮（buildUI 里赋值）
  var IMG_DOCS = [];                          // 已挂监听的文档，防重复挂
  /*
   * 自激护栏（v2.1 建立 · v2.4 改口径）。
   *   观察者回调里「改属性 + 换节点」这个动作本身会产生新的 mutation 记录 ⇒ 观察者
   *   会被自己触发；若宿主又把样式剥掉，下一轮就"看起来仍需要写"，形成
   *   写入 → 换节点 → 被剥 → 再写入 的闭环，页面直接卡死（无头 dump 实测 7 分钟不返回）。
   *   三重防线：① 处理完 takeRecords() 丢弃自己的记录；② 突发配额（见 imgBurstTake）；
   *             ③ 确认被剥后本次会话静音（不再自动重试，但明确告知用户可手动试）。
   *
   * ★ v2.4 改口径（现场报告二·E 实证「防自激丢弃 5 轮」）：
   *   老口径把**每一轮**都算进配额，于是「我们自己换节点 → 编辑器重渲染 → 再触发一轮」
   *   这种**什么都没改**的幂等轮也在吃配额。真实上传时 mutation 批次本就密集，
   *   配额被幂等轮吃光 ⇒ 真正带图的那一轮被丢掉 ⇒ 「上传后没自动生效」。
   *   新口径：① **幂等轮零成本** —— 先干跑一遍，没有一张需要改就根本不进闸门；
   *          ② 被限流时不再「直接放弃」，而是**延后一轮重试**（只留一个待办）。
   *   真自激（被抹 → 再写 → 再被抹）每一轮都是「要写」，照样会被截断，护栏不失效。
   */
  var IMG_BURST = { t: 0, n: 0 };
  var IMG_BURST_MAX = 6;      // 1.5s 窗口内最多「真的要写」几轮
  var IMG_RETRY_T = null;     // 限流后的延后重试（只留一个待办，不堆风暴）
  var IMG_AUTO_MUTE = false;

  function imgBurstTake() {
    var now = Date.now();
    if (now - IMG_BURST.t > 1500) { IMG_BURST.t = now; IMG_BURST.n = 0; }
    IMG_BURST.n++;
    /*
     * 6 轮：正常链条是「插入 → 处理 → 宿主重渲染 → 幂等确认」，
     * 3 轮会把正常链路自己掐掉（装置实测红过）；而真自激是**无限**轮，
     * 6 轮足以在 1.5s 内把它截断。
     */
    return IMG_BURST.n <= IMG_BURST_MAX;
  }

  function imgRoundOn() { return GMX.get('imgRound', IMG_ON_DEFAULT) !== false; }

  function imgChipLabel() { return '图片圆角 · ' + (imgRoundOn() ? '开' : '关'); }

  function syncImgChip() {
    if (!IMG_CHIP) return;
    IMG_CHIP.textContent = imgChipLabel();
    // 开着用主色（pri），关掉退回灰底 —— 状态一眼可见，不必读文字
    try {
      if (imgRoundOn()) IMG_CHIP.classList.add('pri');
      else IMG_CHIP.classList.remove('pri');
    } catch (e) {}
  }

  function setImgRound(on) {
    GMX.set('imgRound', !!on);
    syncImgChip();
    toast('图片自动圆角已' + (on ? '开启' : '关闭'));
    // 开启时立刻补跑一轮：关闭期间上传的图片也一并补上
    if (on) { try { imgApplyNow('开启补跑'); } catch (e) { trace('err', '图片补跑 · ' + (e && e.message)); } }
  }

  function toggleImgRound() { setImgRound(!imgRoundOn()); }

  // computed style 取值（内联与外链 CSS 都覆盖；拿不到就返回 null）
  function imgStyleOf(el) {
    try {
      var w = (el.ownerDocument && el.ownerDocument.defaultView) || window;
      return w.getComputedStyle(el);
    } catch (e) { return null; }
  }

  function imgRadiusOf(el) {
    var cs = imgStyleOf(el);
    if (!cs) return 0;
    var v = parseFloat(cs.borderTopLeftRadius || '');
    return isNaN(v) ? 0 : v;
  }

  // 内边距取上下左右的**最大**值 —— 同心半径要按最紧的那条边算才不出错
  function imgPadOf(el) {
    var cs = imgStyleOf(el);
    if (!cs) return 0;
    var a = [cs.paddingTop, cs.paddingRight, cs.paddingBottom, cs.paddingLeft], m = 0;
    for (var i = 0; i < a.length; i++) {
      var v = parseFloat(a[i] || '');
      if (!isNaN(v) && v > m) m = v;
    }
    return m;
  }

  // 底色是不是「全透明」（Chromium 的 computed 值写成 rgba(0, 0, 0, 0)）
  function imgBgClear(bg) {
    return !bg || bg === 'transparent' || /^rgba\([^)]*,\s*0(?:\.0+)?\s*\)$/.test(bg);
  }

  /*
   * 「外部底色」：从某个元素（含自身）向上取第一个实色底。
   *   判断卡片不能只看「有没有底色」—— 微信的 section 常带 background-color:#fff，
   *   白底套白底根本不是卡片；真正区分卡片的是「底色与四周不同」。
   */
  function imgEffBg(el) {
    var n = el, guard = 0;
    while (n && n.nodeType === 1 && guard++ < 24) {
      var cs = imgStyleOf(n);
      if (!cs) break;
      var bg = String(cs.backgroundColor || '');
      if (!imgBgClear(bg)) return bg;
      n = n.parentNode;
    }
    return 'rgba(0, 0, 0, 0)';
  }

  /*
   * 「卡片 / 引用块」判定（规则①的取样口径）。只认两种信号：
   *   · 左侧竖条（border-left）—— 微信引用块最典型的标记；
   *   · 实色底，**且与四周底色不同** —— 白底 section 不算卡片。
   * 正文普通段落两者皆无，不会被误判成容器 ——
   * 否则「同心圆角」会把整篇图片都按容器的 padding 压成直角。
   */
  function imgIsContainer(el) {
    var cs = imgStyleOf(el);
    if (!cs) return false;
    if ((parseFloat(cs.borderLeftWidth) || 0) > 0 && cs.borderLeftStyle !== 'none') return true;
    var bg = String(cs.backgroundColor || '');
    if (!imgBgClear(bg) && bg !== imgEffBg(el.parentNode)) return true;
    return false;
  }

  /*
   * 正文边界（★ v2.1 装置实测的关键修复）。
   *   向上找「卡片」时必须有个头：最多走到编辑器正文根，绝不越过它 ——
   *   编辑器自己的外框（border + border-radius + padding）不是卡片。
   *   有 ctx.root 就直接用；没有（诊断等旁路）则按 .ProseMirror / 最外层可编辑祖先兜底。
   */
  function imgContentRoot(img, root) {
    if (root && root.nodeType === 1) return root;
    var n = img.parentNode, hit = null;
    while (n && n.nodeType === 1) {
      if (n.classList && n.classList.contains('ProseMirror')) return n;
      if (n.isContentEditable) hit = n;   // 记最外层可编辑祖先（＝正文根）
      n = n.parentNode;
    }
    return hit;
  }

  /*
   * 描边档上限（规则⑤）：1px 描边 ⇒ 半径 ≤8px；≥2px 描边 ⇒ ≤6px。
   *   描边越粗，弧线越容易在直角处"漏出方形断面"，所以半径要跟着收。
   *   只看**最粗的那条边**；没有描边 ⇒ 返回 0 表示「不设上限」。
   */
  function imgBorderCap(el) {
    var cs = imgStyleOf(el);
    if (!cs) return 0;
    var a = [cs.borderTopWidth, cs.borderRightWidth, cs.borderBottomWidth, cs.borderLeftWidth], m = 0;
    for (var i = 0; i < a.length; i++) {
      var v = parseFloat(a[i] || '');
      if (!isNaN(v) && v > m) m = v;
    }
    if (m <= 0) return 0;
    return m >= 2 ? IMG_R_BORDER2 : IMG_R_BORDER1;
  }

  /*
   * 并排拼贴：同一个直接父容器里有 ≥2 张图。
   * 微信图文里「并排」几乎总是同段/同块内的多个 img，
   * 用父容器计数比按渲染坐标判断稳（不受响应式换行影响）。
   */
  function imgIsGallery(img) {
    var p = img.parentNode;
    if (!p || !p.children) return false;
    var n = 0;
    for (var i = 0; i < p.children.length; i++) {
      // ★ 只数「真图」：ProseMirror 会在每张图旁边插零尺寸占位
      //   <img class="ProseMirror-separator" alt="">，把它数进来会把单图误判成拼贴
      if (isRealImg(p.children[i])) n++;
    }
    return n >= 2;
  }

  /*
   * 目标半径（px 整数）。root = 编辑器正文根（用来给向上查找封顶）。
   *   ① 坐在卡片 / 引用块里 → 同心值 = r_card − padding（≥0），容器直角则取 0；
   *   ② 否则按档位：并排拼贴 IMG_R_GAL / 单图 IMG_R_SINGLE；
   *   ③ 最后过一遍描边上限（自己有描边时）。
   *   用 −1 作「还没定」的哨兵：0 是**合法结果**（直角容器），不能被当成"没找到"。
   */
  function imgTargetRadius(img, root) {
    var stop = imgContentRoot(img, root), el = img.parentNode, guard = 0, r = -1;
    while (el && el.nodeType === 1 && guard++ < 40) {
      if (el === stop) break;    // ★ 不越过正文根：编辑器外框不是卡片
      if (el === img.ownerDocument.body || el.tagName === 'BODY') break;
      if (imgIsContainer(el)) {
        var rc = imgRadiusOf(el);
        r = rc > 0 ? Math.max(0, Math.round(rc - imgPadOf(el))) : 0;
        break;
      }
      el = el.parentNode;
    }
    if (r < 0) r = imgIsGallery(img) ? IMG_R_GAL : IMG_R_SINGLE;
    var cap = imgBorderCap(img);                  // 规则⑤：描边越粗，半径越小
    if (r > 0 && cap > 0) r = Math.min(r, cap);
    return r;
  }

  /*
   * 只认「真正的正文图片」。
   *   受控编辑器（ProseMirror）会在图片旁边插零尺寸占位
   *   `<img class="ProseMirror-separator" alt="">` —— 它既不该加圆角，
   *   被当成目标反复处理还会把自动链路的配额耗光（装置实测：12 个 img 里 6 个是占位）。
   *   判据：必须有 src、且不是分隔占位、不是脚本自己的 UI。
   */
  function isRealImg(el) {
    if (!el || el.tagName !== 'IMG' || isOurNode(el)) return false;
    if (!el.getAttribute) return false;
    if (!el.getAttribute('src')) return false;
    var cls = String(el.getAttribute('class') || '');
    if (cls.indexOf('ProseMirror-separator') >= 0) return false;
    return true;
  }

  function imgNodesIn(root) {
    var out = [];
    if (!root) return out;
    if (isRealImg(root)) out.push(root);
    walkEls(root, function (el) {
      if (isRealImg(el)) out.push(el);
    });
    return out;
  }

  function imgHasRound(img) {
    try {
      var v = img.style && img.style.borderRadius;
      if (v) { var n = parseFloat(v); return !isNaN(n) && n > 0; }
      var cs = imgStyleOf(img);
      var m = parseFloat((cs && cs.borderTopLeftRadius) || '');
      return !isNaN(m) && m > 0;
    } catch (e) { return false; }
  }

  // 单张处理：返回 1 = 真的改过，0 = 已是目标值（幂等，靠它终止监听回调的连锁触发）
  function roundImgEl(img, root) {
    var r = imgTargetRadius(img, root);
    var css = 'border-radius:' + r + 'px;';
    if (elHasCss(img, css)) return 0;
    if (r === 0) {
      // 目标就是直角（在直角容器内）—— 把之前加的圆角拆掉，保证内外弧同心
      if (!img.style || !img.style.borderRadius) return 0;
      stripStyle(img, css);
      return 1;
    }
    mergeStyle(img, css);
    return 1;
  }

  function imgCtx() {
    if (ECTX && aliveCtx(ECTX)) return ECTX;
    return pickEditor();
  }

  /*
   * 取「真正装着图片的那个上下文」（★ v2.1 装置实测的关键修复之二）。
   *   为什么不能只信 imgCtx()：ECTX 是 boot 那一刻定下来的，此后不会自己更新。
   *   而 boot 时正文往往还很短、光标又落在标题 / 作者框里（+30 分），
   *   pickEditor() 可能把 ECTX 定在那类**单行框**上 —— 于是观察者回调去框里找图，
   *   0 张、静默返回：不报错、不提示、流水里也没有，表现就是「上传后毫无反应」
   *   （装置实测的 boot 流水原文：「就绪 · 主文档 <div>#fake-title」）。
   *   按钮路径走 runAct → pickEditor() 会重扫，所以能自救；自动链路不重扫，必须自己兜住。
   *   对策：手上这个上下文里没有图时，重扫一次候选，挑真的有图的。
   */
  function imgCtxForImg() {
    var c = imgCtx();
    if (c && c.root) {
      try { if (imgNodesIn(c.root).length) return c; } catch (e) {}
    }
    var fresh = null;
    try { fresh = pickEditor(); } catch (e) {}
    if (fresh && fresh.root) {
      try { if (imgNodesIn(fresh.root).length) return fresh; } catch (e) {}
    }
    return c || fresh;
  }

  /*
   * 「这一张需不需要动手」—— 幂等判据，与 roundImgEl 的分支**一一对应**：
   *   · 已经是目标圆角          → 0
   *   · 目标就是直角且现无圆角  → 0（没什么可拆的）
   *   · 其余                    → 1
   * 单独拎出来是为了让自动链路**先干跑一遍**：没有任何一张要改就不吃突发配额。
   */
  function imgNeedWork(img, root) {
    var r = imgTargetRadius(img, root);
    var css = 'border-radius:' + r + 'px;';
    if (elHasCss(img, css)) return 0;
    if (r === 0) return (img.style && img.style.borderRadius) ? 1 : 0;
    return 1;
  }

  /*
   * 被突发闸门限流后**延后一轮重试**（v2.4）。
   *   老行为是「直接放弃这一轮」：若被丢掉的正好是带图那一轮，图就永远等不到圆角。
   *   延后重试仍然走 mode='自动'（照样过闸门），只是错开 900ms 让它落在新窗口里；
   *   同一时刻只留一个待办，避免自己把自己堆成风暴。
   */
  function imgDeferRetry() {
    if (IMG_RETRY_T) return;
    IMG_RETRY_T = setTimeout(function () {
      IMG_RETRY_T = null;
      try { imgApplyNow('自动'); } catch (e) { trace('err', '图片延后补跑 · ' + (e && e.message)); }
    }, 900);
  }

  /*
   * 主流程：把正文里的图片全部对齐到目标圆角。

   * mode 只用于流水标注（自动 / 手动 / 开启补跑）。
   */
  function imgApplyNow(mode) {
    // ★ 必须走 imgCtxForImg：只信 ECTX 会在「boot 认错编辑框」时静默哑掉
    var ctx = imgCtxForImg();
    if (!ctx || !ctx.root) { if (mode !== '自动') toast('没找到正文编辑器'); return 0; }
    var list = imgNodesIn(ctx.root);
    if (!list.length) { if (mode !== '自动') toast('正文里还没有图片（上传后会自动处理）'); return 0; }

    /*
     * ★ 先干跑一遍（v2.4）：没有任何一张需要改 ⇒ 这是幂等轮，**零成本返回、不吃配额**。
     *   这一步是老口径最大的漏洞：我们自己的换节点会引起编辑器重渲染、再触发一轮
     *   「发现已是目标值 ⇒ 什么都没改」，这种轮次也在吃配额，真实上传时把配额吃光，
     *   真正带图的那一轮反而被丢掉（现场报告：一次会话丢弃 5 轮）。
     */
    var need = 0;
    for (var w = 0; w < list.length; w++) { if (imgNeedWork(list[w], ctx.root)) need++; }
    if (!need) {
      IMG_STAT.skipped = list.length;
      if (mode !== '自动') {
        toast('图片圆角已是目标值（单图 ' + IMG_R_SINGLE + 'px / 拼贴 ' + IMG_R_GAL + 'px）');
      }
      return 0;
    }
    // 真自激每一轮都是「要写」，照样在这里被截断；被限流则延后一轮，不再直接放弃
    if (mode === '自动' && !imgBurstTake()) {
      IMG_STAT.throttled++;
      trace('img', '自动圆角本轮限流（' + need + ' 张待处理），延后重试 · 累计 ' + IMG_STAT.throttled + ' 次');
      imgDeferRetry();
      return 0;
    }

    var before = String(ctx.root.innerHTML);
    var n = 0, skip = 0;
    for (var i = 0; i < list.length; i++) {
      if (roundImgEl(list[i], ctx.root) > 0) n++; else skip++;
    }
    if (!n) {
      if (mode !== '自动') {
        toast('图片圆角已是目标值（单图 ' + IMG_R_SINGLE + 'px / 拼贴 ' + IMG_R_GAL + 'px）');
      }
      IMG_STAT.skipped = skip;
      return 0;
    }
    IMG_STAT.applied += n;
    // ★ 同步固化：受控编辑器只接纳「换节点」，改属性会被整块回滚
    var solid = safeSolid(ctx, before);
    trace('img', '图片圆角·' + (mode || '手动') + ' ' + n + ' 张'
      + (skip ? '（已是目标值 ' + skip + ' 张）' : '')
      + '　固化=' + (solid >= 0 ? solid + ' 个节点' : '未触发'));
    if (mode !== '自动') {
      toast('已给 ' + n + ' 张图片加圆角（单图 ' + IMG_R_SINGLE + 'px / 拼贴 ' + IMG_R_GAL + 'px）');
    }
    imgAfterCheck(ctx);
    return n;
  }

  /*
   * 写完之后回头看一次：圆角还在不在。
   *   改了、固化了、还是被剥掉 ⇒ 说明该编辑器版本的图片节点不吃 border-radius。
   *   这种情况必须**说出来**（静默降级比失败更糟），但只提示一次。
   */
  function imgAfterCheck(ctx) {
    setTimeout(function () {
      try {
        if (!ctx || !ctx.root || !ctx.root.isConnected) return;
        /*
         * 只统计「目标本该带圆角」的图。
         *   否则「整篇都坐在直角容器里 ⇒ 全篇目标 0」会被误判成
         *   「圆角被编辑器剥掉」，进而误触发静音 + 假告警。
         */
        var list = imgNodesIn(ctx.root), alive = 0, want = 0;
        for (var i = 0; i < list.length; i++) {
          if (imgTargetRadius(list[i], ctx.root) <= 0) continue;
          want++;
          if (imgHasRound(list[i])) alive++;
        }
        if (!want) return;
        if (alive === 0 && !IMG_STRIP_WARNED) {
          IMG_STRIP_WARNED = true;
          IMG_AUTO_MUTE = true;      // ★ 不再自动重试：反复刷 DOM 只会让编辑器卡
          IMG_STAT.stripped++;
          trace('img', '圆角被编辑器剥掉（图片节点不吃 border-radius）→ 本次会话暂停自动重试');
          toast('图片圆角没被编辑器保留 —— 点标题栏红点把诊断发我');
        } else if (alive > 0) {
          trace('img', '圆角复查通过：' + alive + ' / ' + want + ' 张仍带圆角');
        }
      } catch (e) {}
    }, 900);
  }

  // 手动入口（面板按钮 / 脚本菜单）：关着就不动手，避免「以为开着其实没开」
  function applyImgRound() {
    if (!imgRoundOn()) { toast('图片自动圆角已关闭 —— 点「图片圆角 · 开」开启'); return; }
    /*
     * 手动一次 = **真的**再给编辑器一次机会（文档承诺的「可反复重试」兑现在这里）。
     *   两个标记必须**一起**清：
     *     · 只清 IMG_AUTO_MUTE 不清 IMG_STRIP_WARNED ⇒ 下次被剥时 `!IMG_STRIP_WARNED`
     *       为假 ⇒ 既不提示、也不再静音 ⇒ **变成无限重试**（危险）；
     *     · 只清 IMG_STRIP_WARNED 不清 IMG_AUTO_MUTE ⇒ 观察者仍然静音，手动试完就彻底哑了。
     */
    IMG_AUTO_MUTE = false;
    IMG_STRIP_WARNED = false;
    runAct('图片圆角', function () { imgApplyNow('手动'); });
  }

  // 这一批变更记录里有没有「图片」的动静
  function imgRecsHit(recs) {
    for (var i = 0; i < recs.length; i++) {
      var r = recs[i];
      if (r.type === 'attributes') {
        if (isRealImg(r.target)) return true;
        continue;
      }
      var ns = r.addedNodes || [];
      for (var j = 0; j < ns.length; j++) {
        var a = ns[j];
        if (a.nodeType !== 1 || isOurNode(a)) continue;
        if (isRealImg(a)) return true;
        // 新插入的子树里可能有真图片（宿主常常整块插入）
        if (a.querySelector && a.querySelector('img[src]')) return true;
      }
    }
    return false;
  }

  /*
   * 监听：图片被插入 / 上传完成换了 src，都算「有图要处理」。
   *   · childList+subtree：插入新图（编辑器原生上传、粘贴图片、拖拽）
   *   · attributes[src]：上传完成时宿主把占位 src 换成 mmbiz 域名，节点不换
   * 处理在回调内同步做（见文件头「为什么不能等一拍」）。
   */
  function bindImgWatch(doc) {
    if (!doc || !doc.body || doc.__mptbImgWatch) return;
    doc.__mptbImgWatch = true;
    try {
      var mo = new MutationObserver(function (recs) {
        if (IMG_AUTO_MUTE) return;          // 已确认这套编辑器不保留图片圆角 → 不再打扰
        if (!imgRoundOn()) return;
        if (!imgRecsHit(recs)) return;
        try { imgApplyNow('自动'); } catch (e) { trace('err', '图片自动圆角 · ' + (e && e.message)); }
        /*
         * ★ 把**自己造成的**待处理记录丢掉。
         *   上面那一步（改属性 + 换节点）会立刻产生新的 mutation 记录；不丢掉的话，
         *   观察者会在下一批里收到自己写的那条，于是"自己触发自己"。takeRecords()
         *   正是为此存在 —— 在回调内调用即清空尚未交付的记录队列。
         */
        try { mo.takeRecords(); } catch (e) {}
      });
      mo.observe(doc.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['src'] });
      IMG_DOCS.push({ doc: doc, mo: mo });
    } catch (e) {
      trace('err', '图片监听挂了 · ' + (e && e.message));
    }
  }

  /*
   * 诊断报告的一段 —— 「图片的圆角到底能不能留下来」要能当场回答。
   *   判据是编辑器自己的 schema：图片节点若带 style 属性，border-radius 就能随节点存活；
   *   没有 style 属性则必然被剥（此时报告里同时给出实测计数，两条证据互相印证）。
   */
  function imgLines(ctx) {
    var L = [];
    L.push('  自动圆角：' + (imgRoundOn() ? '开' : '关')
      + '　单图档 ' + IMG_R_SINGLE + 'px　拼贴档 ' + IMG_R_GAL + 'px');
    var root = ctx && ctx.root;
    var list = root ? imgNodesIn(root) : [];
    L.push('  正文图片：' + list.length + ' 张（已排除编辑器分隔占位）'
      + (IMG_STAT.applied ? '　本次已处理 ' + IMG_STAT.applied + ' 张' : '')
      + (IMG_STAT.stripped ? '　★ 被剥过 ' + IMG_STAT.stripped + ' 次' : '')
      + (IMG_STAT.throttled ? '　防自激丢弃 ' + IMG_STAT.throttled + ' 轮' : ''));
    for (var i = 0; i < list.length && i < 6; i++) {
      var im = list[i];
      L.push('   · 第' + (i + 1) + '张：目标 ' + imgTargetRadius(im, root) + 'px'
        + '　当前内联 ' + ((im.style && im.style.borderRadius) || '无')
        + (imgIsGallery(im) ? '　[拼贴]' : ''));
    }

    var host = pmHostOf(ctx), sc = host ? pmSchemaOf(host) : null, td = null;
    try { if (sc && sc.spec && sc.spec.nodes && sc.spec.nodes.get) td = sc.spec.nodes.get('image'); } catch (e) {}
    if (!td) {
      L.push('  schema·图片节点：没找到 image（图片可能由别的节点承载，或 schema 读不到）');
      return L;
    }
    var ak = attrKeysOf(td, td.spec);
    L.push('  schema·图片节点 image：attrs=[' + ak.join(',') + ']'
      + '　读入 ' + (readTagsOf(td.spec).join(' ') || '—')
      + '　写出 ' + readDomOf(td, td.spec));
    L.push('  ※ 图片节点' + (ak.indexOf('style') >= 0
      ? '带 style 属性 ⇒ border-radius 可以随节点存活（实测见上「当前内联」）'
      : '未见 style 属性 ⇒ border-radius 很可能被剥掉，圆角会退化为直角'));
    return L;
  }
})();