☰

auto-toc

可以为任何网站生成TOC网站目录大纲, 默认是不打开的, 需要去插件菜单里为想要打开 toc 的网站开启开关, 插件会记住这个开关, 下回再打开这个网站会自动根据开关来生成 toc 与否. 高级技巧: 单击TOC拖动栏可以自动暗淡 TOC, 双击TOC拖动栏可以关闭 TOC .

目前为 2024-12-29 提交的版本。查看 最新版本。

  1. // ==UserScript==
  2. // @name         auto-toc
  3. // @name:zh-CN   auto-toc
  4. // @namespace    EX
  5. // @version      1.54
  6. // @license MIT
  7. // @description Generate table of contents for any website. By default, it is not open. You need to go to the plug-in menu to open the switch for the website that wants to open the toc. The plug-in will remember this switch, and the toc will be generated automatically according to the switch when you open the website the next time.
  8. // @description:zh-cn 可以为任何网站生成TOC网站目录大纲, 默认是不打开的, 需要去插件菜单里为想要打开 toc 的网站开启开关, 插件会记住这个开关, 下回再打开这个网站会自动根据开关来生成 toc 与否. 高级技巧: 单击TOC拖动栏可以自动暗淡 TOC, 双击TOC拖动栏可以关闭 TOC .
  9. // @include      http://*
  10. // @include      https://*
  11. // @grant        GM_registerMenuCommand
  12. // @grant        GM.registerMenuCommand
  13. // @grant        GM_unregisterMenuCommand
  14. // @grant        GM.unregisterMenuCommand
  15. // @grant        GM_setValue
  16. // @grant        GM.setValue
  17. // @grant        GM_getValue
  18. // @grant        GM.getValue
  19. // @grant        GM_addStyle
  20. // @grant        GM.addStyle
  21. // @compatible        chrome
  22. // @compatible        edge
  23. // @compatible        safari
  24. // @supportURL        https://github.com/no5ix/auto-toc/issues
  25. // @homepage          https://github.com/no5ix/auto-toc
  26. // ==/UserScript==
  27.  
  28. (function () {
  29.     "use strict";
  30.  
  31.     function isSafari() {
  32.         return (
  33.             /Safari/.test(navigator.userAgent) &&
  34.             !/Chrome/.test(navigator.userAgent)
  35.         );
  36.     }
  37.  
  38.     function getRootWindow() {
  39.         let w = window;
  40.         while (w !== w.parent) {
  41.             w = w.parent;
  42.         }
  43.         return w;
  44.     }
  45.  
  46.     function getMaster(root) {
  47.         const iframes = [].slice.apply(
  48.             root.document.getElementsByTagName("iframe")
  49.         );
  50.  
  51.         if (iframes.length === 0) {
  52.             return root;
  53.         } else {
  54.             const largestChild = iframes
  55.                 .map((f) => ({
  56.                     elem: f,
  57.                     area: f.offsetWidth * f.offsetHeight,
  58.                 }))
  59.                 .sort((a, b) => b.area - a.area)[0];
  60.             const html = root.document.documentElement;
  61.             return largestChild.area / (html.offsetWidth * html.offsetHeight) >
  62.                 0.5
  63.                 ? largestChild.elem.contentWindow
  64.                 : root;
  65.         }
  66.     }
  67.  
  68.     let shouldLog = false;
  69.  
  70.     function isMasterFrame(w) {
  71.         const root = getRootWindow();
  72.         const master = getMaster(root);
  73.         return w === master;
  74.     }
  75.  
  76.     var toastCSS = `
  77.         #smarttoc-toast {
  78.             all: initial;
  79.         }
  80.         
  81.         #smarttoc-toast * {
  82.             all: unset;
  83.         }
  84.         
  85.         #smarttoc-toast {
  86.             display: none;
  87.             position: fixed;
  88.             left: 50%;
  89.             transform: translateX(-50%);
  90.             top: 0;
  91.             margin: 1em 2em;
  92.             min-width: 16em;
  93.             text-align: center;
  94.             padding: 1em;
  95.             z-index: 10000;
  96.             box-sizing: border-box;
  97.             background-color: #017afe;
  98.             border: 1px solid rgba(158, 158, 158, 0.22);
  99.             color: #ffffff;
  100.             font-size: calc(12px + 0.15vw);
  101.             font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
  102.             font-weight: normal;
  103.             -webkit-font-smoothing: subpixel-antialiased;
  104.             font-smoothing: subpixel-antialiased;
  105.             transition: opacity 200ms ease-out, transform 200ms ease-out;
  106.             border-radius: 18px;
  107.             box-shadow: 0px 0px 0px 0px rgb(0 0 0 / 20%), 0px 0px 8px 0 rgb(0 0 0 / 19%);
  108.         }
  109.         
  110.         #smarttoc-toast.enter {
  111.             display: block;
  112.             opacity: 0.01;
  113.             transform: translate3d(-50%, -2em, 0);
  114.         }
  115.         
  116.         #smarttoc-toast.enter.enter-active {
  117.             display: block;
  118.             opacity: 1;
  119.             transform: translate3d(-50%, 0, 0);
  120.         }
  121.         
  122.         #smarttoc-toast.leave {
  123.             display: block;
  124.             opacity: 1;
  125.             transform: translate3d(-50%, 0, 0);
  126.         }
  127.         
  128.         #smarttoc-toast.leave.leave-active {
  129.             display: block;
  130.             opacity: 0.01;
  131.             transform: translate3d(-50%, -2em, 0);
  132.         }
  133.     `;
  134.  
  135.     function log() {
  136.         if (false) {
  137.         }
  138.     }
  139.  
  140.     function draw(elem, color = "red") {
  141.         if (false && elem) {
  142.         }
  143.     }
  144.  
  145.     function assert(condition, error) {
  146.         if (!condition) {
  147.             throw new Error(error);
  148.         }
  149.     }
  150.  
  151.     // '12px' => 12
  152.     const num = (size = "0") =>
  153.         typeof size === "number" ? size : +size.replace(/px/, "");
  154.  
  155.     // '12px' <= 12
  156.     const px = (size = 0) => num(size) + "px";
  157.  
  158.     function throttle(fn, delay) {
  159.         if (delay) {
  160.             let timer;
  161.             return function timerThrottled(...args) {
  162.                 clearTimeout(timer);
  163.                 timer = setTimeout(function () {
  164.                     fn(...args);
  165.                 }, delay);
  166.             };
  167.         } else {
  168.             let request;
  169.             return function rafThrottled(...args) {
  170.                 cancelAnimationFrame(request);
  171.                 request = requestAnimationFrame(function () {
  172.                     fn(...args);
  173.                 });
  174.             };
  175.         }
  176.     }
  177.  
  178.     const safe = (str) => str.replace(/\s+/g, "-");
  179.  
  180.     const unique = (function uniqueGenerator() {
  181.         let set = new Set();
  182.         return function unique(str) {
  183.             let id = 1;
  184.             while (set.has(str)) {
  185.                 str = str.replace(/(\$\d+)?$/, "") + "$" + id;
  186.                 id++;
  187.             }
  188.             set.add(str);
  189.             return str;
  190.         };
  191.     })();
  192.  
  193.     const getScroll = (elem, direction = "top") => {
  194.         if (elem === document.body) {
  195.             return direction === "top"
  196.                 ? document.documentElement.scrollTop || document.body.scrollTop
  197.                 : document.documentElement.scrollLeft ||
  198.                       document.body.scrollLeft;
  199.         } else {
  200.             return direction === "top" ? elem.scrollTop : elem.scrollLeft;
  201.         }
  202.     };
  203.  
  204.     const setScroll = (elem, val, direction = "top") => {
  205.         if (elem === document.body) {
  206.             if (direction === "top") {
  207.                 document.documentElement.scrollTop = val;
  208.                 window.scrollTo(window.scrollX, val);
  209.             } else {
  210.                 document.documentElement.scrollLeft = val;
  211.                 window.scrollTo(val, window.scrollY);
  212.             }
  213.         } else {
  214.             if (direction === "top") {
  215.                 elem.scrollTop = val;
  216.             } else {
  217.                 elem.scrollLeft = val;
  218.             }
  219.         }
  220.     };
  221.  
  222.     const scrollTo = (function scrollToFactory() {
  223.         let request;
  224.         const easeOutQuad = function (t, b, c, d) {
  225.             t /= d;
  226.             return -c * t * (t - 2) + b;
  227.         };
  228.         return function scrollTo({
  229.             targetElem,
  230.             scrollElem,
  231.             topMargin = 0,
  232.             maxDuration = 300,
  233.             easeFn,
  234.             callback,
  235.         }) {
  236.             cancelAnimationFrame(request);
  237.             let rect = targetElem.getBoundingClientRect();
  238.             let endScrollTop =
  239.                 rect.top -
  240.                 (scrollElem === document.body
  241.                     ? 0
  242.                     : scrollElem.getBoundingClientRect().top) +
  243.                 getScroll(scrollElem) -
  244.                 topMargin;
  245.             let startScrollTop = getScroll(scrollElem);
  246.             let distance = endScrollTop - startScrollTop;
  247.             let startTime;
  248.             let ease = easeFn || easeOutQuad;
  249.             let distanceRatio = Math.min(Math.abs(distance) / 10000, 1);
  250.             let duration = Math.max(
  251.                 maxDuration * distanceRatio * (2 - distanceRatio),
  252.                 10
  253.             );
  254.             if (!maxDuration) {
  255.                 setScroll(scrollElem, endScrollTop);
  256.                 if (callback) {
  257.                     callback();
  258.                 }
  259.             } else {
  260.                 requestAnimationFrame(update);
  261.             }
  262.  
  263.             function update(timestamp) {
  264.                 if (!startTime) {
  265.                     startTime = timestamp;
  266.                 }
  267.                 let progress = (timestamp - startTime) / duration;
  268.                 if (progress < 1) {
  269.                     setScroll(
  270.                         scrollElem,
  271.                         ease(
  272.                             timestamp - startTime,
  273.                             startScrollTop,
  274.                             distance,
  275.                             duration
  276.                         )
  277.                     );
  278.                     requestAnimationFrame(update);
  279.                 } else {
  280.                     setScroll(scrollElem, endScrollTop);
  281.                     if (callback) {
  282.                         callback();
  283.                     }
  284.                 }
  285.             }
  286.         };
  287.     })();
  288.  
  289.     function toDash(str) {
  290.         return str.replace(/([A-Z])/g, (match, p1) => "-" + p1.toLowerCase());
  291.     }
  292.  
  293.     function applyStyle(elem, style = {}, reset = false) {
  294.         if (reset) {
  295.             elem.style = "";
  296.         }
  297.         if (typeof style === "string") {
  298.             elem.style = style;
  299.         } else {
  300.             for (let prop in style) {
  301.                 if (typeof style[prop] === "number") {
  302.                     elem.style.setProperty(
  303.                         toDash(prop),
  304.                         px(style[prop]),
  305.                         "important"
  306.                     );
  307.                 } else {
  308.                     elem.style.setProperty(
  309.                         toDash(prop),
  310.                         style[prop],
  311.                         "important"
  312.                     );
  313.                 }
  314.             }
  315.         }
  316.     }
  317.  
  318.     function translate3d(x = 0, y = 0, z = 0) {
  319.         return `translate3d(${Math.round(x)}px, ${Math.round(
  320.             y
  321.         )}px, ${Math.round(z)}px)`; // 0.5px => blurred text
  322.     }
  323.  
  324.     function setClass(elem, names, delay) {
  325.         if (delay === undefined) {
  326.             elem.classList = names;
  327.         } else {
  328.             return setTimeout(() => {
  329.                 elem.classList = names;
  330.             }, delay);
  331.         }
  332.     }
  333.  
  334.     const toast = (function toastFactory() {
  335.         let timers = [];
  336.         return function toast(msg, display_duration = 1600 /* ms */) {
  337.             let toast;
  338.             insertCSS(toastCSS, "smarttoc-toast__css");
  339.             if (document.getElementById("smarttoc-toast")) {
  340.                 toast = document.getElementById("smarttoc-toast");
  341.             } else {
  342.                 toast = document.createElement("DIV");
  343.                 toast.id = "smarttoc-toast";
  344.                 document.body.appendChild(toast);
  345.             }
  346.             toast.textContent = msg;
  347.  
  348.             timers.forEach(clearTimeout);
  349.             toast.classList = "";
  350.  
  351.             const set = setClass.bind(null, toast);
  352.  
  353.             toast.classList = "enter";
  354.             timers = [
  355.                 set("enter enter-active", 0),
  356.                 set("leave", display_duration),
  357.                 set("leave leave-active", display_duration),
  358.                 set("", display_duration + 200),
  359.             ];
  360.         };
  361.     })();
  362.  
  363.     const insertCSS = function (css, id) {
  364.         // if (!document.getElementById(id)) {
  365.         let style = document.createElement("STYLE");
  366.         style.type = "text/css";
  367.         style.id = id;
  368.         style.textContent = css;
  369.         document.head.appendChild(style);
  370.         // return
  371.         // }
  372.     };
  373.  
  374.     const removeCSS = function (id) {
  375.         let styleElement = document.querySelector(`#${id}`);
  376.         if (styleElement) {
  377.             styleElement.parentNode.removeChild(styleElement);
  378.         }
  379.     };
  380.  
  381.     function shouldCollapseToc() {
  382.         const domain2isCollapse = GM_getValue(
  383.             "menu_GAEEScript_auto_collapse_toc"
  384.         );
  385.         // console.log('[shouldCollapse cccccccccccccccccccccccccccccc]', domain2isCollapse);
  386.         // alert(domain2isCollapse[window.location.host])
  387.         return domain2isCollapse[window.location.host];
  388.     }
  389.  
  390.     let toc_dom = null;
  391.     let toc_text_wrap = true;
  392.  
  393.     function getTocCss() {
  394.         const shouldCollapse = shouldCollapseToc();
  395.         if (shouldLog) console.log("[getTocCss]", shouldCollapse);
  396.         return (
  397.             `
  398.             @media (prefers-color-scheme: dark) {
  399.                 #smarttoc.dark-scheme {
  400.                     /* background-color: rgb(48, 52, 54); */
  401.                 }
  402.             
  403.                 #smarttoc.dark-scheme .handle {
  404.                     /* color: #ffffff; */
  405.                 }
  406.             
  407.                 #smarttoc.dark-scheme a {
  408.                     /* color: #ccc; */
  409.                 }
  410.             
  411.                 #smarttoc.dark-scheme a:hover,
  412.                 #smarttoc.dark-scheme a:active {
  413.                     /* border-left-color: #f6f6f6; */
  414.                     /* color: #fff; */
  415.                 }
  416.             
  417.                 #smarttoc.dark-scheme li.active>a {
  418.                     /* border-left-color: rgb(46, 82, 154);
  419.                     color: rgb(131, 174, 218) */
  420.                 }
  421.             }
  422.             
  423.             #smarttoc {
  424.                 all: initial;
  425.             }
  426.             
  427.             #smarttoc * {
  428.                 all: unset;
  429.             }
  430.             
  431.             /* container */
  432.             #smarttoc {
  433.                 display: flex;
  434.                 flex-direction: column;
  435.                 align-items: stretch;
  436.                 position: fixed;
  437.                 min-width: 12em;
  438.                 /* resize: horizontal; */
  439.                 width: 18em;
  440.                 /* max-height: calc(100vh - 368px); */
  441.             ` +
  442.             (shouldCollapse
  443.                 ? "max-height: 22px;"
  444.                 : "max-height: calc(100vh - 100px);") +
  445.             `
  446.                 z-index: 888;
  447.                 box-sizing: border-box;
  448.                 /* background-color: #fff; */
  449.                 color: gray;
  450.                 font-size: calc(12px + 0.1vw);
  451.                 font-family: \"Helvetica Neue\", Helvetica, Arial, sans-serif;
  452.                 line-height: 1.5;
  453.                 font-weight: normal;
  454.                 /* border: 1px solid rgba(158, 158, 158, 0.22); */
  455.                 -webkit-font-smoothing: subpixel-antialiased;
  456.                 font-smoothing: subpixel-antialiased;
  457.                 overflow: hidden;
  458.                 contain: content;
  459.                 /* box-shadow: 0px 0px 0px 0px rgb(0 0 0 / 20%), 0px 0px 8px 0 rgb(0 0 0 / 19%); */
  460.                 border-radius: 6px;
  461.                 transition: max-height 0.3s ease-in-out, opacity 0.3s ease-in-out;
  462.             ` +
  463.             (shouldCollapse ? "opacity: 0.6;" : "opacity: 1;") +
  464.             `
  465.             }
  466.             
  467.             #smarttoc:hover {
  468.             ` +
  469.             (shouldCollapse
  470.                 ? "max-height: calc(100vh - 100px); opacity: 1"
  471.                 : "") +
  472.             `
  473.             }
  474.             
  475.             #smarttoc.hidden {
  476.                 display: none;
  477.             }
  478.             
  479.             #smarttoc .handle {
  480.                 -webkit-user-select: none;
  481.                 user-select: none;
  482.                 /* border-bottom: 1px solid rgba(158, 158, 158, 0.22); */
  483.                 padding: 0.1em 0.7em;
  484.                 font-variant-caps: inherit;
  485.                 font-variant: small-caps;
  486.                 font-size: 0.9em;
  487.                 color: rgb(0, 0, 0);
  488.                 cursor: pointer;
  489.                 text-align: center;
  490.                 opacity: 0.3;
  491.                 transition: opacity 0.3s ease-in-out;
  492.             }
  493.             
  494.             #smarttoc .handle:hover {
  495.                 cursor: move;
  496.                 opacity: 1;
  497.             }
  498.             
  499.             #smarttoc>ul {
  500.                 flex-grow: 1;
  501.                 padding: 1em 1.3em 1.3em 1em;
  502.                 overflow-y: auto;
  503.                 overflow-x: hidden;
  504.             ` +
  505.             (shouldCollapse ? "opacity: 0.3;" : "opacity: 1;") +
  506.             `
  507.                 transition: opacity 0.3s ease-in-out;
  508.             }
  509.             
  510.             #smarttoc>ul:hover {
  511.             ` +
  512.             (shouldCollapse ? "opacity: 1;" : "") +
  513.             `
  514.             }
  515.             ` +
  516.             (isSafari()
  517.                 ? ""
  518.                 : `
  519.             #smarttoc>ul::-webkit-scrollbar {  
  520.                 width: 3px;
  521.                 height: 1px;
  522.             }
  523.             
  524.             /* 滚动条轨道样式, 空的即为隐藏 */   
  525.             #smarttoc>ul::-webkit-scrollbar-track {
  526.             }  
  527.               
  528.             /* 滚动条滑块样式 */   
  529.             #smarttoc>ul::-webkit-scrollbar-thumb {  
  530.                 border-radius: 10px;
  531.                 background: rgb(128, 128, 128, 0);   
  532.                 transition: background 0.3s ease-in-out;
  533.             }  
  534.             
  535.             #smarttoc>ul:hover::-webkit-scrollbar-thumb {
  536.               background: rgb(128, 128, 128, 0.6);  
  537.             }  
  538.             `) +
  539.             `
  540.             /* all headings  */
  541.             #smarttoc ul,
  542.             #smarttoc li {
  543.                 list-style: none;
  544.                 display: block;
  545.             }
  546.             
  547.             #smarttoc a {
  548.                 text-decoration: none;
  549.                 color: rgb(128, 128, 128, 0.6);
  550.                 display: block;
  551.                 line-height: 1.3;
  552.                 padding-top: 0.2em;
  553.                 padding-bottom: 0.2em;
  554.             ` +
  555.             (toc_text_wrap
  556.                 ? "white-space: pre-wrap;"
  557.                 : "text-overflow: ellipsis; overflow-x: hidden; white-space: nowrap;") +
  558.             `
  559.                 margin-bottom: 0.8px;
  560.                 margin-top: 0.8px;
  561.                 transition: color 0.3s ease-in-out;
  562.             }
  563.             
  564.             #smarttoc a:hover,
  565.             #smarttoc a:active {
  566.                 /* color: #563d7c; */
  567.                 color: rgb(86, 61, 124, 1);
  568.             }
  569.             
  570.             #smarttoc li.active>a {
  571.                 /* color: #563d7c; */
  572.                 color: rgb(86, 61, 124, 1);
  573.             }
  574.             
  575.             /* heading level: 1 */
  576.             #smarttoc ul {
  577.                 line-height: 2;
  578.             }
  579.             
  580.             #smarttoc ul a {
  581.                 font-size: 1em;
  582.                 padding-left: 1.3em;
  583.                 cursor: pointer;
  584.             }
  585.             
  586.             #smarttoc ul a:hover,
  587.             #smarttoc ul a:active,
  588.             #smarttoc ul li.active>a {
  589.                 font-weight: 700;
  590.             }
  591.             
  592.             /* heading level: 2 (hidden only when there are too many headings)  */
  593.             #smarttoc ul ul {
  594.                 line-height: 1.8;
  595.             }
  596.             
  597.             #smarttoc.lengthy ul ul {
  598.                 display: none;
  599.             }
  600.             
  601.             #smarttoc.lengthy ul li.active>ul {
  602.                 display: block;
  603.             }
  604.             
  605.             #smarttoc ul ul a {
  606.                 font-size: 1em;
  607.                 padding-left: 2.7em;
  608.             }
  609.             
  610.             #smarttoc ul ul a:hover,
  611.             #smarttoc ul ul a:active,
  612.             #smarttoc ul ul li.active>a {
  613.                 font-weight: normal;
  614.             }
  615.             
  616.             /* heading level: 3 */
  617.             #smarttoc ul ul ul {
  618.                 line-height: 1.7;
  619.                 /* display: none; */  /* (hidden unless parent is active) */
  620.             }
  621.             
  622.             #smarttoc ul ul li.active>ul {
  623.                 display: block;
  624.             }
  625.             
  626.             #smarttoc ul ul ul a {
  627.                 font-size: 1em;
  628.                 padding-left: 4em;
  629.             }
  630.             
  631.             #smarttoc ul ul ul a:hover,
  632.             #smarttoc ul ul ul a:active,
  633.             #smarttoc ul ul ul li.active>a {
  634.                 font-weight: normal;
  635.             }
  636.             
  637.             /* heading level: 4 */
  638.             #smarttoc ul ul ul ul {
  639.                 line-height: 1.7;
  640.                 /* display: none; */  /* (hidden unless parent is active) */
  641.             }
  642.             
  643.             #smarttoc ul ul ul li.active>ul {
  644.                 display: block;
  645.             }
  646.             
  647.             #smarttoc ul ul ul ul a {
  648.                 font-size: 1em;
  649.                 padding-left: 5em;
  650.             }
  651.             
  652.             #smarttoc ul ul ul ul a:hover,
  653.             #smarttoc ul ul ul ul a:active,
  654.             #smarttoc ul ul ul ul li.active>a {
  655.                 font-weight: normal;
  656.             }
  657.             
  658.             /* heading level: 5 */
  659.             #smarttoc ul ul ul ul ul {
  660.                 line-height: 1.7;
  661.                 /* display: none; */  /* (hidden unless parent is active) */
  662.             }
  663.             
  664.             #smarttoc ul ul ul ul li.active>ul {
  665.                 display: block;
  666.             }
  667.             
  668.             #smarttoc ul ul ul ul ul a {
  669.                 font-size: 1em;
  670.                 padding-left: 6em;
  671.             }
  672.             
  673.             #smarttoc ul ul ul ul ul a:hover,
  674.             #smarttoc ul ul ul ul ul a:active,
  675.             #smarttoc ul ul ul ul ul li.active>a {
  676.                 font-weight: normal;
  677.             }
  678.             
  679.             /* heading level: 6 */
  680.             #smarttoc ul ul ul ul ul ul {
  681.                 line-height: 1.7;
  682.                 /* display: none; */  /* (hidden unless parent is active) */
  683.             }
  684.             
  685.             #smarttoc ul ul ul ul ul li.active>ul {
  686.                 display: block;
  687.             }
  688.             
  689.             #smarttoc ul ul ul ul ul ul a {
  690.                 font-size: 1em;
  691.                 padding-left: 7em;
  692.             }
  693.             
  694.             #smarttoc ul ul ul ul ul ul a:hover,
  695.             #smarttoc ul ul ul ul ul ul a:active,
  696.             #smarttoc ul ul ul ul ul ul li.active>a {
  697.                 font-weight: normal;
  698.             }
  699.         `
  700.         );
  701.     }
  702.  
  703.     const proto = {
  704.         subscribe(cb, emitOnSubscribe = true) {
  705.             if (emitOnSubscribe && this.value !== undefined) {
  706.                 cb(this.value);
  707.             }
  708.             this.listeners.push(cb);
  709.         },
  710.         addDependent(dependent) {
  711.             this.dependents.push(dependent);
  712.         },
  713.         update(val) {
  714.             this.value = val;
  715.             this.changed = true;
  716.             this.dependents.forEach((dep) => dep.update(val));
  717.         },
  718.         flush() {
  719.             if (this.changed) {
  720.                 this.changed = false;
  721.                 this.listeners.forEach((l) => l(this.value));
  722.                 this.dependents.forEach((dep) => dep.flush());
  723.             }
  724.         },
  725.         unique() {
  726.             let lastValue = this.value;
  727.             let $unique = Stream(lastValue);
  728.             this.subscribe((val) => {
  729.                 if (val !== lastValue) {
  730.                     $unique(val);
  731.                     lastValue = val;
  732.                 }
  733.             });
  734.             return $unique;
  735.         },
  736.         map(f) {
  737.             return Stream.combine(this, f);
  738.         },
  739.         filter(f) {
  740.             return this.map((output) => (f(output) ? output : undefined));
  741.         },
  742.         throttle(delay) {
  743.             let $throttled = Stream(this.value);
  744.             const emit = throttle($throttled, delay);
  745.             this.subscribe(emit);
  746.             return $throttled;
  747.         },
  748.         log(name) {
  749.             this.subscribe((e) => console.log(`[${name}]: `, e));
  750.             return this;
  751.         },
  752.     };
  753.  
  754.     function Stream(init) {
  755.         let s = function (val) {
  756.             if (val === undefined) return s.value;
  757.             s.update(val);
  758.             s.flush(val);
  759.         };
  760.  
  761.         s.value = init;
  762.         s.changed = false;
  763.         s.listeners = [];
  764.         s.dependents = [];
  765.  
  766.         return Object.assign(s, proto);
  767.     }
  768.  
  769.     Stream.combine = function (...streams) {
  770.         const combiner = streams.pop();
  771.         let cached = streams.map((s) => s());
  772.         const combined = Stream(combiner(...cached));
  773.  
  774.         streams.forEach((s, i) => {
  775.             const dependent = {
  776.                 update(val) {
  777.                     cached[i] = val;
  778.                     combined.update(combiner(...cached));
  779.                 },
  780.                 flush() {
  781.                     combined.flush();
  782.                 },
  783.             };
  784.             s.addDependent(dependent);
  785.         });
  786.  
  787.         return combined;
  788.     };
  789.  
  790.     Stream.interval = function (int) {
  791.         let $interval = Stream();
  792.         setInterval(() => $interval(null), int);
  793.         return $interval;
  794.     };
  795.  
  796.     Stream.fromEvent = function (elem, type) {
  797.         let $event = Stream();
  798.         elem.addEventListener(type, $event);
  799.         return $event;
  800.     };
  801.  
  802.     var commonjsGlobal =
  803.         typeof window !== "undefined"
  804.             ? window
  805.             : typeof global !== "undefined"
  806.             ? global
  807.             : typeof self !== "undefined"
  808.             ? self
  809.             : {};
  810.  
  811.     function createCommonjsModule(fn, module) {
  812.         return (
  813.             (module = { exports: {} }),
  814.             fn(module, module.exports),
  815.             module.exports
  816.         );
  817.     }
  818.  
  819.     var mithril = createCommonjsModule(function (module) {
  820.         (function () {
  821.             "use strict";
  822.             function Vnode(tag, key, attrs0, children, text, dom) {
  823.                 return {
  824.                     tag: tag,
  825.                     key: key,
  826.                     attrs: attrs0,
  827.                     children: children,
  828.                     text: text,
  829.                     dom: dom,
  830.                     domSize: undefined,
  831.                     state: undefined,
  832.                     _state: undefined,
  833.                     events: undefined,
  834.                     instance: undefined,
  835.                     skip: false,
  836.                 };
  837.             }
  838.             Vnode.normalize = function (node) {
  839.                 if (Array.isArray(node))
  840.                     return Vnode(
  841.                         "[",
  842.                         undefined,
  843.                         undefined,
  844.                         Vnode.normalizeChildren(node),
  845.                         undefined,
  846.                         undefined
  847.                     );
  848.                 if (node != null && typeof node !== "object")
  849.                     return Vnode(
  850.                         "#",
  851.                         undefined,
  852.                         undefined,
  853.                         node === false ? "" : node,
  854.                         undefined,
  855.                         undefined
  856.                     );
  857.                 return node;
  858.             };
  859.             Vnode.normalizeChildren = function normalizeChildren(children) {
  860.                 for (var i = 0; i < children.length; i++) {
  861.                     children[i] = Vnode.normalize(children[i]);
  862.                 }
  863.                 return children;
  864.             };
  865.             var selectorParser =
  866.                 /(?:(^|#|\.)([^#\.\[\]]+))|(\[(.+?)(?:\s*=\s*("|'|)((?:\\["'\]]|.)*?)\5)?\])/g;
  867.             var selectorCache = {};
  868.             var hasOwn = {}.hasOwnProperty;
  869.             function compileSelector(selector) {
  870.                 var match,
  871.                     tag = "div",
  872.                     classes = [],
  873.                     attrs = {};
  874.                 while ((match = selectorParser.exec(selector))) {
  875.                     var type = match[1],
  876.                         value = match[2];
  877.                     if (type === "" && value !== "") tag = value;
  878.                     else if (type === "#") attrs.id = value;
  879.                     else if (type === ".") classes.push(value);
  880.                     else if (match[3][0] === "[") {
  881.                         var attrValue = match[6];
  882.                         if (attrValue)
  883.                             attrValue = attrValue
  884.                                 .replace(/\\(["'])/g, "$1")
  885.                                 .replace(/\\\\/g, "\\");
  886.                         if (match[4] === "class") classes.push(attrValue);
  887.                         else
  888.                             attrs[match[4]] =
  889.                                 attrValue === ""
  890.                                     ? attrValue
  891.                                     : attrValue || true;
  892.                     }
  893.                 }
  894.                 if (classes.length > 0) attrs.className = classes.join(" ");
  895.                 return (selectorCache[selector] = { tag: tag, attrs: attrs });
  896.             }
  897.             function execSelector(state, attrs, children) {
  898.                 var hasAttrs = false,
  899.                     childList,
  900.                     text;
  901.                 var className = attrs.className || attrs.class;
  902.                 for (var key in state.attrs) {
  903.                     if (hasOwn.call(state.attrs, key)) {
  904.                         attrs[key] = state.attrs[key];
  905.                     }
  906.                 }
  907.                 if (className !== undefined) {
  908.                     if (attrs.class !== undefined) {
  909.                         attrs.class = undefined;
  910.                         attrs.className = className;
  911.                     }
  912.                     if (state.attrs.className != null) {
  913.                         attrs.className =
  914.                             state.attrs.className + " " + className;
  915.                     }
  916.                 }
  917.                 for (let key in attrs) {
  918.                     if (hasOwn.call(attrs, key) && key !== "key") {
  919.                         hasAttrs = true;
  920.                         break;
  921.                     }
  922.                 }
  923.                 if (
  924.                     Array.isArray(children) &&
  925.                     children.length === 1 &&
  926.                     children[0] != null &&
  927.                     children[0].tag === "#"
  928.                 ) {
  929.                     text = children[0].children;
  930.                 } else {
  931.                     childList = children;
  932.                 }
  933.                 return Vnode(
  934.                     state.tag,
  935.                     attrs.key,
  936.                     hasAttrs ? attrs : undefined,
  937.                     childList,
  938.                     text
  939.                 );
  940.             }
  941.             function hyperscript(selector) {
  942.                 // Because sloppy mode sucks
  943.                 var attrs = arguments[1],
  944.                     start = 2,
  945.                     children;
  946.                 if (
  947.                     selector == null ||
  948.                     (typeof selector !== "string" &&
  949.                         typeof selector !== "function" &&
  950.                         typeof selector.view !== "function")
  951.                 ) {
  952.                     throw Error(
  953.                         "The selector must be either a string or a component."
  954.                     );
  955.                 }
  956.                 if (typeof selector === "string") {
  957.                     var cached =
  958.                         selectorCache[selector] || compileSelector(selector);
  959.                 }
  960.                 if (attrs == null) {
  961.                     attrs = {};
  962.                 } else if (
  963.                     typeof attrs !== "object" ||
  964.                     attrs.tag != null ||
  965.                     Array.isArray(attrs)
  966.                 ) {
  967.                     attrs = {};
  968.                     start = 1;
  969.                 }
  970.                 if (arguments.length === start + 1) {
  971.                     children = arguments[start];
  972.                     if (!Array.isArray(children)) children = [children];
  973.                 } else {
  974.                     children = [];
  975.                     while (start < arguments.length)
  976.                         children.push(arguments[start++]);
  977.                 }
  978.                 var normalized = Vnode.normalizeChildren(children);
  979.                 if (typeof selector === "string") {
  980.                     return execSelector(cached, attrs, normalized);
  981.                 } else {
  982.                     return Vnode(selector, attrs.key, attrs, normalized);
  983.                 }
  984.             }
  985.             hyperscript.trust = function (html) {
  986.                 if (html == null) html = "";
  987.                 return Vnode(
  988.                     "<",
  989.                     undefined,
  990.                     undefined,
  991.                     html,
  992.                     undefined,
  993.                     undefined
  994.                 );
  995.             };
  996.             hyperscript.fragment = function (attrs1, children) {
  997.                 return Vnode(
  998.                     "[",
  999.                     attrs1.key,
  1000.                     attrs1,
  1001.                     Vnode.normalizeChildren(children),
  1002.                     undefined,
  1003.                     undefined
  1004.                 );
  1005.             };
  1006.             var m = hyperscript;
  1007.             /** @constructor */
  1008.             var PromisePolyfill = function (executor) {
  1009.                 if (!(this instanceof PromisePolyfill))
  1010.                     throw new Error("Promise must be called with `new`");
  1011.                 if (typeof executor !== "function")
  1012.                     throw new TypeError("executor must be a function");
  1013.                 var self = this,
  1014.                     resolvers = [],
  1015.                     rejectors = [],
  1016.                     resolveCurrent = handler(resolvers, true),
  1017.                     rejectCurrent = handler(rejectors, false);
  1018.                 var instance = (self._instance = {
  1019.                     resolvers: resolvers,
  1020.                     rejectors: rejectors,
  1021.                 });
  1022.                 var callAsync =
  1023.                     typeof setImmediate === "function"
  1024.                         ? setImmediate
  1025.                         : setTimeout;
  1026.                 function handler(list, shouldAbsorb) {
  1027.                     return function execute(value) {
  1028.                         var then;
  1029.                         try {
  1030.                             if (
  1031.                                 shouldAbsorb &&
  1032.                                 value != null &&
  1033.                                 (typeof value === "object" ||
  1034.                                     typeof value === "function") &&
  1035.                                 typeof (then = value.then) === "function"
  1036.                             ) {
  1037.                                 if (value === self)
  1038.                                     throw new TypeError(
  1039.                                         "Promise can't be resolved w/ itself"
  1040.                                     );
  1041.                                 executeOnce(then.bind(value));
  1042.                             } else {
  1043.                                 callAsync(function () {
  1044.                                     if (!shouldAbsorb && list.length === 0)
  1045.                                         console.error(
  1046.                                             "Possible unhandled promise rejection:",
  1047.                                             value
  1048.                                         );
  1049.                                     for (var i = 0; i < list.length; i++)
  1050.                                         list[i](value);
  1051.                                     (resolvers.length = 0),
  1052.                                         (rejectors.length = 0);
  1053.                                     instance.state = shouldAbsorb;
  1054.                                     instance.retry = function () {
  1055.                                         execute(value);
  1056.                                     };
  1057.                                 });
  1058.                             }
  1059.                         } catch (e) {
  1060.                             rejectCurrent(e);
  1061.                         }
  1062.                     };
  1063.                 }
  1064.                 function executeOnce(then) {
  1065.                     var runs = 0;
  1066.                     function run(fn) {
  1067.                         return function (value) {
  1068.                             if (runs++ > 0) return;
  1069.                             fn(value);
  1070.                         };
  1071.                     }
  1072.                     var onerror = run(rejectCurrent);
  1073.                     try {
  1074.                         then(run(resolveCurrent), onerror);
  1075.                     } catch (e) {
  1076.                         onerror(e);
  1077.                     }
  1078.                 }
  1079.                 executeOnce(executor);
  1080.             };
  1081.             PromisePolyfill.prototype.then = function (
  1082.                 onFulfilled,
  1083.                 onRejection
  1084.             ) {
  1085.                 var self = this,
  1086.                     instance = self._instance;
  1087.                 function handle(callback, list, next, state) {
  1088.                     list.push(function (value) {
  1089.                         if (typeof callback !== "function") next(value);
  1090.                         else
  1091.                             try {
  1092.                                 resolveNext(callback(value));
  1093.                             } catch (e) {
  1094.                                 if (rejectNext) rejectNext(e);
  1095.                             }
  1096.                     });
  1097.                     if (
  1098.                         typeof instance.retry === "function" &&
  1099.                         state === instance.state
  1100.                     )
  1101.                         instance.retry();
  1102.                 }
  1103.                 var resolveNext, rejectNext;
  1104.                 var promise = new PromisePolyfill(function (resolve, reject) {
  1105.                     (resolveNext = resolve), (rejectNext = reject);
  1106.                 });
  1107.                 handle(onFulfilled, instance.resolvers, resolveNext, true),
  1108.                     handle(onRejection, instance.rejectors, rejectNext, false);
  1109.                 return promise;
  1110.             };
  1111.             PromisePolyfill.prototype.catch = function (onRejection) {
  1112.                 return this.then(null, onRejection);
  1113.             };
  1114.             PromisePolyfill.resolve = function (value) {
  1115.                 if (value instanceof PromisePolyfill) return value;
  1116.                 return new PromisePolyfill(function (resolve) {
  1117.                     resolve(value);
  1118.                 });
  1119.             };
  1120.             PromisePolyfill.reject = function (value) {
  1121.                 return new PromisePolyfill(function (resolve, reject) {
  1122.                     reject(value);
  1123.                 });
  1124.             };
  1125.             PromisePolyfill.all = function (list) {
  1126.                 return new PromisePolyfill(function (resolve, reject) {
  1127.                     var total = list.length,
  1128.                         count = 0,
  1129.                         values = [];
  1130.                     if (list.length === 0) resolve([]);
  1131.                     else
  1132.                         for (var i = 0; i < list.length; i++) {
  1133.                             (function (i) {
  1134.                                 function consume(value) {
  1135.                                     count++;
  1136.                                     values[i] = value;
  1137.                                     if (count === total) resolve(values);
  1138.                                 }
  1139.                                 if (
  1140.                                     list[i] != null &&
  1141.                                     (typeof list[i] === "object" ||
  1142.                                         typeof list[i] === "function") &&
  1143.                                     typeof list[i].then === "function"
  1144.                                 ) {
  1145.                                     list[i].then(consume, reject);
  1146.                                 } else consume(list[i]);
  1147.                             })(i);
  1148.                         }
  1149.                 });
  1150.             };
  1151.             PromisePolyfill.race = function (list) {
  1152.                 return new PromisePolyfill(function (resolve, reject) {
  1153.                     for (var i = 0; i < list.length; i++) {
  1154.                         list[i].then(resolve, reject);
  1155.                     }
  1156.                 });
  1157.             };
  1158.             if (typeof window !== "undefined") {
  1159.                 if (typeof window.Promise === "undefined")
  1160.                     window.Promise = PromisePolyfill;
  1161.                 let PromisePolyfill = window.Promise;
  1162.             } else if (typeof commonjsGlobal !== "undefined") {
  1163.                 if (typeof commonjsGlobal.Promise === "undefined")
  1164.                     commonjsGlobal.Promise = PromisePolyfill;
  1165.                 let PromisePolyfill = commonjsGlobal.Promise;
  1166.             } else {
  1167.             }
  1168.             var buildQueryString = function (object) {
  1169.                 if (
  1170.                     Object.prototype.toString.call(object) !== "[object Object]"
  1171.                 )
  1172.                     return "";
  1173.                 var args = [];
  1174.                 for (var key0 in object) {
  1175.                     destructure(key0, object[key0]);
  1176.                 }
  1177.                 return args.join("&");
  1178.                 function destructure(key0, value) {
  1179.                     if (Array.isArray(value)) {
  1180.                         for (var i = 0; i < value.length; i++) {
  1181.                             destructure(key0 + "[" + i + "]", value[i]);
  1182.                         }
  1183.                     } else if (
  1184.                         Object.prototype.toString.call(value) ===
  1185.                         "[object Object]"
  1186.                     ) {
  1187.                         for (let i in value) {
  1188.                             destructure(key0 + "[" + i + "]", value[i]);
  1189.                         }
  1190.                     } else
  1191.                         args.push(
  1192.                             encodeURIComponent(key0) +
  1193.                                 (value != null && value !== ""
  1194.                                     ? "=" + encodeURIComponent(value)
  1195.                                     : "")
  1196.                         );
  1197.                 }
  1198.             };
  1199.             var FILE_PROTOCOL_REGEX = new RegExp("^file://", "i");
  1200.             var _8 = function ($window, Promise) {
  1201.                 var callbackCount = 0;
  1202.                 var oncompletion;
  1203.                 function setCompletionCallback(callback) {
  1204.                     oncompletion = callback;
  1205.                 }
  1206.                 function finalizer() {
  1207.                     var count = 0;
  1208.                     function complete() {
  1209.                         if (--count === 0 && typeof oncompletion === "function")
  1210.                             oncompletion();
  1211.                     }
  1212.                     return function finalize(promise0) {
  1213.                         var then0 = promise0.then;
  1214.                         promise0.then = function () {
  1215.                             count++;
  1216.                             var next = then0.apply(promise0, arguments);
  1217.                             next.then(complete, function (e) {
  1218.                                 complete();
  1219.                                 if (count === 0) throw e;
  1220.                             });
  1221.                             return finalize(next);
  1222.                         };
  1223.                         return promise0;
  1224.                     };
  1225.                 }
  1226.                 function normalize(args, extra) {
  1227.                     if (typeof args === "string") {
  1228.                         var url = args;
  1229.                         args = extra || {};
  1230.                         if (args.url == null) args.url = url;
  1231.                     }
  1232.                     return args;
  1233.                 }
  1234.                 function request(args, extra) {
  1235.                     var finalize = finalizer();
  1236.                     args = normalize(args, extra);
  1237.                     var promise0 = new Promise(function (resolve, reject) {
  1238.                         if (args.method == null) args.method = "GET";
  1239.                         args.method = args.method.toUpperCase();
  1240.                         var useBody =
  1241.                             args.method === "GET" || args.method === "TRACE"
  1242.                                 ? false
  1243.                                 : typeof args.useBody === "boolean"
  1244.                                 ? args.useBody
  1245.                                 : true;
  1246.                         if (typeof args.serialize !== "function")
  1247.                             args.serialize =
  1248.                                 typeof FormData !== "undefined" &&
  1249.                                 args.data instanceof FormData
  1250.                                     ? function (value) {
  1251.                                           return value;
  1252.                                       }
  1253.                                     : JSON.stringify;
  1254.                         if (typeof args.deserialize !== "function")
  1255.                             args.deserialize = deserialize;
  1256.                         if (typeof args.extract !== "function")
  1257.                             args.extract = extract;
  1258.                         args.url = interpolate(args.url, args.data);
  1259.                         if (useBody) args.data = args.serialize(args.data);
  1260.                         else args.url = assemble(args.url, args.data);
  1261.                         var xhr = new $window.XMLHttpRequest(),
  1262.                             aborted = false,
  1263.                             _abort = xhr.abort;
  1264.                         xhr.abort = function abort() {
  1265.                             aborted = true;
  1266.                             _abort.call(xhr);
  1267.                         };
  1268.                         xhr.open(
  1269.                             args.method,
  1270.                             args.url,
  1271.                             typeof args.async === "boolean" ? args.async : true,
  1272.                             typeof args.user === "string"
  1273.                                 ? args.user
  1274.                                 : undefined,
  1275.                             typeof args.password === "string"
  1276.                                 ? args.password
  1277.                                 : undefined
  1278.                         );
  1279.                         if (args.serialize === JSON.stringify && useBody) {
  1280.                             xhr.setRequestHeader(
  1281.                                 "Content-Type",
  1282.                                 "application/json; charset=utf-8"
  1283.                             );
  1284.                         }
  1285.                         if (args.deserialize === deserialize) {
  1286.                             xhr.setRequestHeader(
  1287.                                 "Accept",
  1288.                                 "application/json, text/*"
  1289.                             );
  1290.                         }
  1291.                         if (args.withCredentials)
  1292.                             xhr.withCredentials = args.withCredentials;
  1293.                         for (var key in args.headers)
  1294.                             if ({}.hasOwnProperty.call(args.headers, key)) {
  1295.                                 xhr.setRequestHeader(key, args.headers[key]);
  1296.                             }
  1297.                         if (typeof args.config === "function")
  1298.                             xhr = args.config(xhr, args) || xhr;
  1299.                         xhr.onreadystatechange = function () {
  1300.                             // Don't throw errors on xhr.abort().
  1301.                             if (aborted) return;
  1302.                             if (xhr.readyState === 4) {
  1303.                                 try {
  1304.                                     var response =
  1305.                                         args.extract !== extract
  1306.                                             ? args.extract(xhr, args)
  1307.                                             : args.deserialize(
  1308.                                                   args.extract(xhr, args)
  1309.                                               );
  1310.                                     if (
  1311.                                         (xhr.status >= 200 &&
  1312.                                             xhr.status < 300) ||
  1313.                                         xhr.status === 304 ||
  1314.                                         FILE_PROTOCOL_REGEX.test(args.url)
  1315.                                     ) {
  1316.                                         resolve(cast(args.type, response));
  1317.                                     } else {
  1318.                                         var error = new Error(xhr.responseText);
  1319.                                         for (var key in response)
  1320.                                             error[key] = response[key];
  1321.                                         reject(error);
  1322.                                     }
  1323.                                 } catch (e) {
  1324.                                     reject(e);
  1325.                                 }
  1326.                             }
  1327.                         };
  1328.                         if (useBody && args.data != null) xhr.send(args.data);
  1329.                         else xhr.send();
  1330.                     });
  1331.                     return args.background === true
  1332.                         ? promise0
  1333.                         : finalize(promise0);
  1334.                 }
  1335.                 function jsonp(args, extra) {
  1336.                     var finalize = finalizer();
  1337.                     args = normalize(args, extra);
  1338.                     var promise0 = new Promise(function (resolve, reject) {
  1339.                         var callbackName =
  1340.                             args.callbackName ||
  1341.                             "_mithril_" +
  1342.                                 Math.round(Math.random() * 1e16) +
  1343.                                 "_" +
  1344.                                 callbackCount++;
  1345.                         var script = $window.document.createElement("script");
  1346.                         $window[callbackName] = function (data) {
  1347.                             script.parentNode.removeChild(script);
  1348.                             resolve(cast(args.type, data));
  1349.                             delete $window[callbackName];
  1350.                         };
  1351.                         script.onerror = function () {
  1352.                             script.parentNode.removeChild(script);
  1353.                             reject(new Error("JSONP request failed"));
  1354.                             delete $window[callbackName];
  1355.                         };
  1356.                         if (args.data == null) args.data = {};
  1357.                         args.url = interpolate(args.url, args.data);
  1358.                         args.data[args.callbackKey || "callback"] =
  1359.                             callbackName;
  1360.                         script.src = assemble(args.url, args.data);
  1361.                         $window.document.documentElement.appendChild(script);
  1362.                     });
  1363.                     return args.background === true
  1364.                         ? promise0
  1365.                         : finalize(promise0);
  1366.                 }
  1367.                 function interpolate(url, data) {
  1368.                     if (data == null) return url;
  1369.                     var tokens = url.match(/:[^\/]+/gi) || [];
  1370.                     for (var i = 0; i < tokens.length; i++) {
  1371.                         var key = tokens[i].slice(1);
  1372.                         if (data[key] != null) {
  1373.                             url = url.replace(tokens[i], data[key]);
  1374.                         }
  1375.                     }
  1376.                     return url;
  1377.                 }
  1378.                 function assemble(url, data) {
  1379.                     var querystring = buildQueryString(data);
  1380.                     if (querystring !== "") {
  1381.                         var prefix = url.indexOf("?") < 0 ? "?" : "&";
  1382.                         url += prefix + querystring;
  1383.                     }
  1384.                     return url;
  1385.                 }
  1386.                 function deserialize(data) {
  1387.                     try {
  1388.                         return data !== "" ? JSON.parse(data) : null;
  1389.                     } catch (e) {
  1390.                         throw new Error(data);
  1391.                     }
  1392.                 }
  1393.                 function extract(xhr) {
  1394.                     return xhr.responseText;
  1395.                 }
  1396.                 function cast(type0, data) {
  1397.                     if (typeof type0 === "function") {
  1398.                         if (Array.isArray(data)) {
  1399.                             for (var i = 0; i < data.length; i++) {
  1400.                                 data[i] = new type0(data[i]);
  1401.                             }
  1402.                         } else return new type0(data);
  1403.                     }
  1404.                     return data;
  1405.                 }
  1406.                 return {
  1407.                     request: request,
  1408.                     jsonp: jsonp,
  1409.                     setCompletionCallback: setCompletionCallback,
  1410.                 };
  1411.             };
  1412.             var requestService = _8(window, PromisePolyfill);
  1413.             var coreRenderer = function ($window) {
  1414.                 var $doc = $window.document;
  1415.                 var $emptyFragment = $doc.createDocumentFragment();
  1416.                 var nameSpace = {
  1417.                     svg: "http://www.w3.org/2000/svg",
  1418.                     math: "http://www.w3.org/1998/Math/MathML",
  1419.                 };
  1420.                 var onevent;
  1421.                 function setEventCallback(callback) {
  1422.                     return (onevent = callback);
  1423.                 }
  1424.                 function getNameSpace(vnode) {
  1425.                     return (
  1426.                         (vnode.attrs && vnode.attrs.xmlns) ||
  1427.                         nameSpace[vnode.tag]
  1428.                     );
  1429.                 }
  1430.                 //create
  1431.                 function createNodes(
  1432.                     parent,
  1433.                     vnodes,
  1434.                     start,
  1435.                     end,
  1436.                     hooks,
  1437.                     nextSibling,
  1438.                     ns
  1439.                 ) {
  1440.                     for (var i = start; i < end; i++) {
  1441.                         var vnode = vnodes[i];
  1442.                         if (vnode != null) {
  1443.                             createNode(parent, vnode, hooks, ns, nextSibling);
  1444.                         }
  1445.                     }
  1446.                 }
  1447.                 function createNode(parent, vnode, hooks, ns, nextSibling) {
  1448.                     var tag = vnode.tag;
  1449.                     if (typeof tag === "string") {
  1450.                         vnode.state = {};
  1451.                         if (vnode.attrs != null)
  1452.                             initLifecycle(vnode.attrs, vnode, hooks);
  1453.                         switch (tag) {
  1454.                             case "#":
  1455.                                 return createText(parent, vnode, nextSibling);
  1456.                             case "<":
  1457.                                 return createHTML(parent, vnode, nextSibling);
  1458.                             case "[":
  1459.                                 return createFragment(
  1460.                                     parent,
  1461.                                     vnode,
  1462.                                     hooks,
  1463.                                     ns,
  1464.                                     nextSibling
  1465.                                 );
  1466.                             default:
  1467.                                 return createElement(
  1468.                                     parent,
  1469.                                     vnode,
  1470.                                     hooks,
  1471.                                     ns,
  1472.                                     nextSibling
  1473.                                 );
  1474.                         }
  1475.                     } else
  1476.                         return createComponent(
  1477.                             parent,
  1478.                             vnode,
  1479.                             hooks,
  1480.                             ns,
  1481.                             nextSibling
  1482.                         );
  1483.                 }
  1484.                 function createText(parent, vnode, nextSibling) {
  1485.                     vnode.dom = $doc.createTextNode(vnode.children);
  1486.                     insertNode(parent, vnode.dom, nextSibling);
  1487.                     return vnode.dom;
  1488.                 }
  1489.                 function createHTML(parent, vnode, nextSibling) {
  1490.                     var match1 = vnode.children.match(/^\s*?<(\w+)/im) || [];
  1491.                     var parent1 =
  1492.                         {
  1493.                             caption: "table",
  1494.                             thead: "table",
  1495.                             tbody: "table",
  1496.                             tfoot: "table",
  1497.                             tr: "tbody",
  1498.                             th: "tr",
  1499.                             td: "tr",
  1500.                             colgroup: "table",
  1501.                             col: "colgroup",
  1502.                         }[match1[1]] || "div";
  1503.                     var temp = $doc.createElement(parent1);
  1504.                     temp.innerHTML = vnode.children;
  1505.                     vnode.dom = temp.firstChild;
  1506.                     vnode.domSize = temp.childNodes.length;
  1507.                     var fragment = $doc.createDocumentFragment();
  1508.                     var child;
  1509.                     while ((child = temp.firstChild)) {
  1510.                         fragment.appendChild(child);
  1511.                     }
  1512.                     insertNode(parent, fragment, nextSibling);
  1513.                     return fragment;
  1514.                 }
  1515.                 function createFragment(parent, vnode, hooks, ns, nextSibling) {
  1516.                     var fragment = $doc.createDocumentFragment();
  1517.                     if (vnode.children != null) {
  1518.                         var children = vnode.children;
  1519.                         createNodes(
  1520.                             fragment,
  1521.                             children,
  1522.                             0,
  1523.                             children.length,
  1524.                             hooks,
  1525.                             null,
  1526.                             ns
  1527.                         );
  1528.                     }
  1529.                     vnode.dom = fragment.firstChild;
  1530.                     vnode.domSize = fragment.childNodes.length;
  1531.                     insertNode(parent, fragment, nextSibling);
  1532.                     return fragment;
  1533.                 }
  1534.                 function createElement(parent, vnode, hooks, ns, nextSibling) {
  1535.                     var tag = vnode.tag;
  1536.                     var attrs2 = vnode.attrs;
  1537.                     var is = attrs2 && attrs2.is;
  1538.                     ns = getNameSpace(vnode) || ns;
  1539.                     var element = ns
  1540.                         ? is
  1541.                             ? $doc.createElementNS(ns, tag, { is: is })
  1542.                             : $doc.createElementNS(ns, tag)
  1543.                         : is
  1544.                         ? $doc.createElement(tag, { is: is })
  1545.                         : $doc.createElement(tag);
  1546.                     vnode.dom = element;
  1547.                     if (attrs2 != null) {
  1548.                         setAttrs(vnode, attrs2, ns);
  1549.                     }
  1550.                     insertNode(parent, element, nextSibling);
  1551.                     if (
  1552.                         vnode.attrs != null &&
  1553.                         vnode.attrs.contenteditable != null
  1554.                     ) {
  1555.                         setContentEditable(vnode);
  1556.                     } else {
  1557.                         if (vnode.text != null) {
  1558.                             if (vnode.text !== "")
  1559.                                 element.textContent = vnode.text;
  1560.                             else
  1561.                                 vnode.children = [
  1562.                                     Vnode(
  1563.                                         "#",
  1564.                                         undefined,
  1565.                                         undefined,
  1566.                                         vnode.text,
  1567.                                         undefined,
  1568.                                         undefined
  1569.                                     ),
  1570.                                 ];
  1571.                         }
  1572.                         if (vnode.children != null) {
  1573.                             var children = vnode.children;
  1574.                             createNodes(
  1575.                                 element,
  1576.                                 children,
  1577.                                 0,
  1578.                                 children.length,
  1579.                                 hooks,
  1580.                                 null,
  1581.                                 ns
  1582.                             );
  1583.                             setLateAttrs(vnode);
  1584.                         }
  1585.                     }
  1586.                     return element;
  1587.                 }
  1588.                 function initComponent(vnode, hooks) {
  1589.                     var sentinel;
  1590.                     if (typeof vnode.tag.view === "function") {
  1591.                         vnode.state = Object.create(vnode.tag);
  1592.                         sentinel = vnode.state.view;
  1593.                         if (sentinel.$$reentrantLock$$ != null)
  1594.                             return $emptyFragment;
  1595.                         sentinel.$$reentrantLock$$ = true;
  1596.                     } else {
  1597.                         vnode.state = void 0;
  1598.                         sentinel = vnode.tag;
  1599.                         if (sentinel.$$reentrantLock$$ != null)
  1600.                             return $emptyFragment;
  1601.                         sentinel.$$reentrantLock$$ = true;
  1602.                         vnode.state =
  1603.                             vnode.tag.prototype != null &&
  1604.                             typeof vnode.tag.prototype.view === "function"
  1605.                                 ? new vnode.tag(vnode)
  1606.                                 : vnode.tag(vnode);
  1607.                     }
  1608.                     vnode._state = vnode.state;
  1609.                     if (vnode.attrs != null)
  1610.                         initLifecycle(vnode.attrs, vnode, hooks);
  1611.                     initLifecycle(vnode._state, vnode, hooks);
  1612.                     vnode.instance = Vnode.normalize(
  1613.                         vnode._state.view.call(vnode.state, vnode)
  1614.                     );
  1615.                     if (vnode.instance === vnode)
  1616.                         throw Error(
  1617.                             "A view cannot return the vnode it received as argument"
  1618.                         );
  1619.                     sentinel.$$reentrantLock$$ = null;
  1620.                 }
  1621.                 function createComponent(
  1622.                     parent,
  1623.                     vnode,
  1624.                     hooks,
  1625.                     ns,
  1626.                     nextSibling
  1627.                 ) {
  1628.                     initComponent(vnode, hooks);
  1629.                     if (vnode.instance != null) {
  1630.                         var element = createNode(
  1631.                             parent,
  1632.                             vnode.instance,
  1633.                             hooks,
  1634.                             ns,
  1635.                             nextSibling
  1636.                         );
  1637.                         vnode.dom = vnode.instance.dom;
  1638.                         vnode.domSize =
  1639.                             vnode.dom != null ? vnode.instance.domSize : 0;
  1640.                         insertNode(parent, element, nextSibling);
  1641.                         return element;
  1642.                     } else {
  1643.                         vnode.domSize = 0;
  1644.                         return $emptyFragment;
  1645.                     }
  1646.                 }
  1647.                 //update
  1648.                 function updateNodes(
  1649.                     parent,
  1650.                     old,
  1651.                     vnodes,
  1652.                     recycling,
  1653.                     hooks,
  1654.                     nextSibling,
  1655.                     ns
  1656.                 ) {
  1657.                     if (old === vnodes || (old == null && vnodes == null))
  1658.                         return;
  1659.                     else if (old == null)
  1660.                         createNodes(
  1661.                             parent,
  1662.                             vnodes,
  1663.                             0,
  1664.                             vnodes.length,
  1665.                             hooks,
  1666.                             nextSibling,
  1667.                             ns
  1668.                         );
  1669.                     else if (vnodes == null)
  1670.                         removeNodes(old, 0, old.length, vnodes);
  1671.                     else {
  1672.                         if (old.length === vnodes.length) {
  1673.                             var isUnkeyed = false;
  1674.                             for (var i = 0; i < vnodes.length; i++) {
  1675.                                 if (vnodes[i] != null && old[i] != null) {
  1676.                                     isUnkeyed =
  1677.                                         vnodes[i].key == null &&
  1678.                                         old[i].key == null;
  1679.                                     break;
  1680.                                 }
  1681.                             }
  1682.                             if (isUnkeyed) {
  1683.                                 for (let i = 0; i < old.length; i++) {
  1684.                                     if (old[i] === vnodes[i]) continue;
  1685.                                     else if (
  1686.                                         old[i] == null &&
  1687.                                         vnodes[i] != null
  1688.                                     )
  1689.                                         createNode(
  1690.                                             parent,
  1691.                                             vnodes[i],
  1692.                                             hooks,
  1693.                                             ns,
  1694.                                             getNextSibling(
  1695.                                                 old,
  1696.                                                 i + 1,
  1697.                                                 nextSibling
  1698.                                             )
  1699.                                         );
  1700.                                     else if (vnodes[i] == null)
  1701.                                         removeNodes(old, i, i + 1, vnodes);
  1702.                                     else
  1703.                                         updateNode(
  1704.                                             parent,
  1705.                                             old[i],
  1706.                                             vnodes[i],
  1707.                                             hooks,
  1708.                                             getNextSibling(
  1709.                                                 old,
  1710.                                                 i + 1,
  1711.                                                 nextSibling
  1712.                                             ),
  1713.                                             recycling,
  1714.                                             ns
  1715.                                         );
  1716.                                 }
  1717.                                 return;
  1718.                             }
  1719.                         }
  1720.                         recycling = recycling || isRecyclable(old, vnodes);
  1721.                         if (recycling) {
  1722.                             var pool = old.pool;
  1723.                             old = old.concat(old.pool);
  1724.                         }
  1725.                         var oldStart = 0,
  1726.                             start = 0,
  1727.                             oldEnd = old.length - 1,
  1728.                             end = vnodes.length - 1,
  1729.                             map;
  1730.                         while (oldEnd >= oldStart && end >= start) {
  1731.                             var o = old[oldStart],
  1732.                                 v = vnodes[start];
  1733.                             if (o === v && !recycling) oldStart++, start++;
  1734.                             else if (o == null) oldStart++;
  1735.                             else if (v == null) start++;
  1736.                             else if (o.key === v.key) {
  1737.                                 var shouldRecycle =
  1738.                                     (pool != null &&
  1739.                                         oldStart >= old.length - pool.length) ||
  1740.                                     (pool == null && recycling);
  1741.                                 oldStart++, start++;
  1742.                                 updateNode(
  1743.                                     parent,
  1744.                                     o,
  1745.                                     v,
  1746.                                     hooks,
  1747.                                     getNextSibling(old, oldStart, nextSibling),
  1748.                                     shouldRecycle,
  1749.                                     ns
  1750.                                 );
  1751.                                 if (recycling && o.tag === v.tag)
  1752.                                     insertNode(
  1753.                                         parent,
  1754.                                         toFragment(o),
  1755.                                         nextSibling
  1756.                                     );
  1757.                             } else {
  1758.                                 let o = old[oldEnd];
  1759.                                 if (o === v && !recycling) oldEnd--, start++;
  1760.                                 else if (o == null) oldEnd--;
  1761.                                 else if (v == null) start++;
  1762.                                 else if (o.key === v.key) {
  1763.                                     let shouldRecycle =
  1764.                                         (pool != null &&
  1765.                                             oldEnd >=
  1766.                                                 old.length - pool.length) ||
  1767.                                         (pool == null && recycling);
  1768.                                     updateNode(
  1769.                                         parent,
  1770.                                         o,
  1771.                                         v,
  1772.                                         hooks,
  1773.                                         getNextSibling(
  1774.                                             old,
  1775.                                             oldEnd + 1,
  1776.                                             nextSibling
  1777.                                         ),
  1778.                                         shouldRecycle,
  1779.                                         ns
  1780.                                     );
  1781.                                     if (recycling || start < end)
  1782.                                         insertNode(
  1783.                                             parent,
  1784.                                             toFragment(o),
  1785.                                             getNextSibling(
  1786.                                                 old,
  1787.                                                 oldStart,
  1788.                                                 nextSibling
  1789.                                             )
  1790.                                         );
  1791.                                     oldEnd--, start++;
  1792.                                 } else break;
  1793.                             }
  1794.                         }
  1795.                         while (oldEnd >= oldStart && end >= start) {
  1796.                             let o = old[oldEnd],
  1797.                                 v = vnodes[end];
  1798.                             if (o === v && !recycling) oldEnd--, end--;
  1799.                             else if (o == null) oldEnd--;
  1800.                             else if (v == null) end--;
  1801.                             else if (o.key === v.key) {
  1802.                                 let shouldRecycle =
  1803.                                     (pool != null &&
  1804.                                         oldEnd >= old.length - pool.length) ||
  1805.                                     (pool == null && recycling);
  1806.                                 updateNode(
  1807.                                     parent,
  1808.                                     o,
  1809.                                     v,
  1810.                                     hooks,
  1811.                                     getNextSibling(
  1812.                                         old,
  1813.                                         oldEnd + 1,
  1814.                                         nextSibling
  1815.                                     ),
  1816.                                     shouldRecycle,
  1817.                                     ns
  1818.                                 );
  1819.                                 if (recycling && o.tag === v.tag)
  1820.                                     insertNode(
  1821.                                         parent,
  1822.                                         toFragment(o),
  1823.                                         nextSibling
  1824.                                     );
  1825.                                 if (o.dom != null) nextSibling = o.dom;
  1826.                                 oldEnd--, end--;
  1827.                             } else {
  1828.                                 if (!map) map = getKeyMap(old, oldEnd);
  1829.                                 if (v != null) {
  1830.                                     var oldIndex = map[v.key];
  1831.                                     if (oldIndex != null) {
  1832.                                         let movable = old[oldIndex];
  1833.                                         let shouldRecycle =
  1834.                                             (pool != null &&
  1835.                                                 oldIndex >=
  1836.                                                     old.length - pool.length) ||
  1837.                                             (pool == null && recycling);
  1838.                                         updateNode(
  1839.                                             parent,
  1840.                                             movable,
  1841.                                             v,
  1842.                                             hooks,
  1843.                                             getNextSibling(
  1844.                                                 old,
  1845.                                                 oldEnd + 1,
  1846.                                                 nextSibling
  1847.                                             ),
  1848.                                             recycling,
  1849.                                             ns
  1850.                                         );
  1851.                                         insertNode(
  1852.                                             parent,
  1853.                                             toFragment(movable),
  1854.                                             nextSibling
  1855.                                         );
  1856.                                         old[oldIndex].skip = true;
  1857.                                         if (movable.dom != null)
  1858.                                             nextSibling = movable.dom;
  1859.                                     } else {
  1860.                                         var dom = createNode(
  1861.                                             parent,
  1862.                                             v,
  1863.                                             hooks,
  1864.                                             ns,
  1865.                                             nextSibling
  1866.                                         );
  1867.                                         nextSibling = dom;
  1868.                                     }
  1869.                                 }
  1870.                                 end--;
  1871.                             }
  1872.                             if (end < start) break;
  1873.                         }
  1874.                         createNodes(
  1875.                             parent,
  1876.                             vnodes,
  1877.                             start,
  1878.                             end + 1,
  1879.                             hooks,
  1880.                             nextSibling,
  1881.                             ns
  1882.                         );
  1883.                         removeNodes(old, oldStart, oldEnd + 1, vnodes);
  1884.                     }
  1885.                 }
  1886.                 function updateNode(
  1887.                     parent,
  1888.                     old,
  1889.                     vnode,
  1890.                     hooks,
  1891.                     nextSibling,
  1892.                     recycling,
  1893.                     ns
  1894.                 ) {
  1895.                     var oldTag = old.tag,
  1896.                         tag = vnode.tag;
  1897.                     if (oldTag === tag) {
  1898.                         vnode.state = old.state;
  1899.                         vnode._state = old._state;
  1900.                         vnode.events = old.events;
  1901.                         if (!recycling && shouldNotUpdate(vnode, old)) return;
  1902.                         if (typeof oldTag === "string") {
  1903.                             if (vnode.attrs != null) {
  1904.                                 if (recycling) {
  1905.                                     vnode.state = {};
  1906.                                     initLifecycle(vnode.attrs, vnode, hooks);
  1907.                                 } else
  1908.                                     updateLifecycle(vnode.attrs, vnode, hooks);
  1909.                             }
  1910.                             switch (oldTag) {
  1911.                                 case "#":
  1912.                                     updateText(old, vnode);
  1913.                                     break;
  1914.                                 case "<":
  1915.                                     updateHTML(parent, old, vnode, nextSibling);
  1916.                                     break;
  1917.                                 case "[":
  1918.                                     updateFragment(
  1919.                                         parent,
  1920.                                         old,
  1921.                                         vnode,
  1922.                                         recycling,
  1923.                                         hooks,
  1924.                                         nextSibling,
  1925.                                         ns
  1926.                                     );
  1927.                                     break;
  1928.                                 default:
  1929.                                     updateElement(
  1930.                                         old,
  1931.                                         vnode,
  1932.                                         recycling,
  1933.                                         hooks,
  1934.                                         ns
  1935.                                     );
  1936.                             }
  1937.                         } else
  1938.                             updateComponent(
  1939.                                 parent,
  1940.                                 old,
  1941.                                 vnode,
  1942.                                 hooks,
  1943.                                 nextSibling,
  1944.                                 recycling,
  1945.                                 ns
  1946.                             );
  1947.                     } else {
  1948.                         removeNode(old, null);
  1949.                         createNode(parent, vnode, hooks, ns, nextSibling);
  1950.                     }
  1951.                 }
  1952.                 function updateText(old, vnode) {
  1953.                     if (old.children.toString() !== vnode.children.toString()) {
  1954.                         old.dom.nodeValue = vnode.children;
  1955.                     }
  1956.                     vnode.dom = old.dom;
  1957.                 }
  1958.                 function updateHTML(parent, old, vnode, nextSibling) {
  1959.                     if (old.children !== vnode.children) {
  1960.                         toFragment(old);
  1961.                         createHTML(parent, vnode, nextSibling);
  1962.                     } else (vnode.dom = old.dom), (vnode.domSize = old.domSize);
  1963.                 }
  1964.                 function updateFragment(
  1965.                     parent,
  1966.                     old,
  1967.                     vnode,
  1968.                     recycling,
  1969.                     hooks,
  1970.                     nextSibling,
  1971.                     ns
  1972.                 ) {
  1973.                     updateNodes(
  1974.                         parent,
  1975.                         old.children,
  1976.                         vnode.children,
  1977.                         recycling,
  1978.                         hooks,
  1979.                         nextSibling,
  1980.                         ns
  1981.                     );
  1982.                     var domSize = 0,
  1983.                         children = vnode.children;
  1984.                     vnode.dom = null;
  1985.                     if (children != null) {
  1986.                         for (var i = 0; i < children.length; i++) {
  1987.                             var child = children[i];
  1988.                             if (child != null && child.dom != null) {
  1989.                                 if (vnode.dom == null) vnode.dom = child.dom;
  1990.                                 domSize += child.domSize || 1;
  1991.                             }
  1992.                         }
  1993.                         if (domSize !== 1) vnode.domSize = domSize;
  1994.                     }
  1995.                 }
  1996.                 function updateElement(old, vnode, recycling, hooks, ns) {
  1997.                     var element = (vnode.dom = old.dom);
  1998.                     ns = getNameSpace(vnode) || ns;
  1999.                     if (vnode.tag === "textarea") {
  2000.                         if (vnode.attrs == null) vnode.attrs = {};
  2001.                         if (vnode.text != null) {
  2002.                             vnode.attrs.value = vnode.text; //FIXME handle0 multiple children
  2003.                             vnode.text = undefined;
  2004.                         }
  2005.                     }
  2006.                     updateAttrs(vnode, old.attrs, vnode.attrs, ns);
  2007.                     if (
  2008.                         vnode.attrs != null &&
  2009.                         vnode.attrs.contenteditable != null
  2010.                     ) {
  2011.                         setContentEditable(vnode);
  2012.                     } else if (
  2013.                         old.text != null &&
  2014.                         vnode.text != null &&
  2015.                         vnode.text !== ""
  2016.                     ) {
  2017.                         if (old.text.toString() !== vnode.text.toString())
  2018.                             old.dom.firstChild.nodeValue = vnode.text;
  2019.                     } else {
  2020.                         if (old.text != null)
  2021.                             old.children = [
  2022.                                 Vnode(
  2023.                                     "#",
  2024.                                     undefined,
  2025.                                     undefined,
  2026.                                     old.text,
  2027.                                     undefined,
  2028.                                     old.dom.firstChild
  2029.                                 ),
  2030.                             ];
  2031.                         if (vnode.text != null)
  2032.                             vnode.children = [
  2033.                                 Vnode(
  2034.                                     "#",
  2035.                                     undefined,
  2036.                                     undefined,
  2037.                                     vnode.text,
  2038.                                     undefined,
  2039.                                     undefined
  2040.                                 ),
  2041.                             ];
  2042.                         updateNodes(
  2043.                             element,
  2044.                             old.children,
  2045.                             vnode.children,
  2046.                             recycling,
  2047.                             hooks,
  2048.                             null,
  2049.                             ns
  2050.                         );
  2051.                     }
  2052.                 }
  2053.                 function updateComponent(
  2054.                     parent,
  2055.                     old,
  2056.                     vnode,
  2057.                     hooks,
  2058.                     nextSibling,
  2059.                     recycling,
  2060.                     ns
  2061.                 ) {
  2062.                     if (recycling) {
  2063.                         initComponent(vnode, hooks);
  2064.                     } else {
  2065.                         vnode.instance = Vnode.normalize(
  2066.                             vnode._state.view.call(vnode.state, vnode)
  2067.                         );
  2068.                         if (vnode.instance === vnode)
  2069.                             throw Error(
  2070.                                 "A view cannot return the vnode it received as argument"
  2071.                             );
  2072.                         if (vnode.attrs != null)
  2073.                             updateLifecycle(vnode.attrs, vnode, hooks);
  2074.                         updateLifecycle(vnode._state, vnode, hooks);
  2075.                     }
  2076.                     if (vnode.instance != null) {
  2077.                         if (old.instance == null)
  2078.                             createNode(
  2079.                                 parent,
  2080.                                 vnode.instance,
  2081.                                 hooks,
  2082.                                 ns,
  2083.                                 nextSibling
  2084.                             );
  2085.                         else
  2086.                             updateNode(
  2087.                                 parent,
  2088.                                 old.instance,
  2089.                                 vnode.instance,
  2090.                                 hooks,
  2091.                                 nextSibling,
  2092.                                 recycling,
  2093.                                 ns
  2094.                             );
  2095.                         vnode.dom = vnode.instance.dom;
  2096.                         vnode.domSize = vnode.instance.domSize;
  2097.                     } else if (old.instance != null) {
  2098.                         removeNode(old.instance, null);
  2099.                         vnode.dom = undefined;
  2100.                         vnode.domSize = 0;
  2101.                     } else {
  2102.                         vnode.dom = old.dom;
  2103.                         vnode.domSize = old.domSize;
  2104.                     }
  2105.                 }
  2106.                 function isRecyclable(old, vnodes) {
  2107.                     if (
  2108.                         old.pool != null &&
  2109.                         Math.abs(old.pool.length - vnodes.length) <=
  2110.                             Math.abs(old.length - vnodes.length)
  2111.                     ) {
  2112.                         var oldChildrenLength =
  2113.                             (old[0] &&
  2114.                                 old[0].children &&
  2115.                                 old[0].children.length) ||
  2116.                             0;
  2117.                         var poolChildrenLength =
  2118.                             (old.pool[0] &&
  2119.                                 old.pool[0].children &&
  2120.                                 old.pool[0].children.length) ||
  2121.                             0;
  2122.                         var vnodesChildrenLength =
  2123.                             (vnodes[0] &&
  2124.                                 vnodes[0].children &&
  2125.                                 vnodes[0].children.length) ||
  2126.                             0;
  2127.                         if (
  2128.                             Math.abs(
  2129.                                 poolChildrenLength - vnodesChildrenLength
  2130.                             ) <=
  2131.                             Math.abs(oldChildrenLength - vnodesChildrenLength)
  2132.                         ) {
  2133.                             return true;
  2134.                         }
  2135.                     }
  2136.                     return false;
  2137.                 }
  2138.                 function getKeyMap(vnodes, end) {
  2139.                     var map = {},
  2140.                         i = 0;
  2141.                     for (let i = 0; i < end; i++) {
  2142.                         let vnode = vnodes[i];
  2143.                         if (vnode != null) {
  2144.                             let key2 = vnode.key;
  2145.                             if (key2 != null) map[key2] = i;
  2146.                         }
  2147.                     }
  2148.                     return map;
  2149.                 }
  2150.                 function toFragment(vnode) {
  2151.                     var count0 = vnode.domSize;
  2152.                     if (count0 != null || vnode.dom == null) {
  2153.                         var fragment = $doc.createDocumentFragment();
  2154.                         if (count0 > 0) {
  2155.                             var dom = vnode.dom;
  2156.                             while (--count0)
  2157.                                 fragment.appendChild(dom.nextSibling);
  2158.                             fragment.insertBefore(dom, fragment.firstChild);
  2159.                         }
  2160.                         return fragment;
  2161.                     } else return vnode.dom;
  2162.                 }
  2163.                 function getNextSibling(vnodes, i, nextSibling) {
  2164.                     for (; i < vnodes.length; i++) {
  2165.                         if (vnodes[i] != null && vnodes[i].dom != null)
  2166.                             return vnodes[i].dom;
  2167.                     }
  2168.                     return nextSibling;
  2169.                 }
  2170.                 function insertNode(parent, dom, nextSibling) {
  2171.                     if (nextSibling && nextSibling.parentNode)
  2172.                         parent.insertBefore(dom, nextSibling);
  2173.                     else parent.appendChild(dom);
  2174.                 }
  2175.                 function setContentEditable(vnode) {
  2176.                     var children = vnode.children;
  2177.                     if (
  2178.                         children != null &&
  2179.                         children.length === 1 &&
  2180.                         children[0].tag === "<"
  2181.                     ) {
  2182.                         var content = children[0].children;
  2183.                         if (vnode.dom.innerHTML !== content)
  2184.                             vnode.dom.innerHTML = content;
  2185.                     } else if (
  2186.                         vnode.text != null ||
  2187.                         (children != null && children.length !== 0)
  2188.                     )
  2189.                         throw new Error(
  2190.                             "Child node of a contenteditable must be trusted"
  2191.                         );
  2192.                 }
  2193.                 //remove
  2194.                 function removeNodes(vnodes, start, end, context) {
  2195.                     for (var i = start; i < end; i++) {
  2196.                         var vnode = vnodes[i];
  2197.                         if (vnode != null) {
  2198.                             if (vnode.skip) vnode.skip = false;
  2199.                             else removeNode(vnode, context);
  2200.                         }
  2201.                     }
  2202.                 }
  2203.                 function removeNode(vnode, context) {
  2204.                     var expected = 1,
  2205.                         called = 0;
  2206.                     if (
  2207.                         vnode.attrs &&
  2208.                         typeof vnode.attrs.onbeforeremove === "function"
  2209.                     ) {
  2210.                         var result = vnode.attrs.onbeforeremove.call(
  2211.                             vnode.state,
  2212.                             vnode
  2213.                         );
  2214.                         if (
  2215.                             result != null &&
  2216.                             typeof result.then === "function"
  2217.                         ) {
  2218.                             expected++;
  2219.                             result.then(continuation, continuation);
  2220.                         }
  2221.                     }
  2222.                     if (
  2223.                         typeof vnode.tag !== "string" &&
  2224.                         typeof vnode._state.onbeforeremove === "function"
  2225.                     ) {
  2226.                         let result = vnode._state.onbeforeremove.call(
  2227.                             vnode.state,
  2228.                             vnode
  2229.                         );
  2230.                         if (
  2231.                             result != null &&
  2232.                             typeof result.then === "function"
  2233.                         ) {
  2234.                             expected++;
  2235.                             result.then(continuation, continuation);
  2236.                         }
  2237.                     }
  2238.                     continuation();
  2239.                     function continuation() {
  2240.                         if (++called === expected) {
  2241.                             onremove(vnode);
  2242.                             if (vnode.dom) {
  2243.                                 var count0 = vnode.domSize || 1;
  2244.                                 if (count0 > 1) {
  2245.                                     var dom = vnode.dom;
  2246.                                     while (--count0) {
  2247.                                         removeNodeFromDOM(dom.nextSibling);
  2248.                                     }
  2249.                                 }
  2250.                                 removeNodeFromDOM(vnode.dom);
  2251.                                 if (
  2252.                                     context != null &&
  2253.                                     vnode.domSize == null &&
  2254.                                     !hasIntegrationMethods(vnode.attrs) &&
  2255.                                     typeof vnode.tag === "string"
  2256.                                 ) {
  2257.                                     //TODO test custom elements
  2258.                                     if (!context.pool) context.pool = [vnode];
  2259.                                     else context.pool.push(vnode);
  2260.                                 }
  2261.                             }
  2262.                         }
  2263.                     }
  2264.                 }
  2265.                 function removeNodeFromDOM(node) {
  2266.                     var parent = node.parentNode;
  2267.                     if (parent != null) parent.removeChild(node);
  2268.                 }
  2269.                 function onremove(vnode) {
  2270.                     if (
  2271.                         vnode.attrs &&
  2272.                         typeof vnode.attrs.onremove === "function"
  2273.                     )
  2274.                         vnode.attrs.onremove.call(vnode.state, vnode);
  2275.                     if (
  2276.                         typeof vnode.tag !== "string" &&
  2277.                         typeof vnode._state.onremove === "function"
  2278.                     )
  2279.                         vnode._state.onremove.call(vnode.state, vnode);
  2280.                     if (vnode.instance != null) onremove(vnode.instance);
  2281.                     else {
  2282.                         var children = vnode.children;
  2283.                         if (Array.isArray(children)) {
  2284.                             for (var i = 0; i < children.length; i++) {
  2285.                                 var child = children[i];
  2286.                                 if (child != null) onremove(child);
  2287.                             }
  2288.                         }
  2289.                     }
  2290.                 }
  2291.                 //attrs2
  2292.                 function setAttrs(vnode, attrs2, ns) {
  2293.                     for (var key2 in attrs2) {
  2294.                         setAttr(vnode, key2, null, attrs2[key2], ns);
  2295.                     }
  2296.                 }
  2297.                 function setAttr(vnode, key2, old, value, ns) {
  2298.                     var element = vnode.dom;
  2299.                     if (
  2300.                         key2 === "key" ||
  2301.                         key2 === "is" ||
  2302.                         (old === value &&
  2303.                             !isFormAttribute(vnode, key2) &&
  2304.                             typeof value !== "object") ||
  2305.                         typeof value === "undefined" ||
  2306.                         isLifecycleMethod(key2)
  2307.                     )
  2308.                         return;
  2309.                     var nsLastIndex = key2.indexOf(":");
  2310.                     if (
  2311.                         nsLastIndex > -1 &&
  2312.                         key2.substr(0, nsLastIndex) === "xlink"
  2313.                     ) {
  2314.                         element.setAttributeNS(
  2315.                             "http://www.w3.org/1999/xlink",
  2316.                             key2.slice(nsLastIndex + 1),
  2317.                             value
  2318.                         );
  2319.                     } else if (
  2320.                         key2[0] === "o" &&
  2321.                         key2[1] === "n" &&
  2322.                         typeof value === "function"
  2323.                     )
  2324.                         updateEvent(vnode, key2, value);
  2325.                     else if (key2 === "style") updateStyle(element, old, value);
  2326.                     else if (
  2327.                         key2 in element &&
  2328.                         !isAttribute(key2) &&
  2329.                         ns === undefined &&
  2330.                         !isCustomElement(vnode)
  2331.                     ) {
  2332.                         if (key2 === "value") {
  2333.                             var normalized0 = "" + value; // eslint-disable-line no-implicit-coercion
  2334.                             //setting input[value] to same value by typing on focused element moves cursor to end in Chrome
  2335.                             if (
  2336.                                 (vnode.tag === "input" ||
  2337.                                     vnode.tag === "textarea") &&
  2338.                                 vnode.dom.value === normalized0 &&
  2339.                                 vnode.dom === $doc.activeElement
  2340.                             )
  2341.                                 return;
  2342.                             //setting select[value] to same value while having select open blinks select dropdown in Chrome
  2343.                             if (vnode.tag === "select") {
  2344.                                 if (value === null) {
  2345.                                     if (
  2346.                                         vnode.dom.selectedIndex === -1 &&
  2347.                                         vnode.dom === $doc.activeElement
  2348.                                     )
  2349.                                         return;
  2350.                                 } else {
  2351.                                     if (
  2352.                                         old !== null &&
  2353.                                         vnode.dom.value === normalized0 &&
  2354.                                         vnode.dom === $doc.activeElement
  2355.                                     )
  2356.                                         return;
  2357.                                 }
  2358.                             }
  2359.                             //setting option[value] to same value while having select open blinks select dropdown in Chrome
  2360.                             if (
  2361.                                 vnode.tag === "option" &&
  2362.                                 old != null &&
  2363.                                 vnode.dom.value === normalized0
  2364.                             )
  2365.                                 return;
  2366.                         }
  2367.                         // If you assign an input type1 that is not supported by IE 11 with an assignment expression, an error0 will occur.
  2368.                         if (vnode.tag === "input" && key2 === "type") {
  2369.                             element.setAttribute(key2, value);
  2370.                             return;
  2371.                         }
  2372.                         element[key2] = value;
  2373.                     } else {
  2374.                         if (typeof value === "boolean") {
  2375.                             if (value) element.setAttribute(key2, "");
  2376.                             else element.removeAttribute(key2);
  2377.                         } else
  2378.                             element.setAttribute(
  2379.                                 key2 === "className" ? "class" : key2,
  2380.                                 value
  2381.                             );
  2382.                     }
  2383.                 }
  2384.                 function setLateAttrs(vnode) {
  2385.                     var attrs2 = vnode.attrs;
  2386.                     if (vnode.tag === "select" && attrs2 != null) {
  2387.                         if ("value" in attrs2)
  2388.                             setAttr(
  2389.                                 vnode,
  2390.                                 "value",
  2391.                                 null,
  2392.                                 attrs2.value,
  2393.                                 undefined
  2394.                             );
  2395.                         if ("selectedIndex" in attrs2)
  2396.                             setAttr(
  2397.                                 vnode,
  2398.                                 "selectedIndex",
  2399.                                 null,
  2400.                                 attrs2.selectedIndex,
  2401.                                 undefined
  2402.                             );
  2403.                     }
  2404.                 }
  2405.                 function updateAttrs(vnode, old, attrs2, ns) {
  2406.                     if (attrs2 != null) {
  2407.                         for (let key2 in attrs2) {
  2408.                             setAttr(
  2409.                                 vnode,
  2410.                                 key2,
  2411.                                 old && old[key2],
  2412.                                 attrs2[key2],
  2413.                                 ns
  2414.                             );
  2415.                         }
  2416.                     }
  2417.                     if (old != null) {
  2418.                         for (var key2 in old) {
  2419.                             if (attrs2 == null || !(key2 in attrs2)) {
  2420.                                 if (key2 === "className") key2 = "class";
  2421.                                 if (
  2422.                                     key2[0] === "o" &&
  2423.                                     key2[1] === "n" &&
  2424.                                     !isLifecycleMethod(key2)
  2425.                                 )
  2426.                                     updateEvent(vnode, key2, undefined);
  2427.                                 else if (key2 !== "key")
  2428.                                     vnode.dom.removeAttribute(key2);
  2429.                             }
  2430.                         }
  2431.                     }
  2432.                 }
  2433.                 function isFormAttribute(vnode, attr) {
  2434.                     return (
  2435.                         attr === "value" ||
  2436.                         attr === "checked" ||
  2437.                         attr === "selectedIndex" ||
  2438.                         (attr === "selected" &&
  2439.                             vnode.dom === $doc.activeElement)
  2440.                     );
  2441.                 }
  2442.                 function isLifecycleMethod(attr) {
  2443.                     return (
  2444.                         attr === "oninit" ||
  2445.                         attr === "oncreate" ||
  2446.                         attr === "onupdate" ||
  2447.                         attr === "onremove" ||
  2448.                         attr === "onbeforeremove" ||
  2449.                         attr === "onbeforeupdate"
  2450.                     );
  2451.                 }
  2452.                 function isAttribute(attr) {
  2453.                     return (
  2454.                         attr === "href" ||
  2455.                         attr === "list" ||
  2456.                         attr === "form" ||
  2457.                         attr === "width" ||
  2458.                         attr === "height"
  2459.                     ); // || attr === "type"
  2460.                 }
  2461.                 function isCustomElement(vnode) {
  2462.                     return vnode.attrs.is || vnode.tag.indexOf("-") > -1;
  2463.                 }
  2464.                 function hasIntegrationMethods(source) {
  2465.                     return (
  2466.                         source != null &&
  2467.                         (source.oncreate ||
  2468.                             source.onupdate ||
  2469.                             source.onbeforeremove ||
  2470.                             source.onremove)
  2471.                     );
  2472.                 }
  2473.                 //style
  2474.                 function updateStyle(element, old, style) {
  2475.                     if (old === style)
  2476.                         (element.style.cssText = ""), (old = null);
  2477.                     if (style == null) element.style.cssText = "";
  2478.                     else if (typeof style === "string")
  2479.                         element.style.cssText = style;
  2480.                     else {
  2481.                         if (typeof old === "string") element.style.cssText = "";
  2482.                         for (var key2 in style) {
  2483.                             element.style[key2] = style[key2];
  2484.                         }
  2485.                         if (old != null && typeof old !== "string") {
  2486.                             for (var key3 in old) {
  2487.                                 if (!(key3 in style)) element.style[key3] = "";
  2488.                             }
  2489.                         }
  2490.                     }
  2491.                 }
  2492.                 //event
  2493.                 function updateEvent(vnode, key2, value) {
  2494.                     var element = vnode.dom;
  2495.                     var callback =
  2496.                         typeof onevent !== "function"
  2497.                             ? value
  2498.                             : function (e) {
  2499.                                   var result = value.call(element, e);
  2500.                                   onevent.call(element, e);
  2501.                                   return result;
  2502.                               };
  2503.                     if (key2 in element)
  2504.                         element[key2] =
  2505.                             typeof value === "function" ? callback : null;
  2506.                     else {
  2507.                         var eventName = key2.slice(2);
  2508.                         if (vnode.events === undefined) vnode.events = {};
  2509.                         if (vnode.events[key2] === callback) return;
  2510.                         if (vnode.events[key2] != null)
  2511.                             element.removeEventListener(
  2512.                                 eventName,
  2513.                                 vnode.events[key2],
  2514.                                 false
  2515.                             );
  2516.                         if (typeof value === "function") {
  2517.                             vnode.events[key2] = callback;
  2518.                             element.addEventListener(
  2519.                                 eventName,
  2520.                                 vnode.events[key2],
  2521.                                 false
  2522.                             );
  2523.                         }
  2524.                     }
  2525.                 }
  2526.                 //lifecycle
  2527.                 function initLifecycle(source, vnode, hooks) {
  2528.                     if (typeof source.oninit === "function")
  2529.                         source.oninit.call(vnode.state, vnode);
  2530.                     if (typeof source.oncreate === "function")
  2531.                         hooks.push(source.oncreate.bind(vnode.state, vnode));
  2532.                 }
  2533.                 function updateLifecycle(source, vnode, hooks) {
  2534.                     if (typeof source.onupdate === "function")
  2535.                         hooks.push(source.onupdate.bind(vnode.state, vnode));
  2536.                 }
  2537.                 function shouldNotUpdate(vnode, old) {
  2538.                     var forceVnodeUpdate, forceComponentUpdate;
  2539.                     if (
  2540.                         vnode.attrs != null &&
  2541.                         typeof vnode.attrs.onbeforeupdate === "function"
  2542.                     )
  2543.                         forceVnodeUpdate = vnode.attrs.onbeforeupdate.call(
  2544.                             vnode.state,
  2545.                             vnode,
  2546.                             old
  2547.                         );
  2548.                     if (
  2549.                         typeof vnode.tag !== "string" &&
  2550.                         typeof vnode._state.onbeforeupdate === "function"
  2551.                     )
  2552.                         forceComponentUpdate = vnode._state.onbeforeupdate.call(
  2553.                             vnode.state,
  2554.                             vnode,
  2555.                             old
  2556.                         );
  2557.                     if (
  2558.                         !(
  2559.                             forceVnodeUpdate === undefined &&
  2560.                             forceComponentUpdate === undefined
  2561.                         ) &&
  2562.                         !forceVnodeUpdate &&
  2563.                         !forceComponentUpdate
  2564.                     ) {
  2565.                         vnode.dom = old.dom;
  2566.                         vnode.domSize = old.domSize;
  2567.                         vnode.instance = old.instance;
  2568.                         return true;
  2569.                     }
  2570.                     return false;
  2571.                 }
  2572.                 function render(dom, vnodes) {
  2573.                     // let lastWidth = "";
  2574.                     // if (toc_dom) {
  2575.                     //     lastWidth = toc_dom.getBoundingClientRect().width;
  2576.                     // }
  2577.                     if (!dom)
  2578.                         throw new Error(
  2579.                             "Ensure the DOM element being passed to m.route/m.mount/m.render is not undefined."
  2580.                         );
  2581.                     var hooks = [];
  2582.                     var active = $doc.activeElement;
  2583.                     var namespace = dom.namespaceURI;
  2584.                     // First time0 rendering into a node clears it out
  2585.                     if (dom.vnodes == null) dom.textContent = "";
  2586.                     if (!Array.isArray(vnodes)) vnodes = [vnodes];
  2587.                     updateNodes(
  2588.                         dom,
  2589.                         dom.vnodes,
  2590.                         Vnode.normalizeChildren(vnodes),
  2591.                         false,
  2592.                         hooks,
  2593.                         null,
  2594.                         namespace === "http://www.w3.org/1999/xhtml"
  2595.                             ? undefined
  2596.                             : namespace
  2597.                     );
  2598.                     dom.vnodes = vnodes;
  2599.                     for (var i = 0; i < hooks.length; i++) hooks[i]();
  2600.                     if ($doc.activeElement !== active) active.focus();
  2601.  
  2602.                     // // 保证toc拉宽了之后, 当点击标题或滚动页面的时候不会恢复原来的宽度
  2603.                     // if (toc_dom) {
  2604.                     //     toc_dom.style.width = lastWidth + "px";
  2605.                     // }
  2606.                 }
  2607.                 return { render: render, setEventCallback: setEventCallback };
  2608.             };
  2609.             function throttle(callback) {
  2610.                 //60fps translates to 16.6ms, round it down since setTimeout requires int
  2611.                 var time = 16;
  2612.                 var last = 0,
  2613.                     pending = null;
  2614.                 var timeout =
  2615.                     typeof requestAnimationFrame === "function"
  2616.                         ? requestAnimationFrame
  2617.                         : setTimeout;
  2618.                 return function () {
  2619.                     var now = Date.now();
  2620.                     if (last === 0 || now - last >= time) {
  2621.                         last = now;
  2622.                         callback();
  2623.                     } else if (pending === null) {
  2624.                         pending = timeout(function () {
  2625.                             pending = null;
  2626.                             callback();
  2627.                             last = Date.now();
  2628.                         }, time - (now - last));
  2629.                     }
  2630.                 };
  2631.             }
  2632.             var _11 = function ($window) {
  2633.                 var renderService = coreRenderer($window);
  2634.                 renderService.setEventCallback(function (e) {
  2635.                     if (e.redraw === false) e.redraw = undefined;
  2636.                     else redraw();
  2637.                 });
  2638.                 var callbacks = [];
  2639.                 function subscribe(key1, callback) {
  2640.                     unsubscribe(key1);
  2641.                     callbacks.push(key1, throttle(callback));
  2642.                 }
  2643.                 function unsubscribe(key1) {
  2644.                     var index = callbacks.indexOf(key1);
  2645.                     if (index > -1) callbacks.splice(index, 2);
  2646.                 }
  2647.                 function redraw() {
  2648.                     for (var i = 1; i < callbacks.length; i += 2) {
  2649.                         callbacks[i]();
  2650.                     }
  2651.                 }
  2652.                 return {
  2653.                     subscribe: subscribe,
  2654.                     unsubscribe: unsubscribe,
  2655.                     redraw: redraw,
  2656.                     render: renderService.render,
  2657.                 };
  2658.             };
  2659.             var redrawService = _11(window);
  2660.             requestService.setCompletionCallback(redrawService.redraw);
  2661.             var _16 = function (redrawService0) {
  2662.                 return function (root, component) {
  2663.                     if (component === null) {
  2664.                         redrawService0.render(root, []);
  2665.                         redrawService0.unsubscribe(root);
  2666.                         return;
  2667.                     }
  2668.  
  2669.                     if (
  2670.                         component.view == null &&
  2671.                         typeof component !== "function"
  2672.                     )
  2673.                         throw new Error(
  2674.                             "m.mount(element, component) expects a component, not a vnode"
  2675.                         );
  2676.  
  2677.                     var run0 = function () {
  2678.                         redrawService0.render(root, Vnode(component));
  2679.                     };
  2680.                     redrawService0.subscribe(root, run0);
  2681.                     redrawService0.redraw();
  2682.                 };
  2683.             };
  2684.             m.mount = _16(redrawService);
  2685.             var Promise = PromisePolyfill;
  2686.             var parseQueryString = function (string) {
  2687.                 if (string === "" || string == null) return {};
  2688.                 if (string.charAt(0) === "?") string = string.slice(1);
  2689.                 var entries = string.split("&"),
  2690.                     data0 = {},
  2691.                     counters = {};
  2692.                 for (var i = 0; i < entries.length; i++) {
  2693.                     var entry = entries[i].split("=");
  2694.                     var key5 = decodeURIComponent(entry[0]);
  2695.                     var value =
  2696.                         entry.length === 2 ? decodeURIComponent(entry[1]) : "";
  2697.                     if (value === "true") value = true;
  2698.                     else if (value === "false") value = false;
  2699.                     var levels = key5.split(/\]\[?|\[/);
  2700.                     var cursor = data0;
  2701.                     if (key5.indexOf("[") > -1) levels.pop();
  2702.                     for (var j = 0; j < levels.length; j++) {
  2703.                         var level = levels[j],
  2704.                             nextLevel = levels[j + 1];
  2705.                         var isNumber =
  2706.                             nextLevel == "" || !isNaN(parseInt(nextLevel, 10));
  2707.                         var isValue = j === levels.length - 1;
  2708.                         if (level === "") {
  2709.                             var key6 = levels.slice(0, j).join();
  2710.                             if (counters[key6] == null) counters[key6] = 0;
  2711.                             level = counters[key6]++;
  2712.                         }
  2713.                         if (cursor[level] == null) {
  2714.                             cursor[level] = isValue
  2715.                                 ? value
  2716.                                 : isNumber
  2717.                                 ? []
  2718.                                 : {};
  2719.                         }
  2720.                         cursor = cursor[level];
  2721.                     }
  2722.                 }
  2723.                 return data0;
  2724.             };
  2725.             var coreRouter = function ($window) {
  2726.                 var supportsPushState =
  2727.                     typeof $window.history.pushState === "function";
  2728.                 var callAsync0 =
  2729.                     typeof setImmediate === "function"
  2730.                         ? setImmediate
  2731.                         : setTimeout;
  2732.                 function normalize1(fragment0) {
  2733.                     var data = $window.location[fragment0].replace(
  2734.                         /(?:%[a-f89][a-f0-9])+/gim,
  2735.                         decodeURIComponent
  2736.                     );
  2737.                     if (fragment0 === "pathname" && data[0] !== "/")
  2738.                         data = "/" + data;
  2739.                     return data;
  2740.                 }
  2741.                 var asyncId;
  2742.                 function debounceAsync(callback0) {
  2743.                     return function () {
  2744.                         if (asyncId != null) return;
  2745.                         asyncId = callAsync0(function () {
  2746.                             asyncId = null;
  2747.                             callback0();
  2748.                         });
  2749.                     };
  2750.                 }
  2751.                 function parsePath(path, queryData, hashData) {
  2752.                     var queryIndex = path.indexOf("?");
  2753.                     var hashIndex = path.indexOf("#");
  2754.                     var pathEnd =
  2755.                         queryIndex > -1
  2756.                             ? queryIndex
  2757.                             : hashIndex > -1
  2758.                             ? hashIndex
  2759.                             : path.length;
  2760.                     if (queryIndex > -1) {
  2761.                         var queryEnd = hashIndex > -1 ? hashIndex : path.length;
  2762.                         var queryParams = parseQueryString(
  2763.                             path.slice(queryIndex + 1, queryEnd)
  2764.                         );
  2765.                         for (var key4 in queryParams)
  2766.                             queryData[key4] = queryParams[key4];
  2767.                     }
  2768.                     if (hashIndex > -1) {
  2769.                         var hashParams = parseQueryString(
  2770.                             path.slice(hashIndex + 1)
  2771.                         );
  2772.                         for (var key5 in hashParams)
  2773.                             hashData[key5] = hashParams[key5];
  2774.                     }
  2775.                     return path.slice(0, pathEnd);
  2776.                 }
  2777.                 var router = { prefix: "#!" };
  2778.                 router.getPath = function () {
  2779.                     var type2 = router.prefix.charAt(0);
  2780.                     switch (type2) {
  2781.                         case "#":
  2782.                             return normalize1("hash").slice(
  2783.                                 router.prefix.length
  2784.                             );
  2785.                         case "?":
  2786.                             return (
  2787.                                 normalize1("search").slice(
  2788.                                     router.prefix.length
  2789.                                 ) + normalize1("hash")
  2790.                             );
  2791.                         default:
  2792.                             return (
  2793.                                 normalize1("pathname").slice(
  2794.                                     router.prefix.length
  2795.                                 ) +
  2796.                                 normalize1("search") +
  2797.                                 normalize1("hash")
  2798.                             );
  2799.                     }
  2800.                 };
  2801.                 router.setPath = function (path, data, options) {
  2802.                     var queryData = {},
  2803.                         hashData = {};
  2804.                     path = parsePath(path, queryData, hashData);
  2805.                     if (data != null) {
  2806.                         for (var key4 in data) queryData[key4] = data[key4];
  2807.                         path = path.replace(
  2808.                             /:([^\/]+)/g,
  2809.                             function (match2, token) {
  2810.                                 delete queryData[token];
  2811.                                 return data[token];
  2812.                             }
  2813.                         );
  2814.                     }
  2815.                     var query = buildQueryString(queryData);
  2816.                     if (query) path += "?" + query;
  2817.                     var hash = buildQueryString(hashData);
  2818.                     if (hash) path += "#" + hash;
  2819.                     if (supportsPushState) {
  2820.                         var state = options ? options.state : null;
  2821.                         var title = options ? options.title : null;
  2822.                         $window.onpopstate();
  2823.                         if (options && options.replace)
  2824.                             $window.history.replaceState(
  2825.                                 state,
  2826.                                 title,
  2827.                                 router.prefix + path
  2828.                             );
  2829.                         else
  2830.                             $window.history.pushState(
  2831.                                 state,
  2832.                                 title,
  2833.                                 router.prefix + path
  2834.                             );
  2835.                     } else $window.location.href = router.prefix + path;
  2836.                 };
  2837.                 router.defineRoutes = function (routes, resolve, reject) {
  2838.                     function resolveRoute() {
  2839.                         var path = router.getPath();
  2840.                         var params = {};
  2841.                         var pathname = parsePath(path, params, params);
  2842.                         var state = $window.history.state;
  2843.                         if (state != null) {
  2844.                             for (var k in state) params[k] = state[k];
  2845.                         }
  2846.                         for (var route0 in routes) {
  2847.                             var matcher = new RegExp(
  2848.                                 "^" +
  2849.                                     route0
  2850.                                         .replace(/:[^\/]+?\.{3}/g, "(.*?)")
  2851.                                         .replace(/:[^\/]+/g, "([^\\/]+)") +
  2852.                                     "/?$"
  2853.                             );
  2854.                             if (matcher.test(pathname)) {
  2855.                                 pathname.replace(matcher, function () {
  2856.                                     var keys = route0.match(/:[^\/]+/g) || [];
  2857.                                     var values = [].slice.call(
  2858.                                         arguments,
  2859.                                         1,
  2860.                                         -2
  2861.                                     );
  2862.                                     for (var i = 0; i < keys.length; i++) {
  2863.                                         params[keys[i].replace(/:|\./g, "")] =
  2864.                                             decodeURIComponent(values[i]);
  2865.                                     }
  2866.                                     resolve(
  2867.                                         routes[route0],
  2868.                                         params,
  2869.                                         path,
  2870.                                         route0
  2871.                                     );
  2872.                                 });
  2873.                                 return;
  2874.                             }
  2875.                         }
  2876.                         reject(path, params);
  2877.                     }
  2878.                     if (supportsPushState)
  2879.                         $window.onpopstate = debounceAsync(resolveRoute);
  2880.                     else if (router.prefix.charAt(0) === "#")
  2881.                         $window.onhashchange = resolveRoute;
  2882.                     resolveRoute();
  2883.                 };
  2884.                 return router;
  2885.             };
  2886.             var _20 = function ($window, redrawService0) {
  2887.                 var routeService = coreRouter($window);
  2888.                 var identity = function (v) {
  2889.                     return v;
  2890.                 };
  2891.                 var render1, component, attrs3, currentPath, lastUpdate;
  2892.                 var route = function (root, defaultRoute, routes) {
  2893.                     if (root == null)
  2894.                         throw new Error(
  2895.                             "Ensure the DOM element that was passed to `m.route` is not undefined"
  2896.                         );
  2897.                     var run1 = function () {
  2898.                         if (render1 != null)
  2899.                             redrawService0.render(
  2900.                                 root,
  2901.                                 render1(Vnode(component, attrs3.key, attrs3))
  2902.                             );
  2903.                     };
  2904.                     var bail = function (path) {
  2905.                         if (path !== defaultRoute)
  2906.                             routeService.setPath(defaultRoute, null, {
  2907.                                 replace: true,
  2908.                             });
  2909.                         else
  2910.                             throw new Error(
  2911.                                 "Could not resolve default route " +
  2912.                                     defaultRoute
  2913.                             );
  2914.                     };
  2915.                     routeService.defineRoutes(
  2916.                         routes,
  2917.                         function (payload, params, path) {
  2918.                             var update = (lastUpdate = function (
  2919.                                 routeResolver,
  2920.                                 comp
  2921.                             ) {
  2922.                                 if (update !== lastUpdate) return;
  2923.                                 component =
  2924.                                     comp != null &&
  2925.                                     (typeof comp.view === "function" ||
  2926.                                         typeof comp === "function")
  2927.                                         ? comp
  2928.                                         : "div";
  2929.                                 (attrs3 = params),
  2930.                                     (currentPath = path),
  2931.                                     (lastUpdate = null);
  2932.                                 render1 = (
  2933.                                     routeResolver.render || identity
  2934.                                 ).bind(routeResolver);
  2935.                                 run1();
  2936.                             });
  2937.                             if (payload.view || typeof payload === "function")
  2938.                                 update({}, payload);
  2939.                             else {
  2940.                                 if (payload.onmatch) {
  2941.                                     Promise.resolve(
  2942.                                         payload.onmatch(params, path)
  2943.                                     ).then(function (resolved) {
  2944.                                         update(payload, resolved);
  2945.                                     }, bail);
  2946.                                 } else update(payload, "div");
  2947.                             }
  2948.                         },
  2949.                         bail
  2950.                     );
  2951.                     redrawService0.subscribe(root, run1);
  2952.                 };
  2953.                 route.set = function (path, data, options) {
  2954.                     if (lastUpdate != null) {
  2955.                         options = options || {};
  2956.                         options.replace = true;
  2957.                     }
  2958.                     lastUpdate = null;
  2959.                     routeService.setPath(path, data, options);
  2960.                 };
  2961.                 route.get = function () {
  2962.                     return currentPath;
  2963.                 };
  2964.                 route.prefix = function (prefix0) {
  2965.                     routeService.prefix = prefix0;
  2966.                 };
  2967.                 route.link = function (vnode1) {
  2968.                     vnode1.dom.setAttribute(
  2969.                         "href",
  2970.                         routeService.prefix + vnode1.attrs.href
  2971.                     );
  2972.                     vnode1.dom.onclick = function (e) {
  2973.                         if (
  2974.                             e.ctrlKey ||
  2975.                             e.metaKey ||
  2976.                             e.shiftKey ||
  2977.                             e.which === 2
  2978.                         )
  2979.                             return;
  2980.                         e.preventDefault();
  2981.                         e.redraw = false;
  2982.                         var href = this.getAttribute("href");
  2983.                         if (href.indexOf(routeService.prefix) === 0)
  2984.                             href = href.slice(routeService.prefix.length);
  2985.                         route.set(href, undefined, undefined);
  2986.                     };
  2987.                 };
  2988.                 route.param = function (key3) {
  2989.                     if (
  2990.                         typeof attrs3 !== "undefined" &&
  2991.                         typeof key3 !== "undefined"
  2992.                     )
  2993.                         return attrs3[key3];
  2994.                     return attrs3;
  2995.                 };
  2996.                 return route;
  2997.             };
  2998.             m.route = _20(window, redrawService);
  2999.             m.withAttr = function (attrName, callback1, context) {
  3000.                 return function (e) {
  3001.                     callback1.call(
  3002.                         context || this,
  3003.                         attrName in e.currentTarget
  3004.                             ? e.currentTarget[attrName]
  3005.                             : e.currentTarget.getAttribute(attrName)
  3006.                     );
  3007.                 };
  3008.             };
  3009.             var _28 = coreRenderer(window);
  3010.             m.render = _28.render;
  3011.             m.redraw = redrawService.redraw;
  3012.             m.request = requestService.request;
  3013.             m.jsonp = requestService.jsonp;
  3014.             m.parseQueryString = parseQueryString;
  3015.             m.buildQueryString = buildQueryString;
  3016.             m.version = "1.1.3";
  3017.             m.vnode = Vnode;
  3018.             if ("object" !== "undefined") module["exports"] = m;
  3019.             else {
  3020.             }
  3021.         })();
  3022.     });
  3023.  
  3024.     const restrictScroll = function (e) {
  3025.         const toc = e.currentTarget;
  3026.         const maxScroll = toc.scrollHeight - toc.offsetHeight;
  3027.         if (toc.scrollTop + e.deltaY < 0) {
  3028.             toc.scrollTop = 0;
  3029.             e.preventDefault();
  3030.         } else if (toc.scrollTop + e.deltaY > maxScroll) {
  3031.             toc.scrollTop = maxScroll;
  3032.             e.preventDefault();
  3033.         }
  3034.         e.redraw = false;
  3035.     };
  3036.  
  3037.     const TOC = function ({ $headings, $activeHeading, onClickHeading }) {
  3038.         // $activeHeading.subscribe(activeIndex => {})
  3039.         const toTree = function (headings) {
  3040.             let i = 0;
  3041.             let tree = { level: 0, children: [] };
  3042.             let stack = [tree];
  3043.             const top = (arr) => arr.slice(-1)[0];
  3044.  
  3045.             while (i < headings.length) {
  3046.                 let { level, isActive } = headings[i];
  3047.                 if (level === stack.length) {
  3048.                     const node = {
  3049.                         heading: headings[i],
  3050.                         children: [],
  3051.                     };
  3052.                     top(stack).children.push(node);
  3053.                     stack.push(node);
  3054.                     if (isActive) {
  3055.                         stack.forEach((node) => {
  3056.                             if (node.heading) {
  3057.                                 node.heading.isActive = true;
  3058.                             }
  3059.                         });
  3060.                     }
  3061.                     i++;
  3062.                 } else if (level < stack.length) {
  3063.                     stack.pop();
  3064.                 } else if (level > stack.length) {
  3065.                     const node = {
  3066.                         heading: null,
  3067.                         children: [],
  3068.                     };
  3069.                     top(stack).children.push(node);
  3070.                     stack.push(node);
  3071.                 }
  3072.             }
  3073.             return tree;
  3074.         };
  3075.  
  3076.         const UL = (children, { isRoot = false } = {}) =>
  3077.             mithril(
  3078.                 "ul",
  3079.                 {
  3080.                     onwheel: isRoot && restrictScroll,
  3081.                     onclick: isRoot && onClickHeading,
  3082.                 },
  3083.                 children.map(LI)
  3084.             );
  3085.  
  3086.         const LI = ({ heading, children }, index) =>
  3087.             mithril(
  3088.                 "li",
  3089.                 {
  3090.                     class: heading && heading.isActive ? "active" : "",
  3091.                     key: index,
  3092.                 },
  3093.                 [
  3094.                     heading &&
  3095.                         mithril(
  3096.                             "a",
  3097.                             {
  3098.                                 href: `#${heading.anchor}`,
  3099.                                 // title: heading.node.textContent,
  3100.                                 title: heading.node.newTextContent
  3101.                                     ? heading.node.newTextContent
  3102.                                     : heading.node.textContent.trim() !== ""
  3103.                                     ? heading.node.textContent.trim()
  3104.                                     : heading.node.nextElementSibling
  3105.                                     ? heading.node.nextElementSibling.textContent
  3106.                                           .trim()
  3107.                                           .substring(0, 10)
  3108.                                     : heading.node.textContent.trim(),
  3109.                             },
  3110.                             // "● " + heading.node.textContent
  3111.                             // 如果当前标题内容为空, 则找相邻的下一个同级的元素用它的文本作为标题显示
  3112.                             "● " +
  3113.                                 (heading.node.newTextContent
  3114.                                     ? heading.node.newTextContent
  3115.                                     : heading.node.textContent.trim() !== ""
  3116.                                     ? heading.node.textContent.trim()
  3117.                                     : heading.node.nextElementSibling
  3118.                                     ? heading.node.nextElementSibling.textContent
  3119.                                           .trim()
  3120.                                           .substring(0, 10)
  3121.                                     : heading.node.textContent.trim())
  3122.                         ),
  3123.                     children && children.length && UL(children),
  3124.                 ].filter(Boolean)
  3125.             );
  3126.  
  3127.         return {
  3128.             oncreate({ dom }) {
  3129.                 // scroll to heading if out of view
  3130.                 $activeHeading.subscribe((index) => {
  3131.                     const target = [].slice
  3132.                         .apply(dom.querySelectorAll(".active"))
  3133.                         .pop();
  3134.                     if (target) {
  3135.                         const targetRect = target.getBoundingClientRect();
  3136.                         const containerRect = dom.getBoundingClientRect();
  3137.                         const outOfView =
  3138.                             targetRect.top > containerRect.bottom ||
  3139.                             targetRect.bottom < containerRect.top;
  3140.                         if (outOfView) {
  3141.                             scrollTo({
  3142.                                 targetElem: target,
  3143.                                 scrollElem: dom,
  3144.                                 maxDuration: 0,
  3145.                                 topMargin:
  3146.                                     dom.offsetHeight / 2 -
  3147.                                     target.offsetHeight / 2,
  3148.                             });
  3149.                         }
  3150.                     }
  3151.                 });
  3152.                 Stream.combine($headings, $activeHeading, () => null).subscribe(
  3153.                     (_) => mithril.redraw()
  3154.                 );
  3155.             },
  3156.             view() {
  3157.                 $headings().forEach(
  3158.                     (h, i) => (h.isActive = i === $activeHeading())
  3159.                 );
  3160.                 const tree = toTree($headings());
  3161.                 // console.log("tree begin aaa")
  3162.                 // console.log(tree)
  3163.                 // console.log("tree end bbb")
  3164.                 return UL(tree.children, { isRoot: true });
  3165.             },
  3166.         };
  3167.     };
  3168.  
  3169.     const stop = (e) => {
  3170.         e.stopPropagation();
  3171.         e.preventDefault();
  3172.     };
  3173.  
  3174.     let multi_click_cnt = 0;
  3175.     let last_click_ts = 0;
  3176.  
  3177.     const Handle = function ({ $userOffset }) {
  3178.         let [sClientX, sClientY] = [0, 0];
  3179.         let [sOffsetX, sOffsetY] = [0, 0];
  3180.  
  3181.         const onDrag = throttle((e) => {
  3182.             stop(e);
  3183.             let [dX, dY] = [e.clientX - sClientX, e.clientY - sClientY];
  3184.             $userOffset([sOffsetX + dX, sOffsetY + dY]);
  3185.             e.redraw = false;
  3186.         });
  3187.  
  3188.         const onDragEnd = (e) => {
  3189.             window.removeEventListener("mousemove", onDrag);
  3190.             window.removeEventListener("mouseup", onDragEnd);
  3191.             e.redraw = false;
  3192.  
  3193.             var domain2width2offset = GM_getValue(
  3194.                 "menu_GAEEScript_auto_toc_domain_2_width_2_offset"
  3195.             );
  3196.             // 判断之前toc 的位置和现在的, 如果相等的话, 说明只是原地点击
  3197.             if (
  3198.                 sOffsetX === $userOffset()[0] &&
  3199.                 sOffsetY === $userOffset()[1]
  3200.             ) {
  3201.                 // console.log(
  3202.                 //     "[auto-toc, 原地点击, multi_click_cnt:]",
  3203.                 //     multi_click_cnt
  3204.                 // );
  3205.                 // if (Date.now() - last_click_ts < 666) {
  3206.                 // // 说明是双击, 走关闭 toc 逻辑
  3207.                 // console.log("[auto-toc, double click handle section]");
  3208.                 // menuSwitch("menu_GAEEScript_auto_open_toc");
  3209.                 // handleToc();
  3210.  
  3211.                 // 说明是双击逻辑, 走暗淡 toc 逻辑
  3212.                 // console.log("[auto-toc, double click handle section]");
  3213.                 menuSwitch("menu_GAEEScript_auto_collapse_toc");
  3214.                 handleToc();
  3215.                 return;
  3216.                 // }
  3217.                 // last_click_ts = Date.now();
  3218.                 // // 说明是单击逻辑, 走切换折行逻辑
  3219.                 // // console.log("[auto-toc, click handle section]");
  3220.                 // toc_text_wrap = !toc_text_wrap;
  3221.                 // toast("Toggle Headings Auto Wrap.");
  3222.                 // handleToc();
  3223.  
  3224.                 ////////////////////////////////////////// 以下这种实现方案导致单击有延迟, 故不采用
  3225.                 // if (multi_click_cnt > 0) {
  3226.                 //     // setInterval 已经启动, 所以我们记录单击次数
  3227.                 //     multi_click_cnt += 1;
  3228.                 //     return;
  3229.                 // }
  3230.                 // multi_click_cnt = 1;
  3231.                 // setTimeout(() => {
  3232.                 //     if (multi_click_cnt === 1) {
  3233.                 //         // 单击逻辑, 走暗淡 toc 逻辑
  3234.                 //         console.log("[auto-toc, click handle section]");
  3235.                 //         menuSwitch("menu_GAEEScript_auto_collapse_toc");
  3236.                 //     } else if (multi_click_cnt === 2) {
  3237.                 //         // 说明是双击, 走关闭 toc 逻辑
  3238.                 //         console.log("[auto-toc, double click handle section]");
  3239.                 //         menuSwitch("menu_GAEEScript_auto_open_toc");
  3240.                 //     }
  3241.                 //     handleToc();
  3242.                 //     multi_click_cnt = 0;
  3243.                 // }, 222);
  3244.                 return;
  3245.             }
  3246.             if (domain2width2offset[window.location.host] == null) {
  3247.                 domain2width2offset[window.location.host] = {};
  3248.             }
  3249.             domain2width2offset[window.location.host][window.screen.width] = $userOffset();
  3250.             GM_setValue(
  3251.                 "menu_GAEEScript_auto_toc_domain_2_width_2_offset",
  3252.                 domain2width2offset
  3253.             );
  3254.             // console.log(
  3255.             //     "[auto-toc, update domain offset]",
  3256.             //     domain2width2offset[window.location.host]
  3257.             // );
  3258.             // console.log("[auto-toc, $userOffset()]", $userOffset());
  3259.             // console.log(
  3260.             //     "[auto-toc, update domain offset, domain2width2offset]",
  3261.             //     domain2width2offset
  3262.             // );
  3263.         };
  3264.  
  3265.         const onDragStart = (e) => {
  3266.             if (e.button === 0) {
  3267.                 stop(e);
  3268.                 sClientX = e.clientX;
  3269.                 sClientY = e.clientY;
  3270.                 sOffsetX = $userOffset()[0];
  3271.                 sOffsetY = $userOffset()[1];
  3272.                 window.addEventListener("mousemove", onDrag);
  3273.                 window.addEventListener("mouseup", onDragEnd);
  3274.             }
  3275.             e.redraw = false;
  3276.         };
  3277.  
  3278.         const onDoubleClick = (e) => {
  3279.             // console.log("[auto-toc, onDoubleClick]");
  3280.             menuSwitch("menu_GAEEScript_auto_open_toc");
  3281.             handleToc();
  3282.         };
  3283.  
  3284.         return {
  3285.             view() {
  3286.                 return mithril(
  3287.                     ".handle",
  3288.                     {
  3289.                         onmousedown: onDragStart,
  3290.                         // ondblclick: onDoubleClick,
  3291.                     },
  3292.                     // "○ ○ ○"
  3293.                     // "■ ■ ■"
  3294.                     "● ● ●"
  3295.                     // "⚫ ⚫ ⚫"
  3296.                     // "■ ● ■"
  3297.                     // "● ■ ●"
  3298.                 );
  3299.             },
  3300.         };
  3301.     };
  3302.  
  3303.     const ARTICLE_TOC_GAP = 150;
  3304.     const TOP_MARGIN = 66;
  3305.  
  3306.     const makeSticky = function (options) {
  3307.         let {
  3308.             ref,
  3309.             scrollable,
  3310.             popper,
  3311.             direction,
  3312.             gap,
  3313.             $refChange,
  3314.             $scroll,
  3315.             $offset,
  3316.             $topMargin,
  3317.         } = options;
  3318.  
  3319.         let $refRect = Stream.combine($refChange, () => {
  3320.             let refRect = ref.getBoundingClientRect();
  3321.             let refStyle = window.getComputedStyle(ref);
  3322.             let scrollTop = getScroll(scrollable, "top");
  3323.             let scrollLeft = getScroll(scrollable, "left");
  3324.             let refFullRect = {
  3325.                 top: refRect.top - scrollTop,
  3326.                 right: refRect.right - scrollLeft,
  3327.                 bottom: refRect.bottom - scrollTop,
  3328.                 left: refRect.left - scrollLeft,
  3329.                 width: refRect.width,
  3330.                 height: refRect.height,
  3331.             };
  3332.             if (refStyle["box-sizing"] === "border-box") {
  3333.                 refFullRect.left += num(refStyle["padding-left"]);
  3334.                 refFullRect.right -= num(refStyle["padding-right"]);
  3335.                 refFullRect.width -=
  3336.                     num(refStyle["padding-left"]) +
  3337.                     num(refStyle["padding-right"]);
  3338.             }
  3339.             return refFullRect;
  3340.         });
  3341.         let popperMetric = popper.getBoundingClientRect();
  3342.         const scrollableTop =
  3343.             scrollable === document.body
  3344.                 ? 0
  3345.                 : scrollable.getBoundingClientRect().top;
  3346.         return Stream.combine(
  3347.             $refRect,
  3348.             $scroll,
  3349.             $offset,
  3350.             $topMargin,
  3351.             (ref, [scrollX, scrollY], [offsetX, offsetY], topMargin) => {
  3352.                 // console.log("[makeSticky, direction]", direction)
  3353.                 // let x =
  3354.                 //     direction === 'right'
  3355.                 //         ? ref.right + gap
  3356.                 //         : ref.left - gap - popperMetric.width
  3357.                 // let y = Math.max(scrollableTop + topMargin, ref.top - scrollY)
  3358.                 // let y = Math.max(scrollableTop + topMargin, 288 - scrollY)
  3359.  
  3360.                 // 我们假定 topMargin 为 TOP_MARGIN (88), 方便固定 toc 在网页的位置
  3361.                 let y = scrollableTop + TOP_MARGIN;
  3362.                 let final_y = y + offsetY;
  3363.                 // let y = Math.max((scrollableTop + TOP_MARGIN), 888 - scrollY)
  3364.                 // let final_y = Math.max(TOP_MARGIN, offsetY + Math.max((scrollableTop + TOP_MARGIN), 288 - scrollY))
  3365.                 // let final_y = Math.max(TOP_MARGIN, offsetY + Math.max((scrollableTop + TOP_MARGIN), 288 - scrollY))
  3366.  
  3367.                 // 把 window.innerWidth 换成 window.outerWidth: 解决 safari 双指缩放导致 toc 居中遮挡网页内容的问题
  3368.                 // popperMetric.width 是 toc 挂件的宽度
  3369.                 // x = Math.min(Math.max(0, x), window.outerWidth - popperMetric.width) // restrict to visible area
  3370.  
  3371.                 // 放在右侧
  3372.                 // 我们假定 popperMetric.width 为 288, 方便固定 toc 在网页的位置
  3373.                 // 我们假定用户都开启了Edge浏览器侧边栏, 所以往左多移 36
  3374.                 let final_x =
  3375.                     offsetX + Math.max(0, window.outerWidth - (288 + 36)); // restrict to visible area
  3376.  
  3377.                 // // 放在左侧, 多加 36, 免得靠浏览器左侧太近
  3378.                 // let final_x = offsetX + 36; // restrict to visible area
  3379.  
  3380.                 // console.log('[auto-toc, makeSticky, final_y]', Math.max((scrollableTop + TOP_MARGIN), 888 - scrollY), final_y)
  3381.                 // console.log('[auto-toc, makeSticky, scrollableTop, topMargin]',scrollableTop, topMargin)
  3382.                 // console.log('[auto-toc, makeSticky, window.outerWidth, popperMetric.width]',window.outerWidth, popperMetric.width)
  3383.                 // console.log('[auto-toc, makeSticky, ref.right, gap]',ref.right, gap)
  3384.                 // console.log('[auto-toc, makeSticky, x, window.outerWidth - popperMetric.width]', x, window.outerWidth - popperMetric.width)
  3385.                 // console.log('[auto-toc, makeSticky, x, y, offsetX, offsetY]', x, y, offsetX, offsetY)
  3386.                 // console.log('[auto-toc, makeSticky, scrollableTop, topMargin, ref.top, scrollY)', scrollableTop, topMargin, ref.top, scrollY)
  3387.                 // // console.log('[auto-toc, makeSticky, scrollableTop + topMargin, ref.top - scrollY)', scrollableTop + topMargin, ref.top - scrollY)
  3388.                 // console.log('[auto-toc, makeSticky, 3*(scrollableTop + TOP_MARGIN), 888 - scrollY', 3*(scrollableTop + TOP_MARGIN), 888 - scrollY)
  3389.                 // console.log('[auto-toc, makeSticky, x + offsetX, y + offsetY]',x + offsetX, y + offsetY)
  3390.                 // console.log('[auto-toc, makeSticky, ref.top, gap]',ref.top, gap)
  3391.  
  3392.                 // if (shouldLog) console.log("[makeSticky,final_x, final_y]", final_x, final_y)
  3393.                 return {
  3394.                     position: "fixed",
  3395.                     left: 0,
  3396.                     top: 0,
  3397.                     // transform: translate3d(x + offsetX, y + offsetY)
  3398.                     transform: translate3d(final_x, final_y),
  3399.                 };
  3400.             }
  3401.         );
  3402.     };
  3403.  
  3404.     const getOptimalContainerPos = function (article) {
  3405.         const { top, left, right, bottom, height, width } =
  3406.             article.getBoundingClientRect();
  3407.  
  3408.         const depthOf = function (elem) {
  3409.             let depth = 0;
  3410.             while (elem) {
  3411.                 elem = elem.parentElement;
  3412.                 depth++;
  3413.             }
  3414.             return depth;
  3415.         };
  3416.         const depthOfPoint = function ([x, y]) {
  3417.             const elem = document.elementFromPoint(x, y);
  3418.             return elem && depthOf(elem);
  3419.         };
  3420.         const gap = ARTICLE_TOC_GAP;
  3421.         const testWidth = 200;
  3422.         const testHeight = 400;
  3423.         const leftSlotTestPoints = [
  3424.             left - gap - testWidth,
  3425.             left - gap - testWidth / 2,
  3426.             left - gap,
  3427.         ]
  3428.             .map((x) =>
  3429.                 [top, top + testHeight / 2, top + testHeight].map((y) => [x, y])
  3430.             )
  3431.             .reduce((prev, cur) => prev.concat(cur), []);
  3432.         const rightSlotTestPoints = [
  3433.             right + gap,
  3434.             right + gap + testWidth / 2,
  3435.             right + gap + testWidth,
  3436.         ]
  3437.             .map((x) =>
  3438.                 [top, top + testHeight / 2, top + testHeight].map((y) => [x, y])
  3439.             )
  3440.             .reduce((prev, cur) => prev.concat(cur), []);
  3441.         const leftDepths = leftSlotTestPoints.map(depthOfPoint).filter(Boolean);
  3442.         const rightDepths = rightSlotTestPoints
  3443.             .map(depthOfPoint)
  3444.             .filter(Boolean);
  3445.         const leftAvgDepth = leftDepths.length
  3446.             ? leftDepths.reduce((a, b) => a + b, 0) / leftDepths.length
  3447.             : null;
  3448.         const rightAvgDepth = rightDepths.length
  3449.             ? rightDepths.reduce((a, b) => a + b, 0) / rightDepths.length
  3450.             : null;
  3451.  
  3452.         if (!leftAvgDepth) return { direction: "right" };
  3453.         if (!rightAvgDepth) return { direction: "left" };
  3454.         const spaceDiff = document.documentElement.offsetWidth - right - left;
  3455.         const scoreDiff =
  3456.             spaceDiff * 1 + (rightAvgDepth - leftAvgDepth) * 9 * -10 + 20; // I do like right better
  3457.         return scoreDiff > 0 ? { direction: "right" } : { direction: "left" };
  3458.     };
  3459.  
  3460.     const Container = function ({
  3461.         article,
  3462.         scrollable,
  3463.         $headings,
  3464.         theme,
  3465.         $activeHeading,
  3466.         $isShow,
  3467.         $userOffset,
  3468.         $relayout,
  3469.         $scroll,
  3470.         $topbarHeight,
  3471.         onClickHeading,
  3472.     }) {
  3473.         const handle = Handle({ $userOffset });
  3474.         const toc = TOC({ $headings, $activeHeading, onClickHeading });
  3475.         return {
  3476.             oncreate({ dom }) {
  3477.                 toc_dom = dom;
  3478.                 const { direction } = getOptimalContainerPos(article);
  3479.                 this.$style = makeSticky({
  3480.                     ref: article,
  3481.                     scrollable: scrollable,
  3482.                     popper: dom,
  3483.                     direction: direction,
  3484.                     gap: ARTICLE_TOC_GAP,
  3485.                     // $topMargin: $topbarHeight.map(h => (h || 0) + 50),
  3486.                     $topMargin: $topbarHeight.map((h) => TOP_MARGIN),
  3487.                     $refChange: $relayout,
  3488.                     $scroll: $scroll,
  3489.                     $offset: $userOffset,
  3490.                 });
  3491.                 this.$style.subscribe((_) => mithril.redraw());
  3492.             },
  3493.             view() {
  3494.                 return mithril(
  3495.                     "#smarttoc.dark-scheme",
  3496.                     {
  3497.                         class: [
  3498.                             theme || "light",
  3499.                             $headings().filter((h) => h.level <= 2).length >
  3500.                                 50 && "lengthy",
  3501.                             $isShow() ? "" : "hidden",
  3502.                         ]
  3503.                             .filter(Boolean)
  3504.                             .join(" "),
  3505.                         style: this.$style && this.$style(),
  3506.                     },
  3507.                     [mithril(handle), mithril(toc)]
  3508.                 );
  3509.             },
  3510.         };
  3511.     };
  3512.  
  3513.     const Extender = function ({ $headings, scrollable, $isShow, $relayout }) {
  3514.         const $extender = Stream();
  3515.         // toc: extend body height so we can scroll to the last heading
  3516.         let extender = document.createElement("DIV");
  3517.         extender.id = "smarttoc-extender";
  3518.         Stream.combine($isShow, $relayout, $headings, (isShow, _, headings) => {
  3519.             setTimeout(() => {
  3520.                 // some delay to ensure page is stable ?
  3521.                 let lastHeading = headings.slice(-1)[0].node;
  3522.                 let lastRect = lastHeading.getBoundingClientRect();
  3523.                 let extenderHeight = 0;
  3524.                 if (scrollable === document.body) {
  3525.                     let heightBelowLastRect =
  3526.                         document.documentElement.scrollHeight -
  3527.                         (lastRect.bottom + document.documentElement.scrollTop) -
  3528.                         num(extender.style.height); // in case we are there already
  3529.                     extenderHeight = isShow
  3530.                         ? Math.max(
  3531.                               window.innerHeight -
  3532.                                   lastRect.height -
  3533.                                   heightBelowLastRect,
  3534.                               0
  3535.                           )
  3536.                         : 0;
  3537.                 } else {
  3538.                     let scrollRect = scrollable.getBoundingClientRect();
  3539.                     let heightBelowLastRect =
  3540.                         scrollRect.top +
  3541.                         scrollable.scrollHeight -
  3542.                         getScroll(scrollable) - // bottom of scrollable relative to viewport
  3543.                         lastRect.bottom -
  3544.                         num(extender.style.height); // in case we are there already
  3545.                     extenderHeight = isShow
  3546.                         ? Math.max(
  3547.                               scrollRect.height -
  3548.                                   lastRect.height -
  3549.                                   heightBelowLastRect,
  3550.                               0
  3551.                           )
  3552.                         : 0;
  3553.                 }
  3554.                 $extender({
  3555.                     height: extenderHeight,
  3556.                 });
  3557.             }, 300);
  3558.         });
  3559.         $extender.subscribe((style) => applyStyle(extender, style));
  3560.         return extender;
  3561.     };
  3562.  
  3563.     const relayoutStream = function (article, $resize, $isShow) {
  3564.         const readableStyle = function (article) {
  3565.             let computed = window.getComputedStyle(article);
  3566.             let fontSize = num(computed.fontSize);
  3567.             let bestWidth = Math.min(Math.max(fontSize, 12), 16) * 66;
  3568.             if (computed["box-sizing"] === "border-box") {
  3569.                 bestWidth +=
  3570.                     num(computed["padding-left"]) +
  3571.                     num(computed["padding-right"]);
  3572.             }
  3573.  
  3574.             return Object.assign(
  3575.                 num(computed.marginLeft) || num(computed.marginRight)
  3576.                     ? {}
  3577.                     : {
  3578.                           marginLeft: "auto",
  3579.                           marginRight: "auto",
  3580.                       },
  3581.                 num(computed.maxWidth)
  3582.                     ? {}
  3583.                     : {
  3584.                           maxWidth: bestWidth,
  3585.                       }
  3586.             );
  3587.         };
  3588.         let oldStyle = article.style.cssText;
  3589.         let newStyle = readableStyle(article);
  3590.         let $relayout = $isShow.map((isShow) => {
  3591.             if (isShow) {
  3592.                 // 注释掉了下面这两行, 免得生成 toc 的时候导致页面重排, 很丑
  3593.                 // applyStyle(article, newStyle)
  3594.                 // return article
  3595.             } else {
  3596.                 // applyStyle(article, oldStyle)
  3597.             }
  3598.         });
  3599.         return Stream.combine($relayout, $resize, () => null);
  3600.     };
  3601.  
  3602.     const addAnchors = function (headings) {
  3603.         const anchoredHeadings = headings.map(function ({
  3604.             node,
  3605.             level,
  3606.             anchor,
  3607.         }) {
  3608.             if (!anchor) {
  3609.                 anchor =
  3610.                     node.id ||
  3611.                     [].slice
  3612.                         .apply(node.children)
  3613.                         .filter((elem) => elem.tagName === "A")
  3614.                         .map((a) => {
  3615.                             let href = a.getAttribute("href") || "";
  3616.                             return href.startsWith("#") ? href.substr(1) : a.id;
  3617.                         })
  3618.                         .filter(Boolean)[0];
  3619.                 if (!anchor) {
  3620.                     anchor = node.id = unique(safe(node.textContent));
  3621.                 } else {
  3622.                     anchor = unique(anchor);
  3623.                 }
  3624.             }
  3625.             return { node, level, anchor };
  3626.         });
  3627.  
  3628.         // console.log("anchoredHeadings begin aaa")
  3629.         // console.log(anchoredHeadings)
  3630.         // console.log("anchoredHeadings end bbb")
  3631.         return anchoredHeadings;
  3632.     };
  3633.  
  3634.     const getScrollParent = function (elem) {
  3635.         const canScroll = (el) =>
  3636.             ["auto", "scroll"].includes(
  3637.                 window.getComputedStyle(el).overflowY
  3638.             ) && el.clientHeight + 1 < el.scrollHeight;
  3639.         while (elem && elem !== document.body && !canScroll(elem)) {
  3640.             elem = elem.parentElement;
  3641.         }
  3642.         log("scrollable", elem);
  3643.         draw(elem, "purple");
  3644.         return elem;
  3645.     };
  3646.  
  3647.     const scrollStream = function (scrollable, $isShow) {
  3648.         let $scroll = Stream([
  3649.             getScroll(scrollable, "left"),
  3650.             getScroll(scrollable),
  3651.         ]);
  3652.         let source = scrollable === document.body ? window : scrollable;
  3653.         Stream.fromEvent(source, "scroll")
  3654.             .filter(() => $isShow())
  3655.             .throttle()
  3656.             .subscribe(() => {
  3657.                 $scroll([getScroll(scrollable, "left"), getScroll(scrollable)]);
  3658.             });
  3659.         return $scroll;
  3660.     };
  3661.  
  3662.     const activeHeadingStream = function (
  3663.         $headings,
  3664.         scrollable,
  3665.         $scroll,
  3666.         $relayout,
  3667.         $topbarHeight
  3668.     ) {
  3669.         const $headingScrollYs = Stream.combine(
  3670.             $relayout,
  3671.             $headings,
  3672.             (_, headings) => {
  3673.                 const scrollableTop =
  3674.                     (scrollable === document.body
  3675.                         ? 0
  3676.                         : scrollable.getBoundingClientRect().top) -
  3677.                     getScroll(scrollable, "top");
  3678.                 return headings.map(
  3679.                     ({ node }) =>
  3680.                         node.getBoundingClientRect().top - scrollableTop
  3681.                 );
  3682.             }
  3683.         );
  3684.  
  3685.         let $curIndex = Stream.combine(
  3686.             $headingScrollYs,
  3687.             $scroll,
  3688.             $topbarHeight,
  3689.             function (headingScrollYs, [scrollX, scrollY], topbarHeight = 0) {
  3690.                 let i = 0;
  3691.                 for (let len = headingScrollYs.length; i < len; i++) {
  3692.                     if (headingScrollYs[i] > scrollY + topbarHeight + 20) {
  3693.                         break;
  3694.                     }
  3695.                 }
  3696.                 return Math.max(0, i - 1);
  3697.             }
  3698.         );
  3699.  
  3700.         return $curIndex.unique();
  3701.     };
  3702.  
  3703.     const scrollToHeading = function (
  3704.         { node },
  3705.         scrollElem,
  3706.         onScrollEnd,
  3707.         topMargin = 0
  3708.     ) {
  3709.         scrollTo({
  3710.             targetElem: node,
  3711.             scrollElem: scrollElem,
  3712.             topMargin: topMargin,
  3713.             maxDuration: 566,
  3714.             callback: onScrollEnd && onScrollEnd.bind(null, node),
  3715.         });
  3716.     };
  3717.  
  3718.     const getTopBarHeight = function (topElem) {
  3719.         // 默认网页的顶部有个 bar, 而且默认这个 bar 的高度是 88, 保证点击 toc 的时候跳转可以网页多往下移一点, 免得被各种检测不出来的 bar 挡住
  3720.         return TOP_MARGIN;
  3721.  
  3722.         const findFixedParent = function (elem) {
  3723.             const isFixed = (elem) => {
  3724.                 let { position, zIndex } = window.getComputedStyle(elem);
  3725.                 return position === "fixed" && zIndex;
  3726.             };
  3727.             while (elem !== document.body && !isFixed(elem)) {
  3728.                 elem = elem.parentElement;
  3729.             }
  3730.             return elem === document.body ? null : elem;
  3731.         };
  3732.         let { left, right, top } = topElem.getBoundingClientRect();
  3733.         let leftTopmost = document.elementFromPoint(left + 1, top + 1);
  3734.         let rightTopmost = document.elementFromPoint(right - 1, top + 1);
  3735.         if (
  3736.             leftTopmost &&
  3737.             rightTopmost &&
  3738.             leftTopmost !== topElem &&
  3739.             rightTopmost !== topElem
  3740.         ) {
  3741.             let leftFixed = findFixedParent(leftTopmost);
  3742.             let rightFixed = findFixedParent(rightTopmost);
  3743.             if (leftFixed && leftFixed === rightFixed) {
  3744.                 return leftFixed.offsetHeight;
  3745.             } else {
  3746.                 return 0;
  3747.             }
  3748.         } else {
  3749.             return 0;
  3750.         }
  3751.     };
  3752.  
  3753.     const getTheme = function (article) {
  3754.         let elem = article;
  3755.         try {
  3756.             const parseColor = (str) =>
  3757.                 str
  3758.                     .replace(/rgba?\(/, "")
  3759.                     .replace(/\).*/, "")
  3760.                     .split(/, ?/);
  3761.             const getBgColor = (elem) =>
  3762.                 parseColor(window.getComputedStyle(elem)["background-color"]);
  3763.             const isTransparent = ([r, g, b, a]) => a === 0;
  3764.             const isLight = ([r, g, b, a]) => r + g + b > (255 / 2) * 3;
  3765.             while (elem && elem.parentElement) {
  3766.                 const color = getBgColor(elem);
  3767.                 if (isTransparent(color)) {
  3768.                     elem = elem.parentElement;
  3769.                 } else {
  3770.                     return isLight(color) ? "light" : "dark";
  3771.                 }
  3772.             }
  3773.             return "light";
  3774.         } catch (e) {
  3775.             return "light";
  3776.         }
  3777.     };
  3778.  
  3779.     const getRoot = function () {
  3780.         let root = document.getElementById("smarttoc_wrapper");
  3781.         if (!root) {
  3782.             root = document.body.appendChild(document.createElement("DIV"));
  3783.             root.id = "smarttoc_wrapper";
  3784.         }
  3785.         return root;
  3786.     };
  3787.  
  3788.     // 生成目录
  3789.     function createTOC({
  3790.         article,
  3791.         $headings: $headings_,
  3792.         userOffset = [0, 0],
  3793.     }) {
  3794.         var domain2width2offset = GM_getValue(
  3795.             "menu_GAEEScript_auto_toc_domain_2_width_2_offset"
  3796.         );
  3797.         if (domain2width2offset[window.location.host] != null) {
  3798.             var lastOffset = domain2width2offset[window.location.host][window.screen.width];
  3799.             if (shouldLog) console.log("[auto-toc, lastOffset]", lastOffset);
  3800.             if (shouldLog) console.log("[auto-toc, domain2width2offset[" + window.location.host + "]]", domain2width2offset[window.location.host]);
  3801.             if (lastOffset != null) {
  3802.                 userOffset = lastOffset;
  3803.             }
  3804.             // console.log("[auto-toc, init userOffset]", userOffset);
  3805.         }
  3806.  
  3807.         const $headings = $headings_.map(addAnchors);
  3808.         insertCSS(getTocCss(), "smarttoc__css");
  3809.  
  3810.         const scrollable = getScrollParent(article);
  3811.         const theme = getTheme(article);
  3812.         log("theme", theme);
  3813.  
  3814.         const $isShow = Stream(true);
  3815.         const $topbarHeight = Stream();
  3816.         const $resize = Stream.combine(
  3817.             Stream.fromEvent(window, "resize"),
  3818.             Stream.fromEvent(document, "readystatechange"),
  3819.             Stream.fromEvent(document, "load"),
  3820.             Stream.fromEvent(document, "DOMContentLoaded"),
  3821.             () => null
  3822.         )
  3823.             .filter(() => $isShow())
  3824.             .throttle();
  3825.         const $scroll = scrollStream(scrollable, $isShow);
  3826.         const $relayout = relayoutStream(article, $resize, $isShow);
  3827.         const $activeHeading = activeHeadingStream(
  3828.             $headings,
  3829.             scrollable,
  3830.             $scroll,
  3831.             $relayout,
  3832.             $topbarHeight
  3833.         );
  3834.         const $userOffset = Stream(userOffset);
  3835.  
  3836.         // scrollable.appendChild(
  3837.         //   Extender({ $headings, scrollable, $isShow, $relayout })
  3838.         // )
  3839.  
  3840.         const onScrollEnd = function (node) {
  3841.             if ($topbarHeight() == null) {
  3842.                 setTimeout(() => {
  3843.                     $topbarHeight(getTopBarHeight(node));
  3844.                     log("topBarHeight", $topbarHeight());
  3845.                     if ($topbarHeight()) {
  3846.                         scrollToHeading(
  3847.                             { node },
  3848.                             scrollable,
  3849.                             null,
  3850.                             $topbarHeight() + 10
  3851.                         );
  3852.                     }
  3853.                 }, 300);
  3854.             }
  3855.         };
  3856.  
  3857.         const onClickHeading = function (e) {
  3858.             e.redraw = false;
  3859.             e.preventDefault();
  3860.             e.stopPropagation();
  3861.             const temp = e.target.getAttribute("href");
  3862.             if (!temp) return;
  3863.             const anchor = temp.substr(1);
  3864.             const heading = $headings().find(
  3865.                 (heading) => heading.anchor === anchor
  3866.             );
  3867.             scrollToHeading(
  3868.                 heading,
  3869.                 scrollable,
  3870.                 onScrollEnd,
  3871.                 ($topbarHeight() || 0) + 10
  3872.             );
  3873.         };
  3874.  
  3875.         mithril.mount(
  3876.             getRoot(),
  3877.             Container({
  3878.                 article,
  3879.                 scrollable,
  3880.                 $headings,
  3881.                 theme,
  3882.                 $activeHeading,
  3883.                 $isShow,
  3884.                 $userOffset,
  3885.                 $relayout,
  3886.                 $scroll,
  3887.                 $topbarHeight,
  3888.                 onClickHeading,
  3889.             })
  3890.         );
  3891.  
  3892.         // // now show what we've found
  3893.         // if (article.getBoundingClientRect().top > window.innerHeight - 50) {
  3894.         //     scrollToHeading(
  3895.         //         $headings()[0],
  3896.         //         scrollable,
  3897.         //         onScrollEnd,
  3898.         //         ($topbarHeight() || 0) + 10
  3899.         //     );
  3900.         // }
  3901.  
  3902.         return {
  3903.             isValid: () =>
  3904.                 document.body.contains(article) &&
  3905.                 article.contains($headings()[0].node),
  3906.  
  3907.             isShow: () => $isShow(),
  3908.  
  3909.             toggle: () => $isShow(!$isShow()),
  3910.  
  3911.             next: () => {
  3912.                 if ($isShow()) {
  3913.                     let nextIdx = Math.min(
  3914.                         $headings().length - 1,
  3915.                         $activeHeading() + 1
  3916.                     );
  3917.                     scrollToHeading(
  3918.                         $headings()[nextIdx],
  3919.                         scrollable,
  3920.                         onScrollEnd,
  3921.                         ($topbarHeight() || 0) + 10
  3922.                     );
  3923.                 }
  3924.             },
  3925.  
  3926.             prev: () => {
  3927.                 if ($isShow()) {
  3928.                     let prevIdx = Math.max(0, $activeHeading() - 1);
  3929.                     scrollToHeading(
  3930.                         $headings()[prevIdx],
  3931.                         scrollable,
  3932.                         onScrollEnd,
  3933.                         ($topbarHeight() || 0) + 10
  3934.                     );
  3935.                 }
  3936.             },
  3937.  
  3938.             dispose: () => {
  3939.                 $isShow(false);
  3940.                 mithril.render(getRoot(), mithril(""));
  3941.                 return { userOffset: $userOffset() };
  3942.             },
  3943.         };
  3944.     }
  3945.  
  3946.     const pathToTop = function (elem, maxLvl = -1) {
  3947.         assert(elem, "no element given");
  3948.         const path = [];
  3949.         while (elem && maxLvl--) {
  3950.             path.push(elem);
  3951.             elem = elem.parentElement;
  3952.         }
  3953.         return path;
  3954.     };
  3955.  
  3956.     //////////////////////////////// 以下是新版提取文章和标题的部分(目前测出某些网站会导致页面排版错乱比如谷歌和https://www.163.com/dy/article/GJKFUO4105119NPR.html) //////////////////////////////////////////////////////////////////////
  3957.     //////////////////////////////// 所以退回后面的旧版的代码了 //////////////////////////////////////////////////////////////////////
  3958.  
  3959.     var toArray = function (arr) {
  3960.         return [].slice.apply(arr);
  3961.     };
  3962.  
  3963.     const header_tags = ["H1", "H2", "H3", "H4", "H5", "H6"];
  3964.     const extra_tags = ["STRONG", "B"];
  3965.  
  3966.     // 判断一个元素是否对于整个页面水平居中
  3967.     const isElementHorizontalCentered = function (element) {
  3968.         let divElement = element.closest("div");
  3969.         if (divElement) {
  3970.             let finalElem = element;
  3971.             let closestSection = element.closest("section");
  3972.             let OtherExtraTagsElemCombinedText = "";
  3973.             // 如果有个最近的section祖先, 则检查是否有兄弟section, 然后判断他们的共同祖先section是否居中
  3974.             if (closestSection) {
  3975.                 if (shouldLog)
  3976.                     console.log(
  3977.                         "isElementHorizontalCentered closestSection begin",
  3978.                         element.textContent
  3979.                     );
  3980.                 finalElem = closestSection;
  3981.                 // 拿到一个高层的祖先<section>元素 S 并且它是有个其他包含其他文本的section, 且途中不能有为P的祖先, 用 S 当做 finalElem 来判断是否居中
  3982.                 let currentElement = element;
  3983.                 let previousSibling = null;
  3984.                 let nextSibling = null;
  3985.                 while (currentElement.parentElement) {
  3986.                     let curParent = currentElement.parentElement;
  3987.                     if (curParent.isCalcedCentered) {
  3988.                         // 已经被标记过了, 那应该直接返回 false 了
  3989.                         return false;
  3990.                     }
  3991.                     if (curParent.tagName === "SECTION") {
  3992.                         previousSibling = curParent.previousElementSibling;
  3993.                         nextSibling = curParent.nextElementSibling;
  3994.                         // 如果祖先的兄弟已经是<p>了, 那可以停止继续循环了
  3995.                         if (
  3996.                             (previousSibling &&
  3997.                                 previousSibling.tagName === "P") ||
  3998.                             (nextSibling && nextSibling.tagName === "P")
  3999.                         ) {
  4000.                             finalElem = curParent;
  4001.                             break;
  4002.                         }
  4003.                         let hasExtraTagsTextCnt = 0;
  4004.                         let shouldBreakWhile = false;
  4005.                         OtherExtraTagsElemCombinedText = "";
  4006.                         for (let k = 0; k < curParent.childNodes.length; k++) {
  4007.                             let fc = curParent.childNodes[k];
  4008.                             // 如果当前祖先的子元素已经是有<p>子元素了, 那可以停止继续循环了, 并且把 `自己` 当做 finalElem
  4009.                             if (fc.querySelector("p") !== null) {
  4010.                                 finalElem = currentElement;
  4011.                                 shouldBreakWhile = true;
  4012.                                 break;
  4013.                             }
  4014.                             // 如果当前祖先的子元素已经是2个以及以上的extra_tags文本子元素了, 那可以停止继续循环了, 并且把 `当前祖先` 当做 finalElem
  4015.                             for (let i = 0; i < extra_tags.length; i++) {
  4016.                                 let curElems = fc.querySelectorAll(
  4017.                                     extra_tags[i]
  4018.                                 );
  4019.                                 if (curElems) {
  4020.                                     for (let j = 0; j < curElems.length; j++) {
  4021.                                         let curElem = curElems[j];
  4022.                                         if (curElem.textContent != "") {
  4023.                                             hasExtraTagsTextCnt += 1;
  4024.                                             OtherExtraTagsElemCombinedText +=
  4025.                                                 curElem.textContent;
  4026.                                             if (shouldLog)
  4027.                                                 console.log(
  4028.                                                     "isElementHorizontalCentered OtherExtraTagsElemCombinedText",
  4029.                                                     element.textContent,
  4030.                                                     OtherExtraTagsElemCombinedText,
  4031.                                                     fc,
  4032.                                                     curElem
  4033.                                                 );
  4034.                                             if (hasExtraTagsTextCnt == 2) {
  4035.                                                 finalElem = curParent;
  4036.                                                 shouldBreakWhile = true;
  4037.                                             }
  4038.                                         }
  4039.                                     }
  4040.                                 }
  4041.                             }
  4042.                         }
  4043.                         if (shouldBreakWhile) {
  4044.                             break;
  4045.                         }
  4046.                     } else if (curParent.tagName === "P") {
  4047.                         // 如果中间有一个祖先是P那就不应该要了
  4048.                         break;
  4049.                     } else if (curParent.tagName === "div") {
  4050.                         // 如果中间有一个祖先是div那就不应该要了
  4051.                         break;
  4052.                     }
  4053.                     currentElement = currentElement.parentElement;
  4054.                 }
  4055.                 finalElem.isCalcedCentered = true;
  4056.                 if (shouldLog)
  4057.                     console.log(
  4058.                         "isElementHorizontalCentered closestSection end",
  4059.                         element.textContent,
  4060.                         OtherExtraTagsElemCombinedText,
  4061.                         finalElem
  4062.                     );
  4063.             }
  4064.             let elementWidth = finalElem.offsetWidth;
  4065.             let pWidth = divElement.offsetWidth;
  4066.             let elementLeft = finalElem.getBoundingClientRect().left;
  4067.             let pLeft = divElement.getBoundingClientRect().left;
  4068.             let elementCenter = elementLeft + elementWidth / 2;
  4069.             let pCenter = pLeft + pWidth / 2;
  4070.             let isCentered = Math.abs(elementCenter - pCenter) <= 3;
  4071.  
  4072.             if (shouldLog)
  4073.                 console.log(
  4074.                     "isElementHorizontalCentered isCentered: ",
  4075.                     element.textContent,
  4076.                     isCentered,
  4077.                     elementCenter,
  4078.                     pCenter
  4079.                 );
  4080.  
  4081.             // 如果有兄弟section, 然后判断他们是不是类似于 `01`+ `起源`这种一个是纯数字其他是文字的几个section合起来的大section, 那就把他们的文本合并来当做`01`这个section的标题 newTextContent
  4082.             if (isCentered && OtherExtraTagsElemCombinedText != "") {
  4083.                 element.newTextContent = OtherExtraTagsElemCombinedText;
  4084.                 if (shouldLog)
  4085.                     console.log(
  4086.                         "isElementHorizontalCentered shouldCombineSectionText: ",
  4087.                         element.textContent,
  4088.                         element.newTextContent
  4089.                     );
  4090.             }
  4091.  
  4092.             return isCentered;
  4093.         } else {
  4094.             let elementRect = element.getBoundingClientRect();
  4095.             let viewportWidth =
  4096.                 window.innerWidth || document.documentElement.clientWidth;
  4097.             let elementCenterX = elementRect.left + elementRect.width / 2;
  4098.             return Math.abs(elementCenterX - viewportWidth / 2) < 8;
  4099.         }
  4100.     };
  4101.  
  4102.     // 拿到离页面左边边缘最近的标题的距离
  4103.     var getElemsCommonLeft = function (elems) {
  4104.         if (!elems.length) {
  4105.             if (shouldLog)
  4106.                 console.log("calc_getElemsCommonLeft, !elems.length");
  4107.             return undefined;
  4108.         }
  4109.         var lefts = {};
  4110.         elems.forEach(function (el) {
  4111.             var left = el.getBoundingClientRect().left;
  4112.             if (!lefts[left]) {
  4113.                 lefts[left] = 0;
  4114.             }
  4115.             lefts[left]++;
  4116.         });
  4117.         var count = elems.length;
  4118.         var isAligned = Object.keys(lefts).length <= Math.ceil(0.6 * count);
  4119.         if (!isAligned) {
  4120.             if (shouldLog)
  4121.                 console.log(
  4122.                     "calc_getElemsCommonLeft, !isAligned, ",
  4123.                     Object.keys(lefts).length,
  4124.                     Math.ceil(0.6 * count),
  4125.                     count
  4126.                 );
  4127.             return undefined;
  4128.         }
  4129.         var sortedByCount = Object.keys(lefts).sort(function (a, b) {
  4130.             return lefts[b] - lefts[a];
  4131.         });
  4132.         var most = Number(sortedByCount[0]);
  4133.         if (shouldLog) console.log("calc_getElemsCommonLeft, most, ", most);
  4134.         return most;
  4135.     };
  4136.  
  4137.     const extractArticle = function (rootElement = document) {
  4138.         // if (shouldLog) console.log("extracting article");
  4139.  
  4140.         const scores = new Map();
  4141.  
  4142.         function addScore(elem, inc) {
  4143.             scores.set(elem, (scores.get(elem) || 0) + inc);
  4144.         }
  4145.  
  4146.         function updateScore(elem, weight) {
  4147.             let path = pathToTop(elem, weight.length);
  4148.             path.forEach((elem, distance) => addScore(elem, weight[distance]));
  4149.         }
  4150.  
  4151.         // weigh nodes by factor: "selector", "distance from this node"
  4152.         const weights = {
  4153.             h1: [0, 100, 60, 40, 30, 25, 22].map((s) => s * 0.4),
  4154.             h2: [0, 100, 60, 40, 30, 25, 22],
  4155.             h3: [0, 100, 60, 40, 30, 25, 22].map((s) => s * 0.5),
  4156.             h4: [0, 100, 60, 40, 30, 25, 22].map((s) => s * 0.5 * 0.5),
  4157.             h5: [0, 100, 60, 40, 30, 25, 22].map((s) => s * 0.5 * 0.5 * 0.5),
  4158.             h6: [0, 100, 60, 40, 30, 25, 22].map(
  4159.                 (s) => s * 0.5 * 0.5 * 0.5 * 0.5
  4160.             ),
  4161.             article: [500],
  4162.             ".article": [500],
  4163.             ".content": [101],
  4164.             sidebar: [-500],
  4165.             ".sidebar": [-500],
  4166.             aside: [-500],
  4167.             ".aside": [-500],
  4168.             nav: [-500],
  4169.             ".nav": [-500],
  4170.             ".navigation": [-500],
  4171.             ".toc": [-500],
  4172.             ".table-of-contents": [-500],
  4173.         };
  4174.         const selectors = Object.keys(weights);
  4175.         selectors
  4176.             .map((selector) => ({
  4177.                 selector: selector,
  4178.                 elems: [].slice.apply(rootElement.querySelectorAll(selector)),
  4179.             }))
  4180.             .forEach(({ selector, elems }) =>
  4181.                 elems.forEach((elem) => updateScore(elem, weights[selector]))
  4182.             );
  4183.         const sorted = [...scores].sort((a, b) => b[1] - a[1]);
  4184.  
  4185.         // reweigh top 5 nodes by factor:  "take-lots-vertical-space", "contain-less-links", "too-narrow"
  4186.         let candicates = sorted
  4187.             .slice(0, 5)
  4188.             .filter(Boolean)
  4189.             .map(([elem, score]) => ({ elem, score }));
  4190.  
  4191.         let isTooNarrow = (e) => e.scrollWidth < 400; // rule out sidebars
  4192.  
  4193.         candicates.forEach((c) => {
  4194.             if (isTooNarrow(c.elem)) {
  4195.                 c.isNarrow = true;
  4196.                 candicates.forEach((parent) => {
  4197.                     if (parent.elem.contains(c.elem)) {
  4198.                         parent.score *= 0.7;
  4199.                     }
  4200.                 });
  4201.             }
  4202.         });
  4203.         candicates = candicates.filter((c) => !c.isNarrow);
  4204.  
  4205.         const reweighted = candicates
  4206.             .map(({ elem, score }) => [
  4207.                 elem,
  4208.                 score *
  4209.                     Math.log(
  4210.                         (elem.scrollHeight * elem.scrollHeight) /
  4211.                             (elem.querySelectorAll("a").length || 1)
  4212.                     ),
  4213.                 elem.scrollHeight,
  4214.                 elem.querySelectorAll("a").length,
  4215.             ])
  4216.             .sort((a, b) => b[1] - a[1]);
  4217.  
  4218.         const article = reweighted.length ? reweighted[0][0] : null;
  4219.  
  4220.         // console.log('[extracttttttttttt]', {
  4221.         //     scores: scores,
  4222.         //     sorted: sorted,
  4223.         //     candicates: candicates,
  4224.         //     reweighted: reweighted
  4225.         // });
  4226.         return article;
  4227.     };
  4228.  
  4229.     const extractHeadings = function (article) {
  4230.         if (shouldLog) console.log("extractHeadings begin");
  4231.         const tags = header_tags.concat(extra_tags);
  4232.         // const tagWeight = (tag) =>
  4233.         //     ({ H1: 4, H2: 9, H3: 9, H4: 10, H5: 10, H6: 10, STRONG: 10, B: 10 }[
  4234.         //         tag
  4235.         //     ]);
  4236.         const isVisible = (elem) => elem.offsetHeight !== 0;
  4237.  
  4238.         // 筛选页面上想要遍历的 node
  4239.         const acceptNode = (node) =>
  4240.             tags.includes(node.tagName) && isVisible(node)
  4241.                 ? // isVisible(node) &&
  4242.                   // (node.id ? finalId.includes(node.id) : finalInnerHTML.includes(node.innerHTML))
  4243.                   NodeFilter.FILTER_ACCEPT
  4244.                 : NodeFilter.FILTER_SKIP;
  4245.         const treeWalker = document.createTreeWalker(
  4246.             article,
  4247.             NodeFilter.SHOW_ELEMENT,
  4248.             { acceptNode }
  4249.         );
  4250.  
  4251.         // console.log("extra_tags_leftmost_offset old begin")
  4252.         // console.log(extra_tags_leftmost_offset)
  4253.         // console.log("extra_tags_leftmost_offset old end")
  4254.  
  4255.         let isNormalHeadingExist = false;
  4256.         let normalHeadingCnt = 0;
  4257.         for (let i = 0; i < header_tags.length; i++) {
  4258.             // 检查 article 是否包含 tag 标签
  4259.             let tag = header_tags[i];
  4260.             const elems = (0, toArray)(article.getElementsByTagName(tag));
  4261.             normalHeadingCnt += elems.length;
  4262.             if (normalHeadingCnt >= 3) {
  4263.                 // 3个及以上比较好, 免得有可能其中一个是文章最上面的大标题
  4264.                 isNormalHeadingExist = true;
  4265.                 break;
  4266.             }
  4267.         }
  4268.  
  4269.         let extra_tags_leftmost_offset = new Map();
  4270.         if (!isNormalHeadingExist) {
  4271.             // 有几个其他正经标题了, 之后没必要提取<b>和<strong>了
  4272.             // 提前计算出<b> 和<strong>这俩特殊标题的离页面左边边缘最近的标题的距离
  4273.             extra_tags.forEach((tag) => {
  4274.                 if (shouldLog)
  4275.                     console.log("calc_getElemsCommonLeft, tagName=", tag);
  4276.                 const elems = (0, toArray)(article.getElementsByTagName(tag));
  4277.                 extra_tags_leftmost_offset[tag] = getElemsCommonLeft(elems);
  4278.             });
  4279.         }
  4280.         // 返回level
  4281.         const is_b_strong_valid_heading = function (node) {
  4282.             // 有几个其他正经标题了, 不要提取<b>和<strong>了
  4283.             if (isNormalHeadingExist) {
  4284.                 if (shouldLog)
  4285.                     console.log("b_strong continue 0, ", node.textContent);
  4286.                 return 0;
  4287.             }
  4288.             // 加粗的文字的前后还有其他元素(有可能是普通不加粗的文字或者图片啊啥的)则不识别为标题
  4289.             if (
  4290.                 node.closest("P") ||
  4291.                 node.parentElement.childNodes.length !== 1
  4292.             ) {
  4293.                 let cn_list = [];
  4294.                 // 拿到最近的p祖先的子元素们
  4295.                 if (node.closest("P")) {
  4296.                     cn_list.push(node.closest("P").childNodes);
  4297.                 }
  4298.                 // 拿到父元素的子元素们
  4299.                 if (node.parentElement.childNodes.length !== 1) {
  4300.                     cn_list.push(node.parentElement.childNodes);
  4301.                 }
  4302.                 for (let j = 0; j < cn_list.length; j++) {
  4303.                     let cn = cn_list[j];
  4304.                     for (let i = 0; i < cn.length; i++) {
  4305.                         if (
  4306.                             cn[i] === node ||
  4307.                             cn[i].contains(node) ||
  4308.                             extra_tags.includes(cn[i].tagName) ||
  4309.                             cn[i].nodeName.toLowerCase() === "br" ||
  4310.                             (cn[i].nodeName.toLowerCase() === "span" &&
  4311.                                 cn[i].textContent === "")
  4312.                         ) {
  4313.                             // 但是同级元素是换行<br>或空的<span>或者是<b>或<strong>是可以的
  4314.                             continue;
  4315.                         }
  4316.                         if (shouldLog)
  4317.                             console.log(
  4318.                                 "b_strong continue 8, ",
  4319.                                 cn[i].textContent,
  4320.                                 cn[i].nodeName.toLowerCase()
  4321.                             );
  4322.                         return 0;
  4323.                     }
  4324.                 }
  4325.             }
  4326.  
  4327.             // 当前 elem 不能是标题的子元素, 否则会重复
  4328.             for (let j = 0; j < tags.length; j++) {
  4329.                 let curNode =
  4330.                     node.tagName == tags[j] ? node.parentElement : node; // 不这样的话, closest会找到node自己
  4331.                 const ancestor = curNode.closest(tags[j]);
  4332.                 if (ancestor) {
  4333.                     if (shouldLog)
  4334.                         console.log(
  4335.                             "b_strong continue 2, ",
  4336.                             node.textContent,
  4337.                             ancestor
  4338.                         );
  4339.                     return 0;
  4340.                 }
  4341.             }
  4342.  
  4343.             // 加粗的文字的父元素以及爷元素为<u>则不识别为标题(因为<u>会使得子元素带下划线)
  4344.             if (
  4345.                 node.parentElement &&
  4346.                 (node.parentElement.tagName === "U" ||
  4347.                     (node.parentElement.parentElement &&
  4348.                         node.parentElement.parentElement.tagName === "U"))
  4349.             ) {
  4350.                 if (shouldLog)
  4351.                     console.log("b_strong continue 5, ", node.textContent);
  4352.                 return 0;
  4353.             }
  4354.             let cur_leftmost_offset = extra_tags_leftmost_offset[node.tagName];
  4355.             let isCentered = false;
  4356.             let isLeftAligned = false;
  4357.             // strong/b 粗体字类型的标题靠左对齐则level为2, 不靠左对齐则看看是否居中, 居中则level为1; 总之: 优先查看是否靠左对齐
  4358.             if (!cur_leftmost_offset) {
  4359.                 isCentered = isElementHorizontalCentered(node);
  4360.                 if (isCentered) {
  4361.                     return 1;
  4362.                 }
  4363.                 if (!isCentered) {
  4364.                     if (shouldLog)
  4365.                         console.log("b_strong continue 6, ", node.textContent);
  4366.                     return 0;
  4367.                 }
  4368.             } else {
  4369.                 // 当前 elem 离左边距离得和 cur_leftmost_offset 一样
  4370.                 isLeftAligned =
  4371.                     node.getBoundingClientRect().left === cur_leftmost_offset;
  4372.                 if (isLeftAligned) {
  4373.                     return 2;
  4374.                 }
  4375.                 isCentered = isElementHorizontalCentered(node);
  4376.                 if (isCentered) {
  4377.                     return 1;
  4378.                 }
  4379.                 if (!isCentered && !isLeftAligned) {
  4380.                     if (shouldLog)
  4381.                         console.log("b_strong continue 1, ", node.textContent);
  4382.                     return 0;
  4383.                 }
  4384.             }
  4385.         };
  4386.  
  4387.         const headings = [];
  4388.         while (treeWalker.nextNode()) {
  4389.             // 按照页面上的显示顺序遍历
  4390.             let node = treeWalker.currentNode;
  4391.             if (node.autoTocHeadingLevel == null) {
  4392.                 // 如果当前标题内容为空, 则找相邻的下一个同级的非header_tags以及非可用的b/strong的元素用它的文本作为标题显示, 但如果还是空白的, 那就不要了
  4393.                 let nodeText = node.textContent.trim();
  4394.                 if (
  4395.                     nodeText === "" &&
  4396.                     node.nextElementSibling &&
  4397.                     !header_tags.includes(node.nextElementSibling.tagName) &&
  4398.                     !is_b_strong_valid_heading(node)
  4399.                 ) {
  4400.                     nodeText = node.nextElementSibling.textContent.trim();
  4401.                 }
  4402.                 if (nodeText === "") {
  4403.                     if (shouldLog)
  4404.                         console.log("b_strong continue 4", node.textContent);
  4405.                     node.autoTocHeadingLevel = 0;
  4406.                     continue;
  4407.                 }
  4408.                 let cur_level = tags.indexOf(node.tagName) + 1;
  4409.                 if (extra_tags.includes(node.tagName)) {
  4410.                     cur_level = is_b_strong_valid_heading(node);
  4411.                     if (cur_level === 0) {
  4412.                         node.autoTocHeadingLevel = 0;
  4413.                         continue;
  4414.                     }
  4415.                     if (shouldLog)
  4416.                         console.log(
  4417.                             "b_strong cur_level",
  4418.                             node.textContent,
  4419.                             cur_level
  4420.                         );
  4421.                 }
  4422.                 node.autoTocHeadingLevel = cur_level;
  4423.             }
  4424.  
  4425.             if (node.autoTocHeadingLevel < 1) {
  4426.                 continue;
  4427.             }
  4428.             headings.push({
  4429.                 node,
  4430.                 level: node.autoTocHeadingLevel,
  4431.             });
  4432.         }
  4433.  
  4434.         if (shouldLog) console.log("extractHeadings end", headings);
  4435.         return headings;
  4436.     };
  4437.  
  4438.     ////////////////////////////////////////////////////////////////////////////////
  4439.  
  4440.     function extract() {
  4441.         const article = extractArticle(document);
  4442.         let $headings;
  4443.         if (article) {
  4444.             $headings = Stream(extractHeadings(article));
  4445.  
  4446.             // const $articleChange = Stream(null);
  4447.             // const observer = new MutationObserver((_) => $articleChange(null));
  4448.             // observer.observe(article, { childList: true });
  4449.             //
  4450.             // $articleChange.throttle(200).subscribe((_) => {
  4451.             //     if (shouldLog) console.log("extract $articleChange");
  4452.             //     let headings = extractHeadings(article);
  4453.             //     if (headings && headings.length) {
  4454.             //         $headings(headings);
  4455.             //     }
  4456.             // });
  4457.         }
  4458.  
  4459.         return [article, $headings];
  4460.     }
  4461.  
  4462.     ////////////////////////////////
  4463.  
  4464.     let toc;
  4465.     let autoGenTocTimerId;
  4466.  
  4467.     const doGenerateToc = function (option = {}) {
  4468.         let [article, $headings] = extract();
  4469.         if (article && $headings && $headings().length) {
  4470.             // console.log("createTOC before old begin aaa");
  4471.             // console.log($headings());
  4472.             // console.log("createTOC before old end bbb");
  4473.  
  4474.             return createTOC(Object.assign({ article, $headings }, option));
  4475.         } else {
  4476.             return null;
  4477.         }
  4478.     };
  4479.  
  4480.     function handleToc() {
  4481.         var domain2shouldShow = GM_getValue("menu_GAEEScript_auto_open_toc");
  4482.         // console.log("[handleToc domain2shouldShow]", domain2shouldShow);
  4483.         // console.log("[handleToc window.location.host]", window.location.host);
  4484.         // console.log(
  4485.         //     "[domain2shouldShow[window.location.host]]",
  4486.         //     domain2shouldShow[window.location.host]
  4487.         // );
  4488.         if (autoGenTocTimerId) {
  4489.             clearInterval(autoGenTocTimerId);
  4490.         }
  4491.         autoGenTocTimerId = setInterval(() => {
  4492.             if (shouldLog)
  4493.                 console.log(
  4494.                     "[handleToc regen toc window.location.host]",
  4495.                     window.location.host
  4496.                 );
  4497.             if (toc && toc.isValid()) {
  4498.                 // clearInterval(timerId); 如果不注释的话, 就会终止这个 timer 从而导致在页面未刷新但是标题改变的时候无法自动生成最新的标题
  4499.                 // return;
  4500.             }
  4501.             if (!domain2shouldShow[window.location.host]) {
  4502.                 // 防止正在循环尝试生成 toc 的时候用户关闭了 toc 开关
  4503.                 return;
  4504.             }
  4505.             if (toc && !toc.isValid()) {
  4506.                 if (shouldLog)
  4507.                     console.log(
  4508.                         "[handleToc regen toc window.location.host, toc && !toc.isValid()]",
  4509.                         window.location.host
  4510.                     );
  4511.                 let lastState = toc.dispose();
  4512.                 toc = doGenerateToc(lastState);
  4513.             } else if (toc == null) {
  4514.                 if (shouldLog)
  4515.                     console.log(
  4516.                         "[handleToc regen toc window.location.host, toc == null]",
  4517.                         window.location.host
  4518.                     );
  4519.                 toc = doGenerateToc();
  4520.             }
  4521.         }, 1600);
  4522.  
  4523.         if (domain2shouldShow[window.location.host]) {
  4524.             toc = doGenerateToc();
  4525.             // console.log("[handleToc toc]", toc);
  4526.             // 如果生成的toc有问题或者toc没生成出来, 那就 n 秒之后再生成一次(比如掘金的很多文章得过几秒钟再生成才行)
  4527.             // toast('Will generate TOC in 2.8 seconds ...', 1600);
  4528.             setTimeout(() => {
  4529.                 if ((toc && !toc.isValid()) || toc == null) {
  4530.                     toast("No article/headings are detected.");
  4531.                 }
  4532.             }, 3800);
  4533.         } else {
  4534.             console.log("[handleToc should not show]", toc);
  4535.             if (toc) {
  4536.                 toc.dispose();
  4537.             }
  4538.         }
  4539.     }
  4540.  
  4541.     //////////////////////////////////////// A watcher to monitor pixel changes on the display.
  4542.     let lastWindowScreenWidth = window.screen.width;
  4543.     function checkMonitorWidthChange() {
  4544.         // console.log("[auto_toc] - check checkkkkkkkkkkkkkkkkkkcheckkkkkkkkkkkkkkkkkk.");
  4545.         // console.log("[auto_toc] - " + window.screen.width);
  4546.         // console.log("[auto_toc] - " + lastWindowScreenWidth);
  4547.         if (window.screen.width != lastWindowScreenWidth) {
  4548.             toast("window.screen.width changed.");
  4549.             if (shouldLog) console.log("[auto_toc] - window.screen.width changed.");
  4550.             lastWindowScreenWidth = window.screen.width;
  4551.             handleToc();
  4552.         }
  4553.     }
  4554.  
  4555.     //////////////////////////////////////// 所有网站-缩小图片
  4556.     function shrinkImg(from_menu_switch = false) {
  4557.         var domain2shouldShrinkImg = GM_getValue("menu_GAEEScript_shrink_img");
  4558.         var shouldShrinkImg = domain2shouldShrinkImg[window.location.host];
  4559.         // console.log(
  4560.         //     "[shrinkImg] begin"
  4561.         // );
  4562.         let shouldNotShrink = shouldShrinkImg == null || !shouldShrinkImg;
  4563.         if (!from_menu_switch && shouldNotShrink) {
  4564.             return;
  4565.         }
  4566.         let cssTxt = "";
  4567.         const shrinkWidth = "88";
  4568.         const shrinkWidthStr = shrinkWidth + "px";
  4569.         Array.from(document.getElementsByTagName("*")).forEach((ele) => {
  4570.             if (ele.tagName === "IMG" && !ele.closest("header")) {
  4571.                 if (shouldNotShrink) {
  4572.                     ele.style.width = ele.style.originalWidth;
  4573.                     // ele.style.height = ele.style.originalHeight;
  4574.                     ele.style.maxHeight = ele.style.originalMaxHeight;
  4575.                     ele.style.minHeight = ele.style.originalMinHeight;
  4576.                     ele.style.maxWidth = ele.style.originalMaxWidth;
  4577.                     ele.style.minWidth = ele.style.originalMinWidth;
  4578.                     ele.style.transition = "";
  4579.                 } else {
  4580.                     if (ele.width > shrinkWidth) {
  4581.                         // 防止多次缩小同一个图片, 也防止放大本身就很小的图片
  4582.                         const genCSSSelector = (ele) => {
  4583.                             if (ele.id) return `img[id="${ele.id}"]:hover`;
  4584.                             else {
  4585.                                 // if(ele.src.startsWith('data:')) return `img[src="${ele.src}"]:hover`;//base64的src
  4586.                                 if (ele.src.startsWith("data:"))
  4587.                                     return ""; //base64的src
  4588.                                 else {
  4589.                                     const the_src =
  4590.                                         ele.src ||
  4591.                                         ele.getAttribute("_src") ||
  4592.                                         "找不到可用选择器";
  4593.                                     //http的src
  4594.                                     try {
  4595.                                         const url = new URL(the_src); //_src是一些网站懒加载的
  4596.                                         return `img[src="${
  4597.                                             url.pathname + url.search
  4598.                                         }"]:hover,img[src="${the_src}"]:hover`;
  4599.                                     } catch (e) {
  4600.                                         console.log(
  4601.                                             "[shrinkImg] ERROR: " + e.message
  4602.                                         );
  4603.                                         return "";
  4604.                                     }
  4605.                                 }
  4606.                             }
  4607.                         };
  4608.                         let cssSelectorStr = genCSSSelector(ele);
  4609.                         if (cssSelectorStr != "") {
  4610.                             if (!ele.style.originalWidth || from_menu_switch) {
  4611.                                 // 防止不是打开开关导致的多次缩小同一个图片
  4612.                                 ele.style.originalWidth = ele.width + "px";
  4613.                                 // ele.style.originalHeight = ele.height + "px";  // 不记录这个了, 时不时拿到的是0
  4614.                                 ele.style.originalMaxHeight =
  4615.                                     ele.style.maxHeight;
  4616.                                 ele.style.originalMinHeight =
  4617.                                     ele.style.minHeight;
  4618.                                 ele.style.originalMaxWidth = ele.style.maxWidth;
  4619.                                 ele.style.originalMinWidth = ele.style.minWidth;
  4620.                                 ele.style.cssSelectorStr = cssSelectorStr;
  4621.  
  4622.                                 // // 加这个div的原因: 为了解决当img缩小之后导致标题间隔变化, toc 跳转会不准(注释了是因为会导致单击了知乎的图片之后缩小的时候知乎网页崩溃)
  4623.                                 // let parent = document.createElement('div');//  新建父元素
  4624.                                 // ele.parentNode.replaceChild(parent,ele);//  获取子元素原来的父元素并将新父元素代替子元素
  4625.                                 // parent.appendChild(ele);//  在新父元素下添加原来的子元素
  4626.                                 // // 设置新div元素的样式
  4627.                                 // parent.style.display = "flex";
  4628.                                 // parent.style.alignItems = "center";
  4629.                                 // parent.style.width = ele.width + "px";
  4630.                                 // parent.style.height = ele.height + "px";
  4631.  
  4632.                                 cssTxt +=
  4633.                                     cssSelectorStr +
  4634.                                     `{` +
  4635.                                     // `width:${ele.width}px !important;height:${ele.height}px !important;` +
  4636.                                     `width:${ele.width}px !important;height:auto !important;` +
  4637.                                     // `width:${ele.width}px !important;` +
  4638.                                     `}`;
  4639.                                 ele.style.width = shrinkWidthStr;
  4640.                                 ele.style.height = "auto";
  4641.                                 ele.style.maxHeight = "";
  4642.                                 ele.style.minHeight = "";
  4643.                                 ele.style.maxWidth = "";
  4644.                                 ele.style.minWidth = "";
  4645.                                 ele.style.transition = isSafari()
  4646.                                     ? "width 0.2s ease, height 0.2s ease"
  4647.                                     : "width 0.3s linear(0 0%, 0 1.8%, 0.01 3.6%, 0.03 6.35%, 0.07 9.1%, 0.13 11.4%, 0.19 13.4%, 0.27 15%, 0.34 16.1%, 0.54 18.35%, 0.66 20.6%, 0.72 22.4%, 0.77 24.6%, 0.81 27.3%, 0.85 30.4%, 0.88 35.1%, 0.92 40.6%, 0.94 47.2%, 0.96 55%, 0.98 64%, 0.99 74.4%, 1 86.4%, 1 100%) 0s, height 0.3s linear(0 0%, 0 1.8%, 0.01 3.6%, 0.03 6.35%, 0.07 9.1%, 0.13 11.4%, 0.19 13.4%, 0.27 15%, 0.34 16.1%, 0.54 18.35%, 0.66 20.6%, 0.72 22.4%, 0.77 24.6%, 0.81 27.3%, 0.85 30.4%, 0.88 35.1%, 0.92 40.6%, 0.94 47.2%, 0.96 55%, 0.98 64%, 0.99 74.4%, 1 86.4%, 1 100%) 0s";
  4648.                             }
  4649.                         }
  4650.                     }
  4651.                 }
  4652.             }
  4653.         });
  4654.  
  4655.         if (shouldNotShrink) {
  4656.             removeCSS("shrinkimg__css");
  4657.             setTimeout(handleToc, 600); // 重新生成toc的原因: 为了解决当img恢复 放大 之后导致标题间隔变化, toc 跳转会不准
  4658.         } else {
  4659.             if (cssTxt != "") {
  4660.                 insertCSS(cssTxt, "shrinkimg__css");
  4661.                 setTimeout(handleToc, 600); // 重新生成toc的原因: 为了解决当img 缩小 之后导致标题间隔变化, toc 跳转会不准
  4662.             }
  4663.             setTimeout(shrinkImg, 800);
  4664.         }
  4665.         // console.log(
  4666.         //     "[shrinkImg] end"
  4667.         // );
  4668.     }
  4669.  
  4670.     var menu_ALL = [
  4671.             [
  4672.                 "menu_GAEEScript_auto_open_toc",
  4673.                 "Enable TOC On Current Site(当前网站TOC开关)",
  4674.                 {},
  4675.             ],
  4676.             [
  4677.                 "menu_GAEEScript_auto_collapse_toc",
  4678.                 "Collapse TOC on current site(当前网站TOC自动折叠开关)",
  4679.                 {},
  4680.             ],
  4681.             [
  4682.                 "menu_GAEEScript_shrink_img",
  4683.                 "Touch Fish On Current Site(当前网站摸鱼开关)",
  4684.                 {},
  4685.             ],
  4686.         ],
  4687.         menu_ID = [];
  4688.  
  4689.     function handleMenu() {
  4690.         // console.log("")
  4691.         for (let i = 0; i < menu_ALL.length; i++) {
  4692.             // 如果读取到的值为 null 就写入默认值
  4693.             // console.log("debug ssss")
  4694.             if (GM_getValue(menu_ALL[i][0]) == null) {
  4695.                 // console.log("debug ssss 11")
  4696.                 GM_setValue(menu_ALL[i][0], menu_ALL[i][2]);
  4697.             }
  4698.         }
  4699.         registerMenuCommand();
  4700.     }
  4701.  
  4702.     // 注册(不可用)脚本菜单
  4703.     function registerMenuCommand() {
  4704.         for (let i = 0; i < menu_ID.length; i++) {
  4705.             // 因为 safari 的各个油猴平台都还没支持好 GM_unregisterMenuCommand , 所以先只让非 safari 的跑, 这会导致 safari 里用户关闭显示 toc 开关的时候, 相关菜单的✅不会变成❎
  4706.             if (!isSafari()) {
  4707.                 // alert("非safari");
  4708.                 GM_unregisterMenuCommand(menu_ID[i]);
  4709.             }
  4710.             // console.log("debug ssss 22, bb")
  4711.         }
  4712.         for (let i = 0; i < menu_ALL.length; i++) {
  4713.             // 循环注册(不可用)脚本菜单
  4714.             var currLocalStorage = GM_getValue(menu_ALL[i][0]);
  4715.             menu_ID[menu_ID.length + 1] = GM_registerMenuCommand(
  4716.                 `${currLocalStorage[window.location.host] ? "✅" : "❎"} ${
  4717.                     menu_ALL[i][1]
  4718.                 }`,
  4719.                 // `${menu_ALL[i][1]}`,
  4720.                 function () {
  4721.                     menuSwitch(`${menu_ALL[i][0]}`);
  4722.                 }
  4723.             );
  4724.             // menu_ID[menu_ID.length + 1] = GM_registerMenuCommand(
  4725.             //     `${currLocalStorage[window.location.host] ? '✅' : '❎'} ${window.location.host}`,
  4726.             //     function () {
  4727.             //         menuSwitch(`${menu_ALL[i][0]}`)
  4728.             //     }
  4729.             // );
  4730.         }
  4731.         // menu_ID[menu_ID.length] = GM_registerMenuCommand(`🏁 当前版本 ${version}`);
  4732.         //menu_ID[menu_ID.length] = GM_registerMenuCommand('💬 反馈 & 建议', function () {window.GM_openInTab('', {active: true,insert: true,setParent: true});});
  4733.     }
  4734.  
  4735.     //切换选项
  4736.     function menuSwitch(localStorageKeyName) {
  4737.         var domain2isCollapse = GM_getValue(
  4738.             "menu_GAEEScript_auto_collapse_toc"
  4739.         );
  4740.         if (localStorageKeyName === "menu_GAEEScript_auto_open_toc") {
  4741.             var domain2isShow = GM_getValue(`${localStorageKeyName}`);
  4742.             var domain2width2offset = GM_getValue(
  4743.                 "menu_GAEEScript_auto_toc_domain_2_width_2_offset"
  4744.             );
  4745.             console.log(
  4746.                 "[auto_toc] - [menuSwitch menu_GAEEScript_auto_open_toc]",
  4747.                 domain2isShow
  4748.             );
  4749.             var isCurrShow = domain2isShow[window.location.host];
  4750.             if (isCurrShow == null || !isCurrShow) {
  4751.                 domain2isShow[window.location.host] = true;
  4752.                 toast("Turn On TOC.");
  4753.             } else {
  4754.                 delete domain2isShow[window.location.host];
  4755.                 delete domain2width2offset[window.location.host];
  4756.                 delete domain2isCollapse[window.location.host];
  4757.  
  4758.                 toast("Turn Off TOC.");
  4759.             }
  4760.             GM_setValue(`${localStorageKeyName}`, domain2isShow);
  4761.             GM_setValue(
  4762.                 "menu_GAEEScript_auto_toc_domain_2_width_2_offset",
  4763.                 domain2width2offset
  4764.             );
  4765.             GM_setValue("menu_GAEEScript_auto_collapse_toc", domain2isCollapse);
  4766.             handleToc();
  4767.         } else if (
  4768.             localStorageKeyName === "menu_GAEEScript_auto_collapse_toc"
  4769.         ) {
  4770.             console.log(
  4771.                 "[menuSwitch menu_GAEEScript_auto_collapse_toc]",
  4772.                 domain2isCollapse
  4773.             );
  4774.             var isCurrDim = domain2isCollapse[window.location.host];
  4775.             if (isCurrDim == null || !isCurrDim) {
  4776.                 domain2isCollapse[window.location.host] = true;
  4777.                 toast("Turn On TOC Auto Collapse.");
  4778.             } else {
  4779.                 delete domain2isCollapse[window.location.host];
  4780.                 toast("Turn Off TOC Auto Collapse.");
  4781.             }
  4782.             GM_setValue(`${localStorageKeyName}`, domain2isCollapse);
  4783.             handleToc();
  4784.         } else if (localStorageKeyName === "menu_GAEEScript_shrink_img") {
  4785.             var domain2shouldShrinkImg = GM_getValue(
  4786.                 "menu_GAEEScript_shrink_img"
  4787.             );
  4788.             console.log(
  4789.                 "[menuSwitch menu_GAEEScript_shrink_img]",
  4790.                 domain2shouldShrinkImg
  4791.             );
  4792.             var shouldShrinkImg = domain2shouldShrinkImg[window.location.host];
  4793.             if (shouldShrinkImg == null || !shouldShrinkImg) {
  4794.                 domain2shouldShrinkImg[window.location.host] = true;
  4795.                 toast("Turn On Shrink IMG.");
  4796.             } else {
  4797.                 delete domain2shouldShrinkImg[window.location.host];
  4798.                 toast("Turn Off Shrink IMG.");
  4799.             }
  4800.             GM_setValue(`${localStorageKeyName}`, domain2shouldShrinkImg);
  4801.             shrinkImg(true);
  4802.         }
  4803.         // 因为 safari 的各个油猴平台都还没支持好 GM_unregisterMenuCommand , 所以先只让非 safari 的跑, 这会导致 safari 里用户关闭显示 toc 开关的时候, 相关菜单的✅不会变成❎
  4804.         if (!isSafari()) {
  4805.             // alert("非safari");
  4806.             registerMenuCommand(); // 重新注册(不可用)脚本菜单
  4807.         }
  4808.         // location.reload(); // 刷新网页
  4809.     }
  4810.  
  4811.     let isMf = false;
  4812.     try {
  4813.         isMf = isMasterFrame(window);
  4814.     } catch (e) {}
  4815.     if (isMf) {
  4816.         // if (true) {
  4817.         console.log("[auto_toc] - running !!!");
  4818.         // 貌似无用
  4819.         // 可以检查pageshow 事件的persisted属性，当页面初始化加载的时候，persisted被设置为false，当页面从缓存中加载的时候，persisted被设置为true。因此，上面代码的意思就是：
  4820.         // 如果页面是从缓存中加载的，那么页面重新加载。
  4821.         // window.onpageshow = function(event) {
  4822.         //     if (event.persisted) {
  4823.         //         // window.location.reload()
  4824.         //         console.log("ex-smart-toc handle toc when open web from cache !!!")
  4825.         //         handleToc()
  4826.         //     }
  4827.         // };
  4828.  
  4829.         // if( ('onhashchange' in window) && ((typeof document.documentMode==='undefined') || document.documentMode==8)) {
  4830.         //     // 浏览器支持onhashchange事件
  4831.         //     console.log("ex-smart-toc register window.onhashchange to handleToc !!!")
  4832.         //     // window.onhashchange = handleToc;  // 对应新的hash执行的操作函数
  4833.         //     window.onhashchange = function(event) {
  4834.         //         console.log("ex-smart-toc window.onhashchange trigger handleToc !!!")
  4835.         //         handleToc()
  4836.         //     }
  4837.         // } else {
  4838.         // 不支持则用定时器检测的办法
  4839.         //     setInterval(function() {
  4840.         //         // 检测hash值或其中某一段是否更改的函数， 在低版本的iE浏览器中通过window.location.hash取出的指和其它的浏览器不同，要注意
  4841.         // 　　　　 var ischanged = isHashChanged();
  4842.         //         if(ischanged) {
  4843.         //             handleToc();  // 对应新的hash执行的操作函数
  4844.         //         }
  4845.         //     }, 150);
  4846.         // }
  4847.  
  4848.         handleMenu();
  4849.  
  4850.         const urlObj = new URL(window.location.href);
  4851.         if (urlObj.host.indexOf("zhihu.com") >= 0) {
  4852.             //////////////////////////////////////// 知乎-向下翻时自动隐藏顶栏&自动重定向
  4853.             console.log("[auto_toc] - [hide-top-bar-when-scroll-down-and-auto-redirect]");
  4854.  
  4855.             function zhihuAutoRedirect() {
  4856.                 let nodes = document.querySelectorAll(
  4857.                     ".RichText a[href*='//link.zhihu.com/?target']"
  4858.                 );
  4859.                 for (let i = 0; i < nodes.length; i++) {
  4860.                     let url = decodeURIComponent(
  4861.                         nodes[i].href.replace(
  4862.                             /https?:\/\/link\.zhihu\.com\/\?target=/,
  4863.                             ""
  4864.                         )
  4865.                     );
  4866.                     nodes[i].href = url;
  4867.                 }
  4868.             }
  4869.             setTimeout(zhihuAutoRedirect, 10);
  4870.             setTimeout(zhihuAutoRedirect, 500);
  4871.             for (let i = 1; i <= 66; i++) {
  4872.                 setTimeout(zhihuAutoRedirect, 1000 * i);
  4873.             }
  4874.  
  4875.             let style = "";
  4876.             let style_3 = `/* 向下翻时自动隐藏顶栏*/
  4877.                 header.is-hidden {display: none;}
  4878.             `;
  4879.             style += style_3;
  4880.             let style_Add = document.createElement("style");
  4881.  
  4882.             if (document.lastChild) {
  4883.                 document.lastChild.appendChild(style_Add).textContent = style;
  4884.             } else {
  4885.                 // 避免网站加载速度太慢的备用措施
  4886.                 let timer1 = setInterval(function () {
  4887.                     // 每 10 毫秒检查一下 html 是否已存在
  4888.                     if (document.lastChild) {
  4889.                         clearInterval(timer1); // 取消定时器
  4890.                         document.lastChild.appendChild(style_Add).textContent =
  4891.                             style;
  4892.                     }
  4893.                 }, 10);
  4894.             }
  4895.         } else if (urlObj.host.indexOf("www.google.com") >= 0) {
  4896.             //////////////////////////////////////// google-禁止重定向
  4897.             console.log("[auto_toc] - [anti-google-redirect]");
  4898.             function redirectHandle() {
  4899.                 try {
  4900.                     let resultNodes = document.querySelectorAll(
  4901.                         ".g .rc a, #rs, #rso .g a"
  4902.                     );
  4903.                     for (let i = 0; i < resultNodes.length; i++) {
  4904.                         let one = resultNodes[i];
  4905.                         one.setAttribute("onmousedown", ""); // 谷歌去重定向干扰
  4906.                         one.setAttribute("target", "_blank"); // 谷歌链接新标签打开
  4907.                         one.setAttribute("data-jsarwt", "0"); // Firefox谷歌去重定向干扰
  4908.                     }
  4909.                 } catch (e) {
  4910.                     console.log(e);
  4911.                 }
  4912.             }
  4913.  
  4914.             setTimeout(redirectHandle, 10);
  4915.             setTimeout(redirectHandle, 500);
  4916.             for (let i = 1; i <= 66; i++) {
  4917.                 setTimeout(redirectHandle, 1000 * i);
  4918.             }
  4919.         } else if (urlObj.host.indexOf("programmercarl.com") >= 0) {
  4920.             //////////////////////////////////////// 代码随想录 把leetcode.cn 替换为 leetcode.com
  4921.             console.log("[auto_toc] - [replace-leetcode-cn-to-com]");
  4922.             function replaceLeetCodeLinks() {
  4923.                 // 获取页面上所有的<a>元素
  4924.                 const links = document.querySelectorAll("a");
  4925.  
  4926.                 // 遍历这些链接
  4927.                 links.forEach((link) => {
  4928.                     // 检查链接的href属性是否包含'leetcode.cn'
  4929.                     if (link.href.includes("leetcode.cn")) {
  4930.                         // 使用字符串的replace方法替换'leetcode.cn'为'leetcode.com'
  4931.                         // 注意：这里假设链接的协议部分（如http://或https://）之后直接跟着'leetcode.cn'
  4932.                         // 如果链接的格式更复杂，你可能需要调整正则表达式来更准确地匹配和替换
  4933.                         link.href = link.href.replace(
  4934.                             /leetcode\.cn/g,
  4935.                             "leetcode.com"
  4936.                         );
  4937.  
  4938.                         // 如果链接的href属性中可能包含子域名（如www.leetcode.cn），你可能需要更复杂的替换逻辑
  4939.                         // 例如，使用正则表达式来匹配整个域名部分
  4940.                         // link.href = link.href.replace(/https?:\/\/[^\/]*leetcode\.cn\//g, 'https://leetcode.com/');
  4941.                     }
  4942.                 });
  4943.             }
  4944.  
  4945.             // setInterval(replaceLeetCodeLinks, 1000);
  4946.  
  4947.             // because programmercarl.com is a single-page website, so we have to add some history observer to trigger the replacer.
  4948.             (function () {
  4949.                 const observer = new MutationObserver(() => {
  4950.                     console.log("[auto_toc] - DOM mutation detected. Current URL:", window.location.href);
  4951.                     replaceLeetCodeLinks();
  4952.                 });
  4953.  
  4954.                 observer.observe(document, { childList: true, subtree: true });
  4955.  
  4956.                 const originalPushState = history.pushState;
  4957.                 history.pushState = function (...args) {
  4958.                     console.log("[auto_toc] - pushState called. URL changed to:", args[2]);
  4959.                     replaceLeetCodeLinks();
  4960.                     observer.disconnect();
  4961.                     observer.observe(document, {
  4962.                         childList: true,
  4963.                         subtree: true,
  4964.                     });
  4965.                     return originalPushState.apply(this, args);
  4966.                 };
  4967.  
  4968.                 const originalReplaceState = history.replaceState;
  4969.                 history.replaceState = function (...args) {
  4970.                     console.log("[auto_toc] - replaceState called. URL changed to:", args[2]);
  4971.                     replaceLeetCodeLinks();
  4972.                     observer.disconnect();
  4973.                     observer.observe(document, {
  4974.                         childList: true,
  4975.                         subtree: true,
  4976.                     });
  4977.                     return originalReplaceState.apply(this, args);
  4978.                 };
  4979.  
  4980.                 window.addEventListener("popstate", () => {
  4981.                     console.log("[auto_toc] - URL changed via back/forward navigation:", window.location.href);
  4982.                 });
  4983.             })();
  4984.         }
  4985.  
  4986.         //////////////////////////////////////// 所有网站-缩小图片
  4987.         var domain2shouldShrinkImg = GM_getValue("menu_GAEEScript_shrink_img");
  4988.         var shouldShrinkImg = domain2shouldShrinkImg[window.location.host];
  4989.         let shouldNotShrink = shouldShrinkImg == null || !shouldShrinkImg;
  4990.         if (!shouldNotShrink) {
  4991.             console.log("[auto_toc] - [shrinkImg]");
  4992.             setTimeout(shrinkImg, 10);
  4993.         }
  4994.  
  4995.         //////////////////////////////////////// 所有网站-生成toc
  4996.         if (GM_getValue("menu_GAEEScript_auto_toc_domain_2_width_2_offset") == null) {
  4997.             GM_setValue("menu_GAEEScript_auto_toc_domain_2_width_2_offset", {});
  4998.         }
  4999.         if (GM_getValue("menu_GAEEScript_auto_collapse_toc") == null) {
  5000.             GM_setValue("menu_GAEEScript_auto_collapse_toc", {});
  5001.         }
  5002.  
  5003.         // A watcher to monitor pixel changes on the display
  5004.         setInterval(checkMonitorWidthChange, 6800);
  5005.  
  5006.         handleToc();
  5007.     }
  5008. })();
  5009.  
  5010. // TEST:
  5011. // pass: https://zhuanlan.zhihu.com/p/336727285
  5012. // pass: https://zhuanlan.zhihu.com/p/643656433
  5013. // pass: https://mp.weixin.qq.com/s/IovIZChwAIIT_kmI7Ry7Aw
  5014. // pass: https://mp.weixin.qq.com/s/QI-Bymo9VBzJaM1lWIE_SA
  5015. // pass: https://mp.weixin.qq.com/s/hMFUINwCpEdLBoZsnPmjzQ
  5016. // pass: https://mp.weixin.qq.com/s?__biz=MzkxNTUwODgzNA==&mid=2247518770&idx=1&sn=0061e739096b2a412f2d19a380444fc5&chksm=c15cd13ff62b5829b33bdb056d0da847d4633ece54ec88516c1de7f4b8c5fea231b04fbe5d99&rd2werd=1#wechat_redirect
  5017. // pass: https://mp.weixin.qq.com/s/FXMFfWcycz55_iI23qFT-Q
  5018. // pass: https://mp.weixin.qq.com/s/ZFFOhKmshOkosgdksFo_Og
  5019. // pass: https://mp.weixin.qq.com/s/f3TKUPy63-U61wjfvIC4zA
  5020. // pass: https://mp.weixin.qq.com/s/CrmouLum_XHlRmjnKW8BrQ

欢迎访问Greasy Fork镜像

土豆服务器，请按需使用

镜像地址随时可能被墙，建议加群获取最新地址

加入Q群

QingJ © 2025

镜像随时可能失效，请加Q群300939539或关注我们的公众号极客氢云获取最新地址