☰

auto-toc

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

目前为 2023-10-20 提交的版本。查看 最新版本。

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

欢迎访问Greasy Fork镜像

土豆服务器，请按需使用

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

加入Q群

QingJ © 2025

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