☰

下载CSDN、简书、掘金、博客园、微信公众号、知乎专栏、脚本之家、51CTO、程序员大本营、吾爱破解、B站、思否、轻识、腾讯云、阿里云、华为云等文章保存为Word/Markdown文件

下载保存博客文章为word/markdown,已支持CSDN、简书、掘金、知乎专栏、博客园、微信公众号、脚本之家、51CTO、程序员大本营、吾爱破解、腾讯云、阿里云、华为云、B站专栏、思否、轻识、百家号、百度经验、码农教程等，脚本仅限学习，请大家尊重版权。

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

  1. // ==UserScript==
  2. // @name         下载CSDN、简书、掘金、博客园、微信公众号、知乎专栏、脚本之家、51CTO、程序员大本营、吾爱破解、B站、思否、轻识、腾讯云、阿里云、华为云等文章保存为Word/Markdown文件
  3. // @namespace    https://waahah.xyz/
  4. // @version      0.1.9
  5. // @description  下载保存博客文章为word/markdown,已支持CSDN、简书、掘金、知乎专栏、博客园、微信公众号、脚本之家、51CTO、程序员大本营、吾爱破解、腾讯云、阿里云、华为云、B站专栏、思否、轻识、百家号、百度经验、码农教程等，脚本仅限学习，请大家尊重版权。
  6. // @author       waahah
  7. // @require      https://unpkg.com/html-docx-js/dist/html-docx.js
  8. // @match        *://blog.csdn.net/*
  9. // @match        *://www.jianshu.com/p/*
  10. // @match        *://juejin.cn/post/*
  11. // @match        *://zhuanlan.zhihu.com/p/*
  12. // @match        *://www.cnblogs.com/*/p/*
  13. // @match        *://www.cnblogs.com/*/archive/*
  14. // @match        *://www.jb51.net/article/*
  15. // @match        *://blog.51cto.com/u_*
  16. // @match        *://www.pianshen.com/article/*
  17. // @match        *://www.360doc.com/content/*
  18. // @match        *://baijiahao.baidu.com/s?id=*
  19. // @match        *://jingyan.baidu.com/article/*
  20. // @match        *://www.52pojie.cn/thread-*
  21. // @match        *://cloud.tencent.com/developer/article/*
  22. // @match        *://developer.aliyun.com/article/*
  23. // @match        *://huaweicloud.csdn.net/*
  24. // @match        *://www.bilibili.com/read/*
  25. // @match        *://weibo.com/ttarticle/p/show*
  26. // @match        *://www.weibo.com/ttarticle/p/show*
  27. // @match        *://mp.weixin.qq.com/s*
  28. // @match        *://segmentfault.com/*/*
  29. // @match        *://www.qinglite.cn/doc/*
  30. // @match        *://www.manongjc.com/detail*
  31. // @license      Apache-2.0
  32. // @icon         data:image/svg+xml,%3Csvg t='1691941995383' class='icon' viewBox='0 0 1024 1024' version='1.1' xmlns='http://www.w3.org/2000/svg' p-id='1514' width='200' height='200'%3E%3Cpath d='M320 864 320 0l480 0 0 192 0 32L1024 224l0 640L320 864zM928 320l-512 0 0 32 512 0L928 320zM928 448l-512 0 0 32 512 0L928 448zM928 576l-512 0 0 32 512 0L928 576zM928 704l-512 0 0 32 512 0L928 704zM832 0l19.2 0L1024 160 1024 192l-192 0L832 0zM288 896l320 0L704 896l0 128L0 1024 0 160l288 0 0 320-192 0L96 512l192 0 0 96-192 0L96 640l192 0 0 96-192 0L96 768l192 0 0 96-192 0L96 896 288 896z' p-id='1515'%3E%3C/path%3E%3C/svg%3E
  33. // @grant        none
  34. // @run-at       document-idle
  35. // ==/UserScript==
  36.  
  37. //修复支持表格、删除线、任务列表、checkbox任务
  38. var turndownPluginGfm = (function (exports) {
  39.     'use strict';
  40.  
  41.     var highlightRegExp = /highlight-(?:text|source)-([a-z0-9]+)/;
  42.  
  43.     function highlightedCodeBlock(turndownService) {
  44.         turndownService.addRule('highlightedCodeBlock', {
  45.             filter: function (node) {
  46.                 var firstChild = node.firstChild;
  47.                 return (
  48.                     node.nodeName === 'DIV' &&
  49.                     highlightRegExp.test(node.className) &&
  50.                     firstChild &&
  51.                     firstChild.nodeName === 'PRE'
  52.                 )
  53.             },
  54.             replacement: function (content, node, options) {
  55.                 var className = node.className || '';
  56.                 var language = (className.match(highlightRegExp) || [null, ''])[1];
  57.  
  58.                 return (
  59.                     '\n\n' + options.fence + language + '\n' +
  60.                     node.firstChild.textContent +
  61.                     '\n' + options.fence + '\n\n'
  62.                 )
  63.             }
  64.         });
  65.     }
  66.  
  67.     function strikethrough(turndownService) {
  68.         turndownService.addRule('strikethrough', {
  69.             filter: ['del', 's', 'strike'],
  70.             replacement: function (content) {
  71.                 return '~' + content + '~'
  72.             }
  73.         });
  74.     }
  75.  
  76.     var indexOf = Array.prototype.indexOf;
  77.     var every = Array.prototype.every;
  78.     var rules = {};
  79.  
  80.     rules.tableCell = {
  81.         filter: ['th', 'td'],
  82.         replacement: function (content, node) {
  83.             return cell(content, node)
  84.         }
  85.     };
  86.  
  87.     rules.tableRow = {
  88.         filter: 'tr',
  89.         replacement: function (content, node) {
  90.             var borderCells = '';
  91.             var alignMap = { left: ':--', right: '--:', center: ':-:' };
  92.  
  93.             if (isHeadingRow(node)) {
  94.                 for (var i = 0; i < node.childNodes.length; i++) {
  95.                     var border = '---';
  96.                     var align = (
  97.                         node.childNodes[i].getAttribute('align') || ''
  98.                     ).toLowerCase();
  99.  
  100.                     if (align) border = alignMap[align] || border;
  101.  
  102.                     borderCells += cell(border, node.childNodes[i]);
  103.                 }
  104.             }
  105.             return '\n' + content + (borderCells ? '\n' + borderCells : '')
  106.         }
  107.     };
  108.  
  109.     rules.table = {
  110.         // Only convert tables with a heading row.
  111.         // Tables with no heading row are kept using `keep` (see below).
  112.         filter: function (node) {
  113.             return node.nodeName === 'TABLE' && isHeadingRow(node.rows[0])
  114.         },
  115.  
  116.         replacement: function (content) {
  117.             // Ensure there are no blank lines
  118.             content = content.replace('\n\n', '\n');
  119.             return '\n\n' + content + '\n\n'
  120.         }
  121.     };
  122.  
  123.     rules.tableSection = {
  124.         filter: ['thead', 'tbody', 'tfoot'],
  125.         replacement: function (content) {
  126.             return content
  127.         }
  128.     };
  129.  
  130.     // A tr is a heading row if:
  131.     // - the parent is a THEAD
  132.     // - or if its the first child of the TABLE or the first TBODY (possibly
  133.     //   following a blank THEAD)
  134.     // - and every cell is a TH
  135.     function isHeadingRow(tr) {
  136.         var parentNode = tr.parentNode;
  137.         return (
  138.             parentNode.nodeName === 'THEAD' ||
  139.             (
  140.                 parentNode.firstChild === tr &&
  141.                 (parentNode.nodeName === 'TABLE' || isFirstTbody(parentNode)) &&
  142.                 every.call(tr.childNodes, function (n) { return n.nodeName === 'TH' })
  143.             )
  144.         )
  145.     }
  146.  
  147.     function isFirstTbody(element) {
  148.         var previousSibling = element.previousSibling;
  149.         return (
  150.             element.nodeName === 'TBODY' && (
  151.                 !previousSibling ||
  152.                 (
  153.                     previousSibling.nodeName === 'THEAD' &&
  154.                     /^\s*$/i.test(previousSibling.textContent)
  155.                 )
  156.             )
  157.         )
  158.     }
  159.  
  160.     function cell(content, node) {
  161.         var index = indexOf.call(node.parentNode.childNodes, node);
  162.         var prefix = ' ';
  163.         if (index === 0) prefix = '| ';
  164.         return prefix + content + ' |'
  165.     }
  166.  
  167.     function tables(turndownService) {
  168.         turndownService.keep(function (node) {
  169.             return node.nodeName === 'TABLE' && !isHeadingRow(node.rows[0])
  170.         });
  171.         for (var key in rules) turndownService.addRule(key, rules[key]);
  172.     }
  173.  
  174.     function taskListItems(turndownService) {
  175.         turndownService.addRule('taskListItems', {
  176.             filter: function (node) {
  177.                 return node.type === 'checkbox' && node.parentNode.nodeName === 'LI'
  178.             },
  179.             replacement: function (content, node) {
  180.                 return (node.checked ? '[x]' : '[ ]') + ' '
  181.             }
  182.         });
  183.     }
  184.  
  185.     function gfm(turndownService) {
  186.         turndownService.use([
  187.             highlightedCodeBlock,
  188.             strikethrough,
  189.             tables,
  190.             taskListItems
  191.         ]);
  192.     }
  193.  
  194.     exports.gfm = gfm;
  195.     exports.highlightedCodeBlock = highlightedCodeBlock;
  196.     exports.strikethrough = strikethrough;
  197.     exports.tables = tables;
  198.     exports.taskListItems = taskListItems;
  199.  
  200.     return exports;
  201.  
  202. }({}));
  203.  
  204.  
  205. var TurndownService = (function () {
  206.     'use strict';
  207.  
  208.     function extend(destination) {
  209.         for (var i = 1; i < arguments.length; i++) {
  210.             var source = arguments[i];
  211.             for (var key in source) {
  212.                 if (source.hasOwnProperty(key)) destination[key] = source[key];
  213.             }
  214.         }
  215.         return destination
  216.     }
  217.  
  218.     function repeat(character, count) {
  219.         return Array(count + 1).join(character)
  220.     }
  221.  
  222.     function trimLeadingNewlines(string) {
  223.         return string.replace(/^\n*/, '')
  224.     }
  225.  
  226.     function trimTrailingNewlines(string) {
  227.         // avoid match-at-end regexp bottleneck, see #370
  228.         var indexEnd = string.length;
  229.         while (indexEnd > 0 && string[indexEnd - 1] === '\n') indexEnd--;
  230.         return string.substring(0, indexEnd)
  231.     }
  232.  
  233.     var blockElements = [
  234.         'ADDRESS', 'ARTICLE', 'ASIDE', 'AUDIO', 'BLOCKQUOTE', 'BODY', 'CANVAS',
  235.         'CENTER', 'DD', 'DIR', 'DIV', 'DL', 'DT', 'FIELDSET', 'FIGCAPTION', 'FIGURE',
  236.         'FOOTER', 'FORM', 'FRAMESET', 'H1', 'H2', 'H3', 'H4', 'H5', 'H6', 'HEADER',
  237.         'HGROUP', 'HR', 'HTML', 'ISINDEX', 'LI', 'MAIN', 'MENU', 'NAV', 'NOFRAMES',
  238.         'NOSCRIPT', 'OL', 'OUTPUT', 'P', 'PRE', 'SECTION', 'TABLE', 'TBODY', 'TD',
  239.         'TFOOT', 'TH', 'THEAD', 'TR', 'UL'
  240.     ];
  241.  
  242.     function isBlock(node) {
  243.         return is(node, blockElements)
  244.     }
  245.  
  246.     var voidElements = [
  247.         'AREA', 'BASE', 'BR', 'COL', 'COMMAND', 'EMBED', 'HR', 'IMG', 'INPUT',
  248.         'KEYGEN', 'LINK', 'META', 'PARAM', 'SOURCE', 'TRACK', 'WBR'
  249.     ];
  250.  
  251.     function isVoid(node) {
  252.         return is(node, voidElements)
  253.     }
  254.  
  255.     function hasVoid(node) {
  256.         return has(node, voidElements)
  257.     }
  258.  
  259.     var meaningfulWhenBlankElements = [
  260.         'A', 'TABLE', 'THEAD', 'TBODY', 'TFOOT', 'TH', 'TD', 'IFRAME', 'SCRIPT',
  261.         'AUDIO', 'VIDEO'
  262.     ];
  263.  
  264.     function isMeaningfulWhenBlank(node) {
  265.         return is(node, meaningfulWhenBlankElements)
  266.     }
  267.  
  268.     function hasMeaningfulWhenBlank(node) {
  269.         return has(node, meaningfulWhenBlankElements)
  270.     }
  271.  
  272.     function is(node, tagNames) {
  273.         return tagNames.indexOf(node.nodeName) >= 0
  274.     }
  275.  
  276.     function has(node, tagNames) {
  277.         return (
  278.             node.getElementsByTagName &&
  279.             tagNames.some(function (tagName) {
  280.                 return node.getElementsByTagName(tagName).length
  281.             })
  282.         )
  283.     }
  284.  
  285.     var rules = {};
  286.  
  287.     rules.paragraph = {
  288.         filter: 'p',
  289.  
  290.         replacement: function (content) {
  291.             return '\n\n' + content + '\n\n'
  292.         }
  293.     };
  294.  
  295.     rules.lineBreak = {
  296.         filter: 'br',
  297.  
  298.         replacement: function (content, node, options) {
  299.             return options.br + '\n'
  300.         }
  301.     };
  302.  
  303.     rules.heading = {
  304.         filter: ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'],
  305.  
  306.         replacement: function (content, node, options) {
  307.             var hLevel = Number(node.nodeName.charAt(1));
  308.  
  309.             if (options.headingStyle === 'setext' && hLevel < 3) {
  310.                 var underline = repeat((hLevel === 1 ? '=' : '-'), content.length);
  311.                 return (
  312.                     '\n\n' + content + '\n' + underline + '\n\n'
  313.                 )
  314.             } else {
  315.                 return '\n\n' + repeat('#', hLevel) + ' ' + content + '\n\n'
  316.             }
  317.         }
  318.     };
  319.  
  320.     rules.blockquote = {
  321.         filter: 'blockquote',
  322.  
  323.         replacement: function (content) {
  324.             content = content.replace(/^\n+|\n+$/g, '');
  325.             content = content.replace(/^/gm, '> ');
  326.             return '\n\n' + content + '\n\n'
  327.         }
  328.     };
  329.  
  330.     rules.list = {
  331.         filter: ['ul', 'ol'],
  332.  
  333.         replacement: function (content, node) {
  334.             var parent = node.parentNode;
  335.             if (parent.nodeName === 'LI' && parent.lastElementChild === node) {
  336.                 return '\n' + content
  337.             } else {
  338.                 return '\n\n' + content + '\n\n'
  339.             }
  340.         }
  341.     };
  342.  
  343.     rules.listItem = {
  344.         filter: 'li',
  345.  
  346.         replacement: function (content, node, options) {
  347.             content = content
  348.                 .replace(/^\n+/, '') // remove leading newlines
  349.                 .replace(/\n+$/, '\n') // replace trailing newlines with just a single one
  350.                 .replace(/\n/gm, '\n    '); // indent
  351.             var prefix = options.bulletListMarker + '   ';
  352.             var parent = node.parentNode;
  353.             if (parent.nodeName === 'OL') {
  354.                 var start = parent.getAttribute('start');
  355.                 var index = Array.prototype.indexOf.call(parent.children, node);
  356.                 prefix = (start ? Number(start) + index : index + 1) + '.  ';
  357.             }
  358.             return (
  359.                 prefix + content + (node.nextSibling && !/\n$/.test(content) ? '\n' : '')
  360.             )
  361.         }
  362.     };
  363.  
  364.     rules.indentedCodeBlock = {
  365.         filter: function (node, options) {
  366.             return (
  367.                 options.codeBlockStyle === 'indented' &&
  368.                 node.nodeName === 'PRE' &&
  369.                 node.firstChild &&
  370.                 node.firstChild.nodeName === 'CODE'
  371.             )
  372.         },
  373.  
  374.         replacement: function (content, node, options) {
  375.             return (
  376.                 '\n\n    ' +
  377.                 node.firstChild.textContent.replace(/\n/g, '\n    ') +
  378.                 '\n\n'
  379.             )
  380.         }
  381.     };
  382.  
  383.     rules.fencedCodeBlock = {
  384.         filter: function (node, options) {
  385.             return (
  386.                 options.codeBlockStyle === 'fenced' &&
  387.                 node.nodeName === 'PRE' &&
  388.                 node.firstChild &&
  389.                 node.firstChild.nodeName === 'CODE'
  390.             )
  391.         },
  392.  
  393.         replacement: function (content, node, options) {
  394.             var className = node.firstChild.getAttribute('class') || '';
  395.             var language = (className.match(/language-(\S+)/) || [null, ''])[1];
  396.             var code = node.firstChild.textContent;
  397.  
  398.             var fenceChar = options.fence.charAt(0);
  399.             var fenceSize = 3;
  400.             var fenceInCodeRegex = new RegExp('^' + fenceChar + '{3,}', 'gm');
  401.  
  402.             var match;
  403.             while ((match = fenceInCodeRegex.exec(code))) {
  404.                 if (match[0].length >= fenceSize) {
  405.                     fenceSize = match[0].length + 1;
  406.                 }
  407.             }
  408.  
  409.             var fence = repeat(fenceChar, fenceSize);
  410.  
  411.             return (
  412.                 '\n\n' + fence + language + '\n' +
  413.                 code.replace(/\n$/, '') +
  414.                 '\n' + fence + '\n\n'
  415.             )
  416.         }
  417.     };
  418.  
  419.     rules.horizontalRule = {
  420.         filter: 'hr',
  421.  
  422.         replacement: function (content, node, options) {
  423.             return '\n\n' + options.hr + '\n\n'
  424.         }
  425.     };
  426.  
  427.     rules.inlineLink = {
  428.         filter: function (node, options) {
  429.             return (
  430.                 options.linkStyle === 'inlined' &&
  431.                 node.nodeName === 'A' &&
  432.                 node.getAttribute('href')
  433.             )
  434.         },
  435.  
  436.         replacement: function (content, node) {
  437.             var href = node.getAttribute('href');
  438.             var title = cleanAttribute(node.getAttribute('title'));
  439.             if (title) title = ' "' + title + '"';
  440.             return '[' + content + '](' + href + title + ')'
  441.         }
  442.     };
  443.  
  444.     rules.referenceLink = {
  445.         filter: function (node, options) {
  446.             return (
  447.                 options.linkStyle === 'referenced' &&
  448.                 node.nodeName === 'A' &&
  449.                 node.getAttribute('href')
  450.             )
  451.         },
  452.  
  453.         replacement: function (content, node, options) {
  454.             var href = node.getAttribute('href');
  455.             var title = cleanAttribute(node.getAttribute('title'));
  456.             if (title) title = ' "' + title + '"';
  457.             var replacement;
  458.             var reference;
  459.  
  460.             switch (options.linkReferenceStyle) {
  461.                 case 'collapsed':
  462.                     replacement = '[' + content + '][]';
  463.                     reference = '[' + content + ']: ' + href + title;
  464.                     break
  465.                 case 'shortcut':
  466.                     replacement = '[' + content + ']';
  467.                     reference = '[' + content + ']: ' + href + title;
  468.                     break
  469.                 default:
  470.                     var id = this.references.length + 1;
  471.                     replacement = '[' + content + '][' + id + ']';
  472.                     reference = '[' + id + ']: ' + href + title;
  473.             }
  474.  
  475.             this.references.push(reference);
  476.             return replacement
  477.         },
  478.  
  479.         references: [],
  480.  
  481.         append: function (options) {
  482.             var references = '';
  483.             if (this.references.length) {
  484.                 references = '\n\n' + this.references.join('\n') + '\n\n';
  485.                 this.references = []; // Reset references
  486.             }
  487.             return references
  488.         }
  489.     };
  490.  
  491.     rules.emphasis = {
  492.         filter: ['em', 'i'],
  493.  
  494.         replacement: function (content, node, options) {
  495.             if (!content.trim()) return ''
  496.             return options.emDelimiter + content + options.emDelimiter
  497.         }
  498.     };
  499.  
  500.     rules.strong = {
  501.         filter: ['strong', 'b'],
  502.  
  503.         replacement: function (content, node, options) {
  504.             if (!content.trim()) return ''
  505.             return options.strongDelimiter + content + options.strongDelimiter
  506.         }
  507.     };
  508.  
  509.     rules.code = {
  510.         filter: function (node) {
  511.             var hasSiblings = node.previousSibling || node.nextSibling;
  512.             var isCodeBlock = node.parentNode.nodeName === 'PRE' && !hasSiblings;
  513.  
  514.             return node.nodeName === 'CODE' && !isCodeBlock
  515.         },
  516.  
  517.         replacement: function (content) {
  518.             if (!content) return ''
  519.             content = content.replace(/\r?\n|\r/g, ' ');
  520.  
  521.             var extraSpace = /^`|^ .*?[^ ].* $|`$/.test(content) ? ' ' : '';
  522.             var delimiter = '`';
  523.             var matches = content.match(/`+/gm) || [];
  524.             while (matches.indexOf(delimiter) !== -1) delimiter = delimiter + '`';
  525.  
  526.             return delimiter + extraSpace + content + extraSpace + delimiter
  527.         }
  528.     };
  529.  
  530.     rules.image = {
  531.         filter: 'img',
  532.  
  533.         replacement: function (content, node) {
  534.             var alt = cleanAttribute(node.getAttribute('alt'));
  535.             var src = node.getAttribute('src') || '';
  536.             var title = cleanAttribute(node.getAttribute('title'));
  537.             var titlePart = title ? ' "' + title + '"' : '';
  538.             return src ? '![' + alt + ']' + '(' + src + titlePart + ')' : ''
  539.         }
  540.     };
  541.  
  542.     function cleanAttribute(attribute) {
  543.         return attribute ? attribute.replace(/(\n+\s*)+/g, '\n') : ''
  544.     }
  545.  
  546.     /**
  547.      * Manages a collection of rules used to convert HTML to Markdown
  548.      */
  549.  
  550.     function Rules(options) {
  551.         this.options = options;
  552.         this._keep = [];
  553.         this._remove = [];
  554.  
  555.         this.blankRule = {
  556.             replacement: options.blankReplacement
  557.         };
  558.  
  559.         this.keepReplacement = options.keepReplacement;
  560.  
  561.         this.defaultRule = {
  562.             replacement: options.defaultReplacement
  563.         };
  564.  
  565.         this.array = [];
  566.         for (var key in options.rules) this.array.push(options.rules[key]);
  567.     }
  568.  
  569.     Rules.prototype = {
  570.         add: function (key, rule) {
  571.             this.array.unshift(rule);
  572.         },
  573.  
  574.         keep: function (filter) {
  575.             this._keep.unshift({
  576.                 filter: filter,
  577.                 replacement: this.keepReplacement
  578.             });
  579.         },
  580.  
  581.         remove: function (filter) {
  582.             this._remove.unshift({
  583.                 filter: filter,
  584.                 replacement: function () {
  585.                     return ''
  586.                 }
  587.             });
  588.         },
  589.  
  590.         forNode: function (node) {
  591.             if (node.isBlank) return this.blankRule
  592.             var rule;
  593.  
  594.             if ((rule = findRule(this.array, node, this.options))) return rule
  595.             if ((rule = findRule(this._keep, node, this.options))) return rule
  596.             if ((rule = findRule(this._remove, node, this.options))) return rule
  597.  
  598.             return this.defaultRule
  599.         },
  600.  
  601.         forEach: function (fn) {
  602.             for (var i = 0; i < this.array.length; i++) fn(this.array[i], i);
  603.         }
  604.     };
  605.  
  606.     function findRule(rules, node, options) {
  607.         for (var i = 0; i < rules.length; i++) {
  608.             var rule = rules[i];
  609.             if (filterValue(rule, node, options)) return rule
  610.         }
  611.         return void 0
  612.     }
  613.  
  614.     function filterValue(rule, node, options) {
  615.         var filter = rule.filter;
  616.         if (typeof filter === 'string') {
  617.             if (filter === node.nodeName.toLowerCase()) return true
  618.         } else if (Array.isArray(filter)) {
  619.             if (filter.indexOf(node.nodeName.toLowerCase()) > -1) return true
  620.         } else if (typeof filter === 'function') {
  621.             if (filter.call(rule, node, options)) return true
  622.         } else {
  623.             throw new TypeError('`filter` needs to be a string, array, or function')
  624.         }
  625.     }
  626.  
  627.     /**
  628.      * The collapseWhitespace function is adapted from collapse-whitespace
  629.      * by Luc Thevenard.
  630.      *
  631.      * The MIT License (MIT)
  632.      *
  633.      * Copyright (c) 2014 Luc Thevenard <lucthevenard@gmail.com>
  634.      *
  635.      * Permission is hereby granted, free of charge, to any person obtaining a copy
  636.      * of this software and associated documentation files (the "Software"), to deal
  637.      * in the Software without restriction, including without limitation the rights
  638.      * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  639.      * copies of the Software, and to permit persons to whom the Software is
  640.      * furnished to do so, subject to the following conditions:
  641.      *
  642.      * The above copyright notice and this permission notice shall be included in
  643.      * all copies or substantial portions of the Software.
  644.      *
  645.      * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  646.      * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  647.      * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  648.      * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  649.      * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  650.      * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  651.      * THE SOFTWARE.
  652.      */
  653.  
  654.     /**
  655.      * collapseWhitespace(options) removes extraneous whitespace from an the given element.
  656.      *
  657.      * @param {Object} options
  658.      */
  659.     function collapseWhitespace(options) {
  660.         var element = options.element;
  661.         var isBlock = options.isBlock;
  662.         var isVoid = options.isVoid;
  663.         var isPre = options.isPre || function (node) {
  664.             return node.nodeName === 'PRE'
  665.         };
  666.  
  667.         if (!element.firstChild || isPre(element)) return
  668.  
  669.         var prevText = null;
  670.         var keepLeadingWs = false;
  671.  
  672.         var prev = null;
  673.         var node = next(prev, element, isPre);
  674.  
  675.         while (node !== element) {
  676.             if (node.nodeType === 3 || node.nodeType === 4) { // Node.TEXT_NODE or Node.CDATA_SECTION_NODE
  677.                 var text = node.data.replace(/[ \r\n\t]+/g, ' ');
  678.  
  679.                 if ((!prevText || / $/.test(prevText.data)) &&
  680.                     !keepLeadingWs && text[0] === ' ') {
  681.                     text = text.substr(1);
  682.                 }
  683.  
  684.                 // `text` might be empty at this point.
  685.                 if (!text) {
  686.                     node = remove(node);
  687.                     continue
  688.                 }
  689.  
  690.                 node.data = text;
  691.  
  692.                 prevText = node;
  693.             } else if (node.nodeType === 1) { // Node.ELEMENT_NODE
  694.                 if (isBlock(node) || node.nodeName === 'BR') {
  695.                     if (prevText) {
  696.                         prevText.data = prevText.data.replace(/ $/, '');
  697.                     }
  698.  
  699.                     prevText = null;
  700.                     keepLeadingWs = false;
  701.                 } else if (isVoid(node) || isPre(node)) {
  702.                     // Avoid trimming space around non-block, non-BR void elements and inline PRE.
  703.                     prevText = null;
  704.                     keepLeadingWs = true;
  705.                 } else if (prevText) {
  706.                     // Drop protection if set previously.
  707.                     keepLeadingWs = false;
  708.                 }
  709.             } else {
  710.                 node = remove(node);
  711.                 continue
  712.             }
  713.  
  714.             var nextNode = next(prev, node, isPre);
  715.             prev = node;
  716.             node = nextNode;
  717.         }
  718.  
  719.         if (prevText) {
  720.             prevText.data = prevText.data.replace(/ $/, '');
  721.             if (!prevText.data) {
  722.                 remove(prevText);
  723.             }
  724.         }
  725.     }
  726.  
  727.     /**
  728.      * remove(node) removes the given node from the DOM and returns the
  729.      * next node in the sequence.
  730.      *
  731.      * @param {Node} node
  732.      * @return {Node} node
  733.      */
  734.     function remove(node) {
  735.         var next = node.nextSibling || node.parentNode;
  736.  
  737.         node.parentNode.removeChild(node);
  738.  
  739.         return next
  740.     }
  741.  
  742.     /**
  743.      * next(prev, current, isPre) returns the next node in the sequence, given the
  744.      * current and previous nodes.
  745.      *
  746.      * @param {Node} prev
  747.      * @param {Node} current
  748.      * @param {Function} isPre
  749.      * @return {Node}
  750.      */
  751.     function next(prev, current, isPre) {
  752.         if ((prev && prev.parentNode === current) || isPre(current)) {
  753.             return current.nextSibling || current.parentNode
  754.         }
  755.  
  756.         return current.firstChild || current.nextSibling || current.parentNode
  757.     }
  758.  
  759.     /*
  760.      * Set up window for Node.js
  761.      */
  762.  
  763.     var root = (typeof window !== 'undefined' ? window : {});
  764.  
  765.     /*
  766.      * Parsing HTML strings
  767.      */
  768.  
  769.     function canParseHTMLNatively() {
  770.         var Parser = root.DOMParser;
  771.         var canParse = false;
  772.  
  773.         // Adapted from https://gist.github.com/1129031
  774.         // Firefox/Opera/IE throw errors on unsupported types
  775.         try {
  776.             // WebKit returns null on unsupported types
  777.             if (new Parser().parseFromString('', 'text/html')) {
  778.                 canParse = true;
  779.             }
  780.         } catch (e) { }
  781.  
  782.         return canParse
  783.     }
  784.  
  785.     function createHTMLParser() {
  786.         var Parser = function () { };
  787.  
  788.         {
  789.             if (shouldUseActiveX()) {
  790.                 Parser.prototype.parseFromString = function (string) {
  791.                     var doc = new window.ActiveXObject('htmlfile');
  792.                     doc.designMode = 'on'; // disable on-page scripts
  793.                     doc.open();
  794.                     doc.write(string);
  795.                     doc.close();
  796.                     return doc
  797.                 };
  798.             } else {
  799.                 Parser.prototype.parseFromString = function (string) {
  800.                     var doc = document.implementation.createHTMLDocument('');
  801.                     doc.open();
  802.                     doc.write(string);
  803.                     doc.close();
  804.                     return doc
  805.                 };
  806.             }
  807.         }
  808.         return Parser
  809.     }
  810.  
  811.     function shouldUseActiveX() {
  812.         var useActiveX = false;
  813.         try {
  814.             document.implementation.createHTMLDocument('').open();
  815.         } catch (e) {
  816.             if (window.ActiveXObject) useActiveX = true;
  817.         }
  818.         return useActiveX
  819.     }
  820.  
  821.     var HTMLParser = canParseHTMLNatively() ? root.DOMParser : createHTMLParser();
  822.  
  823.     function RootNode(input, options) {
  824.         var root;
  825.         if (typeof input === 'string') {
  826.             var doc = htmlParser().parseFromString(
  827.                 // DOM parsers arrange elements in the <head> and <body>.
  828.                 // Wrapping in a custom element ensures elements are reliably arranged in
  829.                 // a single element.
  830.                 '<x-turndown id="turndown-root">' + input + '</x-turndown>',
  831.                 'text/html'
  832.             );
  833.             root = doc.getElementById('turndown-root');
  834.         } else {
  835.             root = input.cloneNode(true);
  836.         }
  837.         collapseWhitespace({
  838.             element: root,
  839.             isBlock: isBlock,
  840.             isVoid: isVoid,
  841.             isPre: options.preformattedCode ? isPreOrCode : null
  842.         });
  843.  
  844.         return root
  845.     }
  846.  
  847.     var _htmlParser;
  848.     function htmlParser() {
  849.         _htmlParser = _htmlParser || new HTMLParser();
  850.         return _htmlParser
  851.     }
  852.  
  853.     function isPreOrCode(node) {
  854.         return node.nodeName === 'PRE' || node.nodeName === 'CODE'
  855.     }
  856.  
  857.     function Node(node, options) {
  858.         node.isBlock = isBlock(node);
  859.         node.isCode = node.nodeName === 'CODE' || node.parentNode.isCode;
  860.         node.isBlank = isBlank(node);
  861.         node.flankingWhitespace = flankingWhitespace(node, options);
  862.         return node
  863.     }
  864.  
  865.     function isBlank(node) {
  866.         return (
  867.             !isVoid(node) &&
  868.             !isMeaningfulWhenBlank(node) &&
  869.             /^\s*$/i.test(node.textContent) &&
  870.             !hasVoid(node) &&
  871.             !hasMeaningfulWhenBlank(node)
  872.         )
  873.     }
  874.  
  875.     function flankingWhitespace(node, options) {
  876.         if (node.isBlock || (options.preformattedCode && node.isCode)) {
  877.             return { leading: '', trailing: '' }
  878.         }
  879.  
  880.         var edges = edgeWhitespace(node.textContent);
  881.  
  882.         // abandon leading ASCII WS if left-flanked by ASCII WS
  883.         if (edges.leadingAscii && isFlankedByWhitespace('left', node, options)) {
  884.             edges.leading = edges.leadingNonAscii;
  885.         }
  886.  
  887.         // abandon trailing ASCII WS if right-flanked by ASCII WS
  888.         if (edges.trailingAscii && isFlankedByWhitespace('right', node, options)) {
  889.             edges.trailing = edges.trailingNonAscii;
  890.         }
  891.  
  892.         return { leading: edges.leading, trailing: edges.trailing }
  893.     }
  894.  
  895.     function edgeWhitespace(string) {
  896.         var m = string.match(/^(([ \t\r\n]*)(\s*))(?:(?=\S)[\s\S]*\S)?((\s*?)([ \t\r\n]*))$/);
  897.         return {
  898.             leading: m[1], // whole string for whitespace-only strings
  899.             leadingAscii: m[2],
  900.             leadingNonAscii: m[3],
  901.             trailing: m[4], // empty for whitespace-only strings
  902.             trailingNonAscii: m[5],
  903.             trailingAscii: m[6]
  904.         }
  905.     }
  906.  
  907.     function isFlankedByWhitespace(side, node, options) {
  908.         var sibling;
  909.         var regExp;
  910.         var isFlanked;
  911.  
  912.         if (side === 'left') {
  913.             sibling = node.previousSibling;
  914.             regExp = / $/;
  915.         } else {
  916.             sibling = node.nextSibling;
  917.             regExp = /^ /;
  918.         }
  919.  
  920.         if (sibling) {
  921.             if (sibling.nodeType === 3) {
  922.                 isFlanked = regExp.test(sibling.nodeValue);
  923.             } else if (options.preformattedCode && sibling.nodeName === 'CODE') {
  924.                 isFlanked = false;
  925.             } else if (sibling.nodeType === 1 && !isBlock(sibling)) {
  926.                 isFlanked = regExp.test(sibling.textContent);
  927.             }
  928.         }
  929.         return isFlanked
  930.     }
  931.  
  932.     var reduce = Array.prototype.reduce;
  933.     var escapes = [
  934.         [/\\/g, '\\\\'],
  935.         [/\*/g, '\\*'],
  936.         [/^-/g, '\\-'],
  937.         [/^\+ /g, '\\+ '],
  938.         [/^(=+)/g, '\\$1'],
  939.         [/^(#{1,6}) /g, '\\$1 '],
  940.         [/`/g, '\\`'],
  941.         [/^~~~/g, '\\~~~'],
  942.         [/\[/g, '\\['],
  943.         [/\]/g, '\\]'],
  944.         [/^>/g, '\\>'],
  945.         [/_/g, '\\_'],
  946.         [/^(\d+)\. /g, '$1\\. ']
  947.     ];
  948.  
  949.     function TurndownService(options) {
  950.         if (!(this instanceof TurndownService)) return new TurndownService(options)
  951.  
  952.         var defaults = {
  953.             rules: rules,
  954.             headingStyle: 'setext',
  955.             hr: '* * *',
  956.             bulletListMarker: '*',
  957.             codeBlockStyle: 'indented',
  958.             fence: '```',
  959.             emDelimiter: '_',
  960.             strongDelimiter: '**',
  961.             linkStyle: 'inlined',
  962.             linkReferenceStyle: 'full',
  963.             br: '  ',
  964.             preformattedCode: false,
  965.             blankReplacement: function (content, node) {
  966.                 return node.isBlock ? '\n\n' : ''
  967.             },
  968.             keepReplacement: function (content, node) {
  969.                 return node.isBlock ? '\n\n' + node.outerHTML + '\n\n' : node.outerHTML
  970.             },
  971.             defaultReplacement: function (content, node) {
  972.                 return node.isBlock ? '\n\n' + content + '\n\n' : content
  973.             }
  974.         };
  975.         this.options = extend({}, defaults, options);
  976.         this.rules = new Rules(this.options);
  977.     }
  978.  
  979.     TurndownService.prototype = {
  980.         /**
  981.          * The entry point for converting a string or DOM node to Markdown
  982.          * @public
  983.          * @param {String|HTMLElement} input The string or DOM node to convert
  984.          * @returns A Markdown representation of the input
  985.          * @type String
  986.          */
  987.  
  988.         turndown: function (input) {
  989.             if (!canConvert(input)) {
  990.                 throw new TypeError(
  991.                     input + ' is not a string, or an element/document/fragment node.'
  992.                 )
  993.             }
  994.  
  995.             if (input === '') return ''
  996.  
  997.             var output = process.call(this, new RootNode(input, this.options));
  998.             return postProcess.call(this, output)
  999.         },
  1000.  
  1001.         /**
  1002.          * Add one or more plugins
  1003.          * @public
  1004.          * @param {Function|Array} plugin The plugin or array of plugins to add
  1005.          * @returns The Turndown instance for chaining
  1006.          * @type Object
  1007.          */
  1008.  
  1009.         use: function (plugin) {
  1010.             if (Array.isArray(plugin)) {
  1011.                 for (var i = 0; i < plugin.length; i++) this.use(plugin[i]);
  1012.             } else if (typeof plugin === 'function') {
  1013.                 plugin(this);
  1014.             } else {
  1015.                 throw new TypeError('plugin must be a Function or an Array of Functions')
  1016.             }
  1017.             return this
  1018.         },
  1019.  
  1020.         /**
  1021.          * Adds a rule
  1022.          * @public
  1023.          * @param {String} key The unique key of the rule
  1024.          * @param {Object} rule The rule
  1025.          * @returns The Turndown instance for chaining
  1026.          * @type Object
  1027.          */
  1028.  
  1029.         addRule: function (key, rule) {
  1030.             this.rules.add(key, rule);
  1031.             return this
  1032.         },
  1033.  
  1034.         /**
  1035.          * Keep a node (as HTML) that matches the filter
  1036.          * @public
  1037.          * @param {String|Array|Function} filter The unique key of the rule
  1038.          * @returns The Turndown instance for chaining
  1039.          * @type Object
  1040.          */
  1041.  
  1042.         keep: function (filter) {
  1043.             this.rules.keep(filter);
  1044.             return this
  1045.         },
  1046.  
  1047.         /**
  1048.          * Remove a node that matches the filter
  1049.          * @public
  1050.          * @param {String|Array|Function} filter The unique key of the rule
  1051.          * @returns The Turndown instance for chaining
  1052.          * @type Object
  1053.          */
  1054.  
  1055.         remove: function (filter) {
  1056.             this.rules.remove(filter);
  1057.             return this
  1058.         },
  1059.  
  1060.         /**
  1061.          * Escapes Markdown syntax
  1062.          * @public
  1063.          * @param {String} string The string to escape
  1064.          * @returns A string with Markdown syntax escaped
  1065.          * @type String
  1066.          */
  1067.  
  1068.         escape: function (string) {
  1069.             return escapes.reduce(function (accumulator, escape) {
  1070.                 return accumulator.replace(escape[0], escape[1])
  1071.             }, string)
  1072.         }
  1073.     };
  1074.  
  1075.     /**
  1076.      * Reduces a DOM node down to its Markdown string equivalent
  1077.      * @private
  1078.      * @param {HTMLElement} parentNode The node to convert
  1079.      * @returns A Markdown representation of the node
  1080.      * @type String
  1081.      */
  1082.  
  1083.     function process(parentNode) {
  1084.         var self = this;
  1085.         return reduce.call(parentNode.childNodes, function (output, node) {
  1086.             node = new Node(node, self.options);
  1087.  
  1088.             var replacement = '';
  1089.             if (node.nodeType === 3) {
  1090.                 replacement = node.isCode ? node.nodeValue : self.escape(node.nodeValue);
  1091.             } else if (node.nodeType === 1) {
  1092.                 replacement = replacementForNode.call(self, node);
  1093.             }
  1094.  
  1095.             return join(output, replacement)
  1096.         }, '')
  1097.     }
  1098.  
  1099.     /**
  1100.      * Appends strings as each rule requires and trims the output
  1101.      * @private
  1102.      * @param {String} output The conversion output
  1103.      * @returns A trimmed version of the ouput
  1104.      * @type String
  1105.      */
  1106.  
  1107.     function postProcess(output) {
  1108.         var self = this;
  1109.         this.rules.forEach(function (rule) {
  1110.             if (typeof rule.append === 'function') {
  1111.                 output = join(output, rule.append(self.options));
  1112.             }
  1113.         });
  1114.  
  1115.         return output.replace(/^[\t\r\n]+/, '').replace(/[\t\r\n\s]+$/, '')
  1116.     }
  1117.  
  1118.     /**
  1119.      * Converts an element node to its Markdown equivalent
  1120.      * @private
  1121.      * @param {HTMLElement} node The node to convert
  1122.      * @returns A Markdown representation of the node
  1123.      * @type String
  1124.      */
  1125.  
  1126.     function replacementForNode(node) {
  1127.         var rule = this.rules.forNode(node);
  1128.         var content = process.call(this, node);
  1129.         var whitespace = node.flankingWhitespace;
  1130.         if (whitespace.leading || whitespace.trailing) content = content.trim();
  1131.         return (
  1132.             whitespace.leading +
  1133.             rule.replacement(content, node, this.options) +
  1134.             whitespace.trailing
  1135.         )
  1136.     }
  1137.  
  1138.     /**
  1139.      * Joins replacement to the current output with appropriate number of new lines
  1140.      * @private
  1141.      * @param {String} output The current conversion output
  1142.      * @param {String} replacement The string to append to the output
  1143.      * @returns Joined output
  1144.      * @type String
  1145.      */
  1146.  
  1147.     function join(output, replacement) {
  1148.         var s1 = trimTrailingNewlines(output);
  1149.         var s2 = trimLeadingNewlines(replacement);
  1150.         var nls = Math.max(output.length - s1.length, replacement.length - s2.length);
  1151.         var separator = '\n\n'.substring(0, nls);
  1152.  
  1153.         return s1 + separator + s2
  1154.     }
  1155.  
  1156.     /**
  1157.      * Determines whether an input can be converted
  1158.      * @private
  1159.      * @param {String|HTMLElement} input Describe this parameter
  1160.      * @returns Describe what it returns
  1161.      * @type String|Object|Array|Boolean|Number
  1162.      */
  1163.  
  1164.     function canConvert(input) {
  1165.         return (
  1166.             input != null && (
  1167.                 typeof input === 'string' ||
  1168.                 (input.nodeType && (
  1169.                     input.nodeType === 1 || input.nodeType === 9 || input.nodeType === 11
  1170.                 ))
  1171.             )
  1172.         )
  1173.     }
  1174.  
  1175.     return TurndownService;
  1176.  
  1177. }());
  1178.  
  1179.  
  1180. (async function() {
  1181.     /**
  1182.     * 遵循开源协议,转载请注明出处谢谢
  1183.     */
  1184.  
  1185.     'use strict';
  1186.     const webUrl = window.location.href;
  1187.     const headline = document.title;
  1188.     const host = location.host;
  1189.  
  1190.     const InterfaceList = [
  1191.         { "host": "blog.csdn.net", "el": "article.baidu_pl", "cut_str": "_" },
  1192.         { "host": "www.jianshu.com", "el": "article._2rhmJa", "cut_str": " - " },
  1193.         { "host": "juejin.cn", "el": ".article-viewer.markdown-body.result", "cut_str": " - " },
  1194.         { "host": "zhuanlan.zhihu.com", "el": ".Post-RichTextContainer", "cut_str": " - " },
  1195.         { "host": "www.cnblogs.com", "el": "#cnblogs_post_body", "cut_str": " - " },
  1196.         { "host": "www.jb51.net", "el": "#content", "cut_str": "_" },
  1197.         { "host": "blog.51cto.com", "el": "#result", "cut_str": "_" },
  1198.         { "host": "www.pianshen.com", "el": ".blogpost-body", "cut_str": " - " },
  1199.         { "host": "www.360doc.com", "el": "#artContent", "cut_str": "" },
  1200.         { "host": "baijiahao.baidu.com", "el": "div[data-testid='article']", "cut_str": "" },
  1201.         { "host": "jingyan.baidu.com", "el": ".exp-content-outer", "cut_str": "-" },
  1202.         { "host": "www.52pojie.cn", "el": ".t_f", "cut_str": " - " },
  1203.         { "host": "cloud.tencent.com", "el": ".mod-content__markdown", "cut_str": "-" },
  1204.         { "host": "developer.aliyun.com", "el": ".content-wrapper", "cut_str": "-" },
  1205.         { "host": "huaweicloud.csdn.net", "el": ".main-content", "cut_str": "_" },
  1206.         { "host": "www.bilibili.com", "el": "#read-article-holder", "cut_str": " - " },
  1207.         { "host": "weibo.com", "el": ".main_editor", "cut_str": "" },
  1208.         { "host": "www.weibo.com", "el": ".main_editor", "cut_str": "" },
  1209.         { "host": "mp.weixin.qq.com", "el": "#js_content", "cut_str": "" },
  1210.         { "host": "segmentfault.com", "el": ".article.fmt.article-content", "cut_str": "- SegmentFault 思否" },
  1211.         { "host": "www.qinglite.cn", "el": ".markdown-body", "cut_str": "-" },
  1212.         { "host": "www.manongjc.com", "el": "#code_example", "cut_str": " - " }
  1213.         
  1214.     ]
  1215.  
  1216.     const utils = {
  1217.  
  1218.         async addMeta () {
  1219.             const meta = document.createElement('meta');
  1220.             meta.setAttribute('http-equiv', "Content-Security-Policy");
  1221.             meta.content = `default-src *; connect-src * ws://* wss://*; style-src * 'unsafe-inline' 'unsafe-eval'; media-src * ; img-src * data:; font-src * ; script-src * 'unsafe-inline' 'unsafe-eval';`;
  1222.             const dom = document.head || document.documentElement;
  1223.             dom.appendChild(meta);
  1224.         },
  1225.  
  1226.         async css (css) {
  1227.             const myStyle = document.createElement('style');
  1228.             myStyle.textContent = css;
  1229.             const doc = document.head || document.documentElement;
  1230.             doc.appendChild(myStyle);
  1231.         },
  1232.     
  1233.         async node (node) {
  1234.             const myDiv = document.createElement('div');
  1235.             myDiv.innerHTML = node;
  1236.             const doc = document.body || document.documentElement;
  1237.             doc.appendChild(myDiv);
  1238.         },
  1239.     
  1240.         async load_web_script (list) {
  1241.             try {
  1242.                 for (const url of list) {
  1243.                     if(!document.querySelector(`script[src="${url}"]`)){
  1244.                         const script = document.createElement("script");
  1245.                         script.src = url;
  1246.                         script.async = false;
  1247.                         document.body.append(script);
  1248.                     }
  1249.                 }
  1250.     
  1251.             } catch (e) {
  1252.                 console.error(e);
  1253.             }
  1254.         },
  1255.  
  1256.         async exportdoc(el, docName) {
  1257.             const elementContent = document.querySelector(el).innerHTML;
  1258.             /*const doc = new Docx();
  1259.             doc.fromHTML(elementContent);
  1260.             doc.createDocx(`${docName}.docx`);*/
  1261.             let wordContent = htmlDocx.asBlob(elementContent);
  1262.             const blobURL = URL.createObjectURL(wordContent);
  1263.             const link = document.createElement('a');
  1264.             link.href = blobURL;
  1265.             link.download = `${docName}.docx`;
  1266.             link.click();
  1267.             URL.revokeObjectURL(blobURL);
  1268.  
  1269.         }
  1270.     }
  1271.  
  1272.  
  1273.     await utils.css(`
  1274.     #zuihuitao {
  1275.         cursor: pointer;
  1276.         position: fixed;
  1277.         top: 100px;
  1278.         left: 0px;
  1279.         width: 0px;
  1280.         z-index: 2147483647;
  1281.         font-size: 12px;
  1282.         text-align: left;
  1283.     }
  1284.  
  1285.     #zuihuitao .logo {
  1286.         position: absolute;
  1287.         right: 0;
  1288.         width: 1.375rem;
  1289.         padding: 10px 2px;
  1290.         text-align: center;
  1291.         color: #fff;
  1292.         cursor: auto;
  1293.         user-select: none;
  1294.         border-radius: 0 4px 4px 0;
  1295.         transform: translate3d(100%, 5%, 0);
  1296.         background: deepskyblue;
  1297.     }
  1298.  
  1299.     #zuihuitao .die {
  1300.         display: none;
  1301.         position: absolute;
  1302.         left: 24px;
  1303.         top: 0;
  1304.         text-align: center;
  1305.         background-color: #04b4ae;
  1306.         border: 1px solid gray;
  1307.     }
  1308.  
  1309.     #zuihuitao .die li {
  1310.         font-size: 12px;
  1311.         color: #fff;
  1312.         text-align: center;
  1313.         width: 60px;
  1314.         line-height: 21px;
  1315.         float: left;
  1316.         border: 1px solid gray;
  1317.         border-radius: 6px 6px 6px 6px;
  1318.         padding: 0 4px;
  1319.         margin: 4px 2px;
  1320.         list-style-type: none;
  1321.     }
  1322.  
  1323.     #zuihuitao .die li:hover {
  1324.         color: #fff;
  1325.         background: #fe2e64;
  1326.     }
  1327.  
  1328.     @media print {
  1329.         body {
  1330.                 display: block !important;
  1331.         }
  1332.     }
  1333.  
  1334.     * {
  1335.         -webkit-user-select: text;
  1336.         -moz-user-select: text;
  1337.         -ms-user-select: text;
  1338.         user-select: text;
  1339.     }
  1340.  
  1341.     .add {
  1342.         background-color: #fe2e64;
  1343.     }
  1344.  
  1345.     .btn-success {
  1346.         position: fixed;
  1347.         font-weight: 400;
  1348.         color: #fff;
  1349.         background-color: #28a745;
  1350.         border-color: #28a745;
  1351.         text-align: center;
  1352.         vertical-align: middle;
  1353.         border: 1px solid transparent;
  1354.         padding: 0.375rem 0.75rem;
  1355.         font-size: 1rem;
  1356.         line-height: 1.5;
  1357.         border-radius: 0.25rem;
  1358.         z-index: 2147483647;
  1359.         cursor: pointer;
  1360.     }
  1361.     `);
  1362.  
  1363.  
  1364.     const html = `<div id='zuihuitao'>
  1365.         <div class='item_text'>
  1366.             <div class="logo"><a id="m">文档下载</a></div>
  1367.                 <div class='die' >
  1368.                     <div style='display:flex;'>
  1369.                         <div style='width:128px; padding:0px 0;'>
  1370.                         <br>
  1371.                             <div style='font-size:16px; text-align:center; color:#fff; line-height:21px;'>导出Markdown</div>
  1372.                             <ul style='margin:0 24px;'>
  1373.                                 <li id="li0">下载</li>
  1374.                                 <div style='clear:both;'></div>
  1375.                             </ul>
  1376.                             <br>
  1377.                             <div style='font-size:16px; text-align:center; color:#fff; line-height:21px;'>导出Word</div>
  1378.                             <ul style='margin:0 24px;'>
  1379.                                 <li id="li1">下载</li>
  1380.                                 <div style='clear:both;'></div>
  1381.                             </ul>
  1382.                             <br>
  1383.                         </div>
  1384.                     </div>
  1385.                 </div>
  1386.             </div>
  1387.         </div>
  1388.         </div>`;
  1389.  
  1390.     await utils.node(html);
  1391.     document.getElementsByClassName('item_text')[0].addEventListener('mouseover', () => {
  1392.         document.getElementsByClassName('die')[0].style.display = 'block';
  1393.     });
  1394.  
  1395.     document.getElementsByClassName('item_text')[0].addEventListener('mouseout', () => {
  1396.         document.getElementsByClassName('die')[0].style.display = 'none';
  1397.     })
  1398.  
  1399.     const cut_title = async (title, cut_str) => {
  1400.         try{
  1401.             const new_title = title.split(cut_str)[0];
  1402.             return new_title;
  1403.         }
  1404.         catch(e){
  1405.             console.log(e);
  1406.             return title;
  1407.         }
  1408.         
  1409.     }
  1410.  
  1411.     const save_md = async (el, title) => {
  1412.         const turndownService = new TurndownService();
  1413.         const gfm = turndownPluginGfm.gfm;
  1414.         turndownService.use(gfm);
  1415.         turndownService.remove('style');
  1416.         let ele = document.querySelector(el);
  1417.         let markdown = turndownService.turndown(ele);
  1418.         //console.log(markdown);
  1419.         let filename = `${title}.md`;
  1420.         const downloadLink = document.createElement('a');
  1421.         downloadLink.setAttribute('download', filename);
  1422.         let markdownContent = `${markdown}\n\n本文转自 <${webUrl}>，如有侵权，请联系删除。`;
  1423.         //downloadLink.href = 'data:text/plain;charset=utf-8,' + encodeURIComponent(markdownContent);
  1424.         const blob = new Blob([markdownContent], { type: 'text/markdown;charset=utf-8' });
  1425.         let blobURL = URL.createObjectURL(blob);
  1426.         downloadLink.setAttribute('href', blobURL);
  1427.         //document.body.appendChild(downloadLink);
  1428.         downloadLink.click();
  1429.         URL.revokeObjectURL(blob);
  1430.     }
  1431.     
  1432.     const getData = async () => {
  1433.         let new_headline;
  1434.         for (const even in InterfaceList) {
  1435.             if (host == InterfaceList[even].host) {
  1436.                 let ele = InterfaceList[even].el;
  1437.                 let cut = InterfaceList[even].cut_str;
  1438.                 if(cut != ''){
  1439.                     new_headline = await cut_title(headline, cut);
  1440.                 }else{
  1441.                     new_headline = document.title;
  1442.                 }
  1443.  
  1444.                 const data = {
  1445.                     title: new_headline,
  1446.                     el: ele
  1447.                 }
  1448.  
  1449.                 return data;
  1450.             }
  1451.         }
  1452.     }
  1453.  
  1454.     const exportMd = async () => {
  1455.  
  1456.         const data = await getData();
  1457.  
  1458.         await save_md(data.el, data.title);
  1459.  
  1460.     }
  1461.  
  1462.     document.getElementById('li0').addEventListener('click', async () => {
  1463.  
  1464.         await exportMd().then(
  1465.             res => {
  1466.                 document.getElementsByClassName('die')[0].style.block = 'none';
  1467.                 console.log(`文件 ${res}.md 已开始下载~`);
  1468.             }
  1469.         ).catch(
  1470.             err => {
  1471.                 console.log(err);
  1472.             }
  1473.         );
  1474.     });
  1475.  
  1476.     document.getElementById('li1').addEventListener('click', async () => {
  1477.  
  1478.         const data = await getData();
  1479.         await utils.exportdoc(data.el, data.title);
  1480.  
  1481.     });
  1482.     
  1483. })();