☰

通用脚本重开启选取复制

破解锁右键，解除禁止复制、剪切、选择文本、右键菜单、文字复制、文字选取、图片右键等限制。增强功能：Alt键超连结文字选取。

当前为 2021-06-28 提交的版本，查看 最新版本。

  1. // ==UserScript==
  2. // @name         A Universal Script to Re-Enable the Selection and Copying
  3. // @name:zh-TW   A Universal Script to Re-Enable the Selection and Copying
  4. // @name:zh-CN   通用脚本重开启选取复制
  5. // @version      1.7.10.6
  6. // @icon https://image.flaticon.com/icons/png/128/3848/3848147.png
  7. // @description  Enables select, right-click, copy and drag on pages that disable them. Enhanced Feature: Alt Key HyperLink Text Selection
  8. // @description:zh-TW 破解鎖右鍵，解除禁止復制、剪切、選擇文本、右鍵菜單、文字複製、文字選取、圖片右鍵等限制。增強功能：Alt鍵超連結文字選取。
  9. // @description:zh-CN 破解锁右键，解除禁止复制、剪切、选择文本、右键菜单、文字复制、文字选取、图片右键等限制。增强功能：Alt键超连结文字选取。
  10. // @include      /^https?\:\/\//
  11. // @grant        none
  12. // @run-at       document-start
  13. // @namespace https://greasyfork.org/users/371179
  14. // ==/UserScript==
  15. (function $$() {
  16.     'use strict';
  17.     if (document == null || !document.documentElement) return window.requestAnimationFrame($$); // this is tampermonkey bug?? not sure
  18.     //console.log('script at', location)
  19.  
  20.     function $nil() {}
  21.  
  22.     function isSupportAdvancedEventListener() {
  23.         if ('_b1750' in $) return $._b1750
  24.         var prop = 0;
  25.         document.createAttribute('z').addEventListener('nil', $nil, {
  26.             get passive() {
  27.                 prop++;
  28.             },
  29.             get once() {
  30.                 prop++;
  31.             }
  32.         });
  33.         return ($._b1750 = prop == 2);
  34.     }
  35.  
  36.     function isSupportPassiveEventListener() {
  37.         if ('_b1650' in $) return $._b1650
  38.         var prop = 0;
  39.         document.createAttribute('z').addEventListener('nil', $nil, {
  40.             get passive() {
  41.                 prop++;
  42.             }
  43.         });
  44.         return ($._b1650 = prop == 1);
  45.     }
  46.  
  47.     var getSelection = window.getSelection || Error()(),
  48.         requestAnimationFrame = window.requestAnimationFrame || Error()(),
  49.         getComputedStyle = window.getComputedStyle || Error()();
  50.  
  51.     const $ = {
  52.         utSelectionColorHack: 'msmtwejkzrqa',
  53.         utTapHighlight: 'xfcklblvkjsj',
  54.         utLpSelection: 'gykqyzwufxpz',
  55.         utHoverBlock: 'meefgeibrtqx', //scc_emptyblock
  56.         //utNonEmptyElm: 'ilkpvtsnwmjb',
  57.         utNonEmptyElmPrevElm: 'jttkfplemwzo',
  58.         utHoverTextWrap: 'oseksntfvucn',
  59.         ksFuncReplacerNonFalse: '___dqzadwpujtct___',
  60.         ksEventReturnValue: ' ___ndjfujndrlsx___',
  61.         ksSetData: '___rgqclrdllmhr___',
  62.         ksNonEmptyPlainText: '___grpvyosdjhuk___',
  63.  
  64.         eh_capture_passive: () => isSupportPassiveEventListener() ? ($._eh_capture_passive = ($._eh_capture_passive || {
  65.             capture: true,
  66.             passive: true
  67.         })) : true,
  68.  
  69.         mAlert_DOWN: function() {}, //dummy function in case alert replacement is not valid
  70.         mAlert_UP: function() {}, //dummy function in case alert replacement is not valid
  71.  
  72.  
  73.         lpKeyPressing: false,
  74.         lpKeyPressingPromise: Promise.resolve(),
  75.  
  76.         isNum: (d) => (d > 0 || d < 0 || d === 0),
  77.  
  78.         isAnySelection: function() {
  79.             var sel = getSelection();
  80.             return !sel ? null : (typeof sel.isCollapsed == 'boolean') ? !sel.isCollapsed : (sel.toString().length > 0);
  81.         },
  82.  
  83.         createCSSElement: function(cssStyle, container) {
  84.             var css = document.createElement('style'); //slope: DOM throughout
  85.             css.type = 'text/css';
  86.             css.innerHTML = cssStyle;
  87.             if (container) container.appendChild(css);
  88.             return css;
  89.         },
  90.  
  91.         createFakeAlert: function(_alert) {
  92.             if (typeof _alert != 'function') return null;
  93.  
  94.             function alert(msg) {
  95.                 alert.__isDisabled__() ? console.log("alert msg disabled: ", msg) : _alert.apply(this, arguments);
  96.             };
  97.             alert.toString = () => "function alert() { [native code] }";
  98.             return alert;
  99.         },
  100.  
  101.         createFuncReplacer: function(originalFunc, pName, resFX) {
  102.             resFX = function(ev) {
  103.                 var res = originalFunc.apply(this, arguments);
  104.                 if (!this || this[pName] != resFX) return res; // if this is null or undefined, or this.onXXX is not this function
  105.                 if (res === false) return; // return undefined when "return false;"
  106.                 originalFunc[$.ksFuncReplacerNonFalse] = true;
  107.                 this[pName] = originalFunc; // restore original
  108.                 return res;
  109.             }
  110.             resFX.toString = () => originalFunc.toString();
  111.             return resFX;
  112.         },
  113.  
  114.         listenerDisableAll: function(evt) {
  115.             var elmNode = evt.target;
  116.             var pName = 'on' + evt.type;
  117.             evt = null;
  118.             Promise.resolve().then(() => {
  119.                 while (elmNode && elmNode.nodeType > 0) { //i.e. HTMLDocument or HTMLElement
  120.                     var f = elmNode[pName];
  121.                     if (typeof f == 'function' && f[$.ksFuncReplacerNonFalse] !== true) {
  122.                         var nf = $.createFuncReplacer(f, pName);
  123.                         nf[$.ksFuncReplacerNonFalse] = true;
  124.                         elmNode[pName] = nf;
  125.                     }
  126.                     elmNode = elmNode.parentNode;
  127.                 }
  128.             })
  129.         },
  130.  
  131.         onceCssHighlightSelection: () => {
  132.             if (document.documentElement.hasAttribute($.utLpSelection)) return;
  133.             $.onceCssHighlightSelection = null
  134.             Promise.resolve().then(() => {
  135.                 var s = [...document.querySelectorAll('a,p,div,span,b,i,strong,li')].filter(elm => elm.childElementCount === 0); // randomly pick an element containing text only to avoid css style bug
  136.                 var elm = !s.length ? document.body : s[s.length >> 1];
  137.                 return elm
  138.             }).then(elm => {
  139.                 var selectionStyle = getComputedStyle(elm, ':selection');
  140.                 if (/^rgba\(\d+,\s*\d+,\s*\d+,\s*0\)$/.test(selectionStyle.getPropertyValue('background-color'))) document.documentElement.setAttribute($.utSelectionColorHack, "");
  141.                 return elm;
  142.             }).then(elm => {
  143.                 var elmStyle = getComputedStyle(elm)
  144.                 if (/^rgba\(\d+,\s*\d+,\s*\d+,\s*0\)$/.test(elmStyle.getPropertyValue('-webkit-tap-highlight-color'))) document.documentElement.setAttribute($.utTapHighlight, "");
  145.             })
  146.         },
  147.  
  148.         clipDataProcess: function(clipboardData) {
  149.  
  150.             if (!clipboardData) return;
  151.             const evt = clipboardData[$.ksSetData]; //NOT NULL when preventDefault is called
  152.             if (!evt || evt.clipboardData !== clipboardData) return;
  153.             const plainText = clipboardData[$.ksNonEmptyPlainText]; //NOT NULL when setData is called with non empty input
  154.             if (!plainText) return;
  155.  
  156.             //BOTH preventDefault and setData are called.
  157.  
  158.             if (evt.cancelable !== true || evt.defaultPrevented !== false) return;
  159.             $.bypass = true;
  160.             evt.preventDefault();
  161.             $.bypass = false;
  162.  
  163.  
  164.             var trimedSelectionText = getSelection().toString().trim()
  165.  
  166.             if (trimedSelectionText) {
  167.                 //there is replacement data and the selection is not empty
  168.                 console.log({
  169.                     msg: "copy event - clipboardData replacement is allowed and the selection is not empty",
  170.                     oldText: trimedSelectionText,
  171.                     newText: plainText,
  172.                 })
  173.             } else {
  174.                 //there is replacement data and the selection is empty
  175.                 console.log({
  176.                     msg: "copy event - clipboardData replacement is allowed and the selection is empty",
  177.                     oldText: trimedSelectionText,
  178.                     newText: plainText,
  179.                 })
  180.             }
  181.  
  182.         },
  183.  
  184.         enableSelectClickCopy: function() {
  185.             $.eyEvts = ['keydown', 'keyup', 'copy', 'contextmenu', 'select', 'selectstart', 'dragstart', 'beforecopy']; //slope: throughout
  186.  
  187.             function isDeactivePreventDefault(evt) {
  188.                 if ($.bypass) return false;
  189.                 var j = $.eyEvts.indexOf(evt.type);
  190.                 switch (j) {
  191.                     case 6:
  192.                         if ($.enableDragging) return false;
  193.                         if (evt.target.hasAttribute('draggable')) {
  194.                             $.enableDragging = true;
  195.                             return false;
  196.                         }
  197.                         //if(evt.target.hasAttribute('draggable')&&evt.target!=window.getSelection().anchorNode)return false;
  198.                         return true;
  199.                     case 3:
  200.                         if (evt.target instanceof Element && (evt.target.textContent || "").trim().length === 0) return false; //exclude elements like video
  201.                         return true;
  202.                     case -1:
  203.                         return false;
  204.                     case 0:
  205.                     case 1:
  206.                         return (evt.keyCode == 67 && (evt.ctrlKey || evt.metaKey) && !evt.altKey && !evt.shiftKey && $.isAnySelection() === true);
  207.                     case 2:
  208.                         if (!('clipboardData' in evt && 'setData' in DataTransfer.prototype)) return true; // Event oncopy not supporting clipboardData
  209.                         if (evt.cancelable && evt.defaultPrevented === false) {} else return true;
  210.  
  211.                         if (evt.clipboardData[$.ksSetData] && evt.clipboardData[$.ksSetData] != evt) return true; //in case there is a bug
  212.                         evt.clipboardData[$.ksSetData] = evt;
  213.  
  214.                         $.clipDataProcess(evt.clipboardData);
  215.  
  216.                         return true; //preventDefault in clipDataProcess
  217.  
  218.  
  219.                     default:
  220.                         return true;
  221.                 }
  222.             }
  223.  
  224.             !(function($setData) {
  225.                 DataTransfer.prototype.setData = (function setData() {
  226.  
  227.                     if (arguments[0] == 'text/plain' && typeof arguments[1] == 'string') {
  228.                         if (arguments[1].trim().length > 0) {
  229.                             this[$.ksNonEmptyPlainText] = arguments[1]
  230.                         } else if (this[$.ksNonEmptyPlainText]) {
  231.                             arguments[1] = this[$.ksNonEmptyPlainText]
  232.                         }
  233.                     }
  234.  
  235.                     $.clipDataProcess(this)
  236.  
  237.                     let res = $setData.apply(this, arguments)
  238.  
  239.                     return res;
  240.  
  241.                 })
  242.             })(DataTransfer.prototype.setData);
  243.  
  244.             Object.defineProperties(DataTransfer.prototype, {
  245.                 [$.ksSetData]: { //store the event
  246.                     value: null,
  247.                     writable: true,
  248.                     enumerable: false,
  249.                     configurable: true
  250.                 },
  251.                 [$.ksNonEmptyPlainText]: { //store the text
  252.                     value: null,
  253.                     writable: true,
  254.                     enumerable: false,
  255.                     configurable: true
  256.                 }
  257.             })
  258.  
  259.  
  260.             Event.prototype.preventDefault = (function(f) {
  261.                 function preventDefault() {
  262.                     if (!isDeactivePreventDefault(this)) f.call(this);
  263.                 }
  264.                 preventDefault.toString = () => f.toString();
  265.                 return preventDefault;
  266.             })(Event.prototype.preventDefault);
  267.  
  268.             Object.defineProperty(Event.prototype, "returnValue", {
  269.                 get() {
  270.                     return $.ksEventReturnValue in this ? this[$.ksEventReturnValue] : true;
  271.                 },
  272.                 set(newValue) {
  273.                     if (newValue === false && !isDeactivePreventDefault(this)) this.preventDefault();
  274.                     this[$.ksEventReturnValue] = newValue;
  275.                 },
  276.                 enumerable: true,
  277.                 configurable: true
  278.             });
  279.  
  280.             for (var i = 2, eventsCount = $.eyEvts.length; i < eventsCount; i++) {
  281.                 document.addEventListener($.eyEvts[i], $.listenerDisableAll, true); // Capture Event; passive:false; expected occurrence COMPLETELY before Target Capture and Target Bubble
  282.             }
  283.  
  284.             var _alert = window.alert; //slope: temporary
  285.             if (typeof _alert == 'function') {
  286.                 var _mAlert = $.createFakeAlert(_alert);
  287.                 if (_mAlert) {
  288.                     var clickBlockingTo = 0;
  289.                     _mAlert.__isDisabled__ = () => clickBlockingTo > +new Date;
  290.                     $.mAlert_DOWN = () => (clickBlockingTo = +new Date + 50);
  291.                     $.mAlert_UP = () => (clickBlockingTo = +new Date + 20);
  292.                     window.alert = _mAlert
  293.                 }
  294.             }
  295.  
  296.         },
  297.  
  298.         lpCheckPointer: function(targetElm) {
  299.             if (targetElm && targetElm.nodeType == 1 && targetElm.matches('*:hover')) {
  300.                 if (getComputedStyle(targetElm).getPropertyValue('cursor') == 'pointer' && targetElm.textContent) return true;
  301.             }
  302.             return false;
  303.         },
  304.  
  305.         eventCancel: function(evt, toPreventDefault) {
  306.             $.bypass = true;
  307.             !toPreventDefault || evt.preventDefault()
  308.             evt.stopPropagation();
  309.             evt.stopImmediatePropagation();
  310.             $.bypass = false;
  311.         },
  312.  
  313.         lpHoverBlocks:[],
  314.  
  315.         lpKeyDown: function(evt) {
  316.  
  317.             if (evt.key == "Alt" && $.lpKeyPressing == false && evt.altKey && !evt.ctrlKey && !evt.metaKey && !evt.shiftKey && evt.target) {
  318.                 $.lpKeyPressing = true;
  319.                 if($.cid_lpKeyPressing>0) $.cid_lpKeyPressing=clearTimeout($.cid_lpKeyPressing)
  320.                 $.cid_lpKeyPressing=setTimeout($.lpCancelKeyPressAlt,300);
  321.  
  322.                 const rootNode = $.rootHTML(evt.target);
  323.                 if (rootNode) {
  324.                     let tmp_wmEty = null;
  325.  
  326.  
  327.                     let wmTextWrap = new WeakMap();
  328.  
  329.                     $.lpKeyPressingPromise = $.lpKeyPressingPromise.then(() => {
  330.                         for (const elm of $.lpHoverBlocks) {
  331.                             elm.removeAttribute($.utNonEmptyElmPrevElm)
  332.                             elm.removeAttribute($.utHoverTextWrap)
  333.                         }
  334.                         $.lpHoverBlocks.length=0;
  335.                     }).then(() => {
  336.                         tmp_wmEty = new WeakMap(); // 1,2,3.....: non-empty elm,  -1:empty elm
  337.                         const s = [...rootNode.querySelectorAll('*:not(button, textarea, input, script, noscript, style, link, img, br)')].filter((elm) => elm.childElementCount === 0 && (elm.textContent || '').trim().length > 0)
  338.                         for (const elm of s) tmp_wmEty.set(elm, 1);
  339.                         return s;
  340.                     }).then((s) => {
  341.                         let laterArr = [];
  342.                         let promises = [];
  343.  
  344.                         let promiseCallback = parentNode => {
  345.                             if (wmTextWrap.get(parentNode) !== null) return;
  346.                             const m = [...parentNode.children].some(elm => {
  347.                                 const value = getComputedStyle(elm).getPropertyValue('z-index');
  348.                                 if (typeof value == 'string' && value.length > 0) return $.isNum(+value)
  349.                                 return false
  350.                             })
  351.                             wmTextWrap.set(parentNode, m)
  352.                             if (m) {
  353.                                 $.lpHoverBlocks.push(parentNode);
  354.                                 parentNode.setAttribute($.utHoverTextWrap, '')
  355.                             }
  356.  
  357.                         };
  358.  
  359.                         for (const elm of s) {
  360.                             let qElm = elm;
  361.                             let qi = 1;
  362.                             while (true) {
  363.                                 let pElm = qElm.previousElementSibling;
  364.                                 let anyEmptyHover = false;
  365.                                 while (pElm) {
  366.                                     if (tmp_wmEty.get(pElm) > 0) break;
  367.                                     if (!pElm.matches(`button, textarea, input, script, noscript, style, link, img, br`) && (pElm.textContent || '').length === 0 && pElm.clientWidth * pElm.clientHeight > 0) {
  368.                                         laterArr.push(pElm);
  369.                                         anyEmptyHover = true;
  370.                                     }
  371.                                     pElm = pElm.previousElementSibling;
  372.                                 }
  373.                                 if (anyEmptyHover && !wmTextWrap.has(qElm.parentNode)) {
  374.                                     wmTextWrap.set(qElm.parentNode, null)
  375.                                     promises.push(Promise.resolve(qElm.parentNode).then(promiseCallback))
  376.                                 }
  377.                                 qElm = qElm.parentNode;
  378.                                 if (!qElm || qElm === rootNode) break;
  379.                                 qi++
  380.                                 if (tmp_wmEty.get(qElm) > 0) break;
  381.                                 tmp_wmEty.set(qElm, qi)
  382.                             }
  383.                         }
  384.  
  385.                         tmp_wmEty = null;
  386.  
  387.                         Promise.all(promises).then(() => {
  388.                             promises.length = 0;
  389.                             promises = null;
  390.                             promiseCallback = null;
  391.                             for (const pElm of laterArr) {
  392.                                 let parentNode = pElm.parentNode
  393.                                 if (wmTextWrap.get(parentNode) === true) {
  394.                                     $.lpHoverBlocks.push(pElm);
  395.                                     pElm.setAttribute($.utNonEmptyElmPrevElm, '');
  396.                                 }
  397.                             }
  398.                             laterArr.length = 0;
  399.                             laterArr = null;
  400.                             wmTextWrap = null;
  401.                         })
  402.                     })
  403.  
  404.                 }
  405.  
  406.  
  407.             }else if(evt.key == "Alt" && evt.altKey && !evt.ctrlKey && !evt.metaKey && !evt.shiftKey && evt.target){
  408.  
  409.                 if($.cid_lpKeyPressing>0) $.cid_lpKeyPressing=clearTimeout($.cid_lpKeyPressing)
  410.                 $.cid_lpKeyPressing=setTimeout($.lpCancelKeyPressAlt,300);
  411.  
  412.             }else if($.lpKeyPressing==true){
  413.  
  414.                 $.lpCancelKeyPressAlt();
  415.  
  416.             }
  417.  
  418.         },
  419.         lpCancelKeyPressAlt:()=>{
  420.             $.lpKeyPressing = false;
  421.             if($.cid_lpKeyPressing>0) $.cid_lpKeyPressing=clearTimeout($.cid_lpKeyPressing)
  422.  
  423.             $.lpKeyPressingPromise = $.lpKeyPressingPromise.then(() => {
  424.                 for (const elm of $.lpHoverBlocks) {
  425.                     elm.removeAttribute($.utNonEmptyElmPrevElm)
  426.                     elm.removeAttribute($.utHoverTextWrap)
  427.                 }
  428.                 $.lpHoverBlocks.length=0;
  429.             })
  430.         },
  431.         lpKeyUp: function(evt) {
  432.  
  433.  
  434.  
  435.  
  436.             if ($.lpKeyPressing == true) {
  437.                 
  438.  
  439.                 $.lpCancelKeyPressAlt();
  440.  
  441.             }
  442.  
  443.         },
  444.  
  445.         lpAltRoots:[],
  446.  
  447.         lpMouseDown: function(evt) {
  448.             $.lpMouseActive = 0;
  449.             if (evt.altKey && !evt.ctrlKey && !evt.metaKey && !evt.shiftKey && evt.button === 0) {
  450.                 $.lpMouseActive = 1;
  451.                 $.eventCancel(evt, false);
  452.                 const rootNode = $.rootHTML(evt.target);
  453.                 $.lpAltRoots.push(rootNode);
  454.                 rootNode.setAttribute($.utLpSelection, '');
  455.             }
  456.         },
  457.  
  458.         lpMouseUp: function(evt) {
  459.             if ($.lpMouseActive == 1) {
  460.                 $.lpMouseActive = 2;
  461.                 for(const rootNode of $.lpAltRoots) rootNode.removeAttribute($.utLpSelection);
  462.                 $.lpAltRoots.length=0;
  463.                 $.eventCancel(evt, false);
  464.                 if ($.onceCssHighlightSelection) window.requestAnimationFrame($.onceCssHighlightSelection);
  465.             }
  466.         },
  467.  
  468.         lpClick: function(evt) {
  469.             if ($.lpMouseActive == 2) {
  470.                 $.eventCancel(evt, false);
  471.             }
  472.         },
  473.  
  474.         lpEnable: function() { // this is an optional feature for modern browser
  475.             // the built-in browser feature has already disabled the default event behavior, the coding is just to ensure no "tailor-made behavior" occuring.
  476.             document.addEventListener('keydown', $.lpKeyDown, {
  477.                 capture: true,
  478.                 passive: true
  479.             })
  480.             document.addEventListener('keyup', $.lpKeyUp, {
  481.                 capture: true,
  482.                 passive: true
  483.             })
  484.             document.addEventListener('mousedown', $.lpMouseDown, {
  485.                 capture: true,
  486.                 passive: true
  487.             })
  488.             document.addEventListener('mouseup', $.lpMouseUp, {
  489.                 capture: true,
  490.                 passive: true
  491.             })
  492.             document.addEventListener('click', $.lpClick, {
  493.                 capture: true,
  494.                 passive: true
  495.             })
  496.         },
  497.  
  498.         rootHTML: (node) => {
  499.  
  500.             if (!node || !(node.nodeType > 0)) return null;
  501.             if (!node.ownerDocument) return node;
  502.             let rootNode = node.getRootNode ? node.getRootNode() : null
  503.             if (!rootNode) {
  504.                 let pElm = node;
  505.                 while (pElm) {
  506.  
  507.                     if (pElm.parentNode) pElm = pElm.parentNode;
  508.                     else break;
  509.  
  510.                 }
  511.                 rootNode = pElm;
  512.             }
  513.  
  514.  
  515.             rootNode = rootNode.querySelector('html') || node.ownerDocument.documentElement || null;
  516.             return rootNode
  517.  
  518.         },
  519.  
  520.         mainEnableScript: () => {
  521.             var cssStyleOnReady = `
  522.             html, html *,
  523.             html *::before, html *::after,
  524.             html *:hover, html *:link, html *:visited, html *:active,
  525.             html *[style], html *[class]{
  526.                 -khtml-user-select: auto !important; -moz-user-select: auto !important; -ms-user-select: auto !important;
  527.                 -webkit-touch-callout: default !important; -webkit-user-select: auto !important; user-select: auto !important;
  528.             }
  529.             *:hover>img[src]{pointer-events:auto !important;}
  530.  
  531.             [${$.utSelectionColorHack}] :not(input):not(textarea)::selection{ background-color: Highlight !important; color: HighlightText !important;}
  532.             [${$.utSelectionColorHack}] :not(input):not(textarea)::-moz-selection{ background-color: Highlight !important; color: HighlightText !important;}
  533.             [${$.utTapHighlight}] *{ -webkit-tap-highlight-color: rgba(0, 0, 0, 0.18) !important;}
  534.  
  535.             [${$.utHoverTextWrap}]>[${$.utNonEmptyElmPrevElm}]{pointer-events:none !important;}
  536.             [${$.utHoverTextWrap}]>*{z-index:inherit !important;}
  537.  
  538.             html[${$.utLpSelection}] *:hover, html[${$.utLpSelection}] *:hover * { cursor:text !important;}
  539.             html[${$.utLpSelection}] :not(input):not(textarea)::selection {background-color: rgba(255, 156, 179,0.5) !important;}
  540.             html[${$.utLpSelection}] :not(input):not(textarea)::-moz-selection {background-color: rgba(255, 156, 179,0.5) !important;}
  541.  
  542.             [${$.utHoverBlock}="2"]{pointer-events:none !important;user-select:none !important;}
  543.             img[${$.utHoverBlock}="4"]{display:none !important;}
  544.             [${$.utHoverBlock}="7"]{padding:0 !important;}
  545.             [${$.utHoverBlock}="7"]>img[${$.utHoverBlock}="4"]:first-child{
  546.                 display:inline-block !important;
  547.                 position: relative !important;
  548.                 top: auto !important;
  549.                 left: auto !important;
  550.                 bottom: auto !important;
  551.                 right: auto !important;
  552.                 opacity: 0 !important;
  553.                 padding: 0 !important;
  554.                 margin: 0 !important;
  555.                 width: 100% !important;
  556.                 height: 100% !important;
  557.                 outline: 0 !important;
  558.                 border: 0 !important;
  559.                 box-sizing: border-box !important;
  560.                 transform: initial !important;
  561.                 user-select:none !important;
  562.                 z-index:1 !important;
  563.                 float: left !important;
  564.                 cursor:inherit !important;
  565.                 pointer-events:inherit !important;
  566.                 border-radius: inherit !important;
  567.                 background:none !important;
  568.             }
  569.  
  570.             `.trim();
  571.  
  572.             $.enableSelectClickCopy()
  573.             $.createCSSElement(cssStyleOnReady, document.documentElement);
  574.  
  575.         },
  576.  
  577.         mainEvents: (listenerPress, listenerRelease) => {
  578.             document.addEventListener("mousedown", listenerPress, true); // Capture Event; (desktop)
  579.             document.addEventListener("contextmenu", listenerPress, true); // Capture Event; (desktop&mobile)
  580.             document.addEventListener("mouseup", listenerRelease, false); // Bubble Event;
  581.         },
  582.  
  583.         disableHoverBlock: () => {
  584.  
  585.             var nMap = new WeakMap()
  586.  
  587.             function elmParam(elm) {
  588.  
  589.                 var mElm = nMap.get(elm);
  590.                 if (!mElm) nMap.set(elm, mElm = {});
  591.                 return mElm;
  592.             }
  593.  
  594.             function overlapArea(rect1, rect2) {
  595.  
  596.                 let l1 = {
  597.                     x: rect1.left,
  598.                     y: rect1.top
  599.                 }
  600.  
  601.                 let r1 = {
  602.                     x: rect1.right,
  603.                     y: rect1.bottom
  604.                 }
  605.                 let l2 = {
  606.                     x: rect2.left,
  607.                     y: rect2.top
  608.                 }
  609.  
  610.                 let r2 = {
  611.                     x: rect2.right,
  612.                     y: rect2.bottom
  613.                 }
  614.  
  615.                 // Area of 1st Rectangle
  616.                 let area1 = Math.abs(l1.x - r1.x) * Math.abs(l1.y - r1.y);
  617.  
  618.                 // Area of 2nd Rectangle
  619.                 let area2 = Math.abs(l2.x - r2.x) * Math.abs(l2.y - r2.y);
  620.  
  621.                 // Length of intersecting part i.e
  622.                 // start from max(l1.x, l2.x) of
  623.                 // x-coordinate and end at min(r1.x,
  624.                 // r2.x) x-coordinate by subtracting
  625.                 // start from end we get required
  626.                 // lengths
  627.                 let x_dist = Math.min(r1.x, r2.x) - Math.max(l1.x, l2.x);
  628.                 let y_dist = Math.min(r1.y, r2.y) - Math.max(l1.y, l2.y);
  629.                 let areaI = 0;
  630.                 if (x_dist > 0 && y_dist > 0) {
  631.                     areaI = x_dist * y_dist;
  632.                 }
  633.  
  634.                 return {
  635.                     area1,
  636.                     area2,
  637.                     areaI
  638.                 };
  639.  
  640.  
  641.             }
  642.  
  643.             function redirectEvent(event, toElement) {
  644.  
  645.                 toElement.dispatchEvent(new event.constructor(event.type, event));
  646.                 if (event.type != 'wheel') event.preventDefault();
  647.                 event.stopPropagation();
  648.             }
  649.  
  650.             const floatingBlockHover = new WeakMap();
  651.  
  652.             let _nImgs = [];
  653.  
  654.  
  655.             function nImgFunc() {
  656.  
  657.                 for (const s of _nImgs) {
  658.                     if (s.lastTime + 800 < +new Date) {
  659.                         s.lastTime = +new Date;
  660.                         return s.elm
  661.                     }
  662.                 }
  663.  
  664.                 let nImg = document.createElement('img');
  665.                 nImg.setAttribute('title', '　');
  666.                 nImg.setAttribute('alt', '　');
  667.                 nImg.onerror = function() {
  668.                     if (this.parentNode != null) this.parentNode.removeChild(this)
  669.                 }
  670.                 nImg.setAttribute($.utHoverBlock, '4');
  671.                 const handle = function(event) {
  672.                     if (this === event.target) {
  673.                         if (event.button != 2) redirectEvent(event, this.parentNode)
  674.                         Promise.resolve().then(() => {
  675.                             for (const s of _nImgs) {
  676.                                 if (s.elm === this) {
  677.                                     s.lastTime = +new Date
  678.                                 }
  679.                             }
  680.                         })
  681.                     }
  682.                 }
  683.                 nImg.addEventListener('click', handle, true);
  684.                 nImg.addEventListener('mousedown', handle, true);
  685.                 nImg.addEventListener('mouseup', handle, true);
  686.                 nImg.addEventListener('mousemove', handle, true);
  687.                 nImg.addEventListener('mouseover', handle, true);
  688.                 nImg.addEventListener('mouseout', handle, true);
  689.                 nImg.addEventListener('mouseenter', handle, true);
  690.                 nImg.addEventListener('mouseleave', handle, true);
  691.                 //nImg.addEventListener('wheel', handle, $.eh_capture_passive());
  692.                 let resObj = {
  693.                     elm: nImg,
  694.                     lastTime: +new Date,
  695.                     cid_fade: 0
  696.                 }
  697.                 _nImgs.push(resObj)
  698.  
  699.                 return nImg;
  700.  
  701.             }
  702.  
  703.             const wmHoverUrl = new WeakMap();
  704.             let lastMouseEnterElm = null;
  705.             let lastMouseEnterAt = 0;
  706.             let lastMouseEnterCid = 0;
  707.  
  708.             function mouseEnter() {
  709.                 lastMouseEnterCid = 0;
  710.  
  711.                 if (+new Date - lastMouseEnterAt < 30) {
  712.                     lastMouseEnterCid = setTimeout(mouseEnter, 82)
  713.                     return;
  714.                 }
  715.  
  716.                 //if($.lpKeyPressing)return;
  717.  
  718.                 const targetElm = lastMouseEnterElm
  719.  
  720.                 Promise.resolve()
  721.                     .then(() => {
  722.                         if (targetElm && targetElm.parentNode) {} else {
  723.                             return;
  724.                         }
  725.                         if (floatingBlockHover.get(targetElm)) {
  726.                             let url = null
  727.                             if (targetElm.getAttribute($.utHoverBlock) == '7' && (url = wmHoverUrl.get(targetElm)) && targetElm.querySelector(`[${$.utHoverBlock}]`) == null) {
  728.                                 let _nImg = nImgFunc();
  729.                                 if (_nImg.parentNode !== targetElm) {
  730.                                     _nImg.setAttribute('src', url);
  731.                                     targetElm.insertBefore(_nImg, targetElm.firstChild);
  732.                                 }
  733.                             }
  734.                             return;
  735.                         }
  736.                         floatingBlockHover.set(targetElm, 1);
  737.                         return 1;
  738.                     }).then((ayRes) => {
  739.                         if (!ayRes) return;
  740.  
  741.                         if (targetElm.nodeType != 1) return;
  742.                         if ("|SVG|IMG|HTML|BODY|VIDEO|AUDIO|BR|HEAD|NOSCRIPT|SCRIPT|STYLE|TEXTAREA|AREA|INPUT|FORM|BUTTON|".indexOf(`|${targetElm.nodeName}|`) >= 0) return;
  743.  
  744.                         const targetArea = targetElm.clientWidth * targetElm.clientHeight
  745.  
  746.                         if (targetArea > 0) {} else {
  747.                             return;
  748.                         }
  749.  
  750.                         const targetCSS = getComputedStyle(targetElm)
  751.                         const targetBgImage = targetCSS.getPropertyValue('background-image');
  752.                         let exec1 = null
  753.  
  754.                         if (targetBgImage != 'none' && (exec1 = /^\s*url\s*\("?([^"\)]+\b(\.gif|\.png|\.jpeg|\.jpg|\.webp)\b[^"\)]*)"?\)\s*$/i.exec(targetBgImage))) {
  755.                             if ((targetElm.textContent || "").trim().length > 0) return;
  756.                             const url = exec1[1];
  757.                             return url
  758.  
  759.                             // console.log(targetBgImage,[...exec1])
  760.                         }
  761.  
  762.  
  763.  
  764.                         if (targetCSS.getPropertyValue('position') == 'absolute' && +targetCSS.getPropertyValue('z-index') > 0) {} else {
  765.                             return;
  766.                         }
  767.                         if ((targetElm.textContent || "").trim().length > 0) return;
  768.  
  769.                         let possibleResults = [];
  770.  
  771.                         for (const imgElm of document.querySelectorAll('img[src]')) {
  772.                             const param = elmParam(imgElm)
  773.                             if (!param.area) {
  774.                                 const area = imgElm.clientWidth * imgElm.clientHeight
  775.                                 if (area > 0) param.area = area;
  776.                             }
  777.                             if (param.area > 0) {
  778.                                 if (targetArea > param.area * 0.9) possibleResults.push(imgElm)
  779.                             }
  780.                         }
  781.  
  782.                         let i = 0;
  783.                         let j = 0;
  784.                         for (const imgElm of possibleResults) {
  785.  
  786.                             const cmpVal = targetElm.compareDocumentPosition(imgElm)
  787.  
  788.                             /*
  789.  
  790.  
  791. 1: The two nodes do not belong to the same document.
  792. 2: p1 is positioned after p2.
  793. 4: p1 is positioned before p2.
  794. 8: p1 is positioned inside p2.
  795. 16: p2 is positioned inside p1.
  796. 32: The two nodes has no relationship, or they are two attributes on the same element.
  797.  
  798.             */
  799.  
  800.                             if (cmpVal & 8 || cmpVal & 16) return;
  801.                             if (cmpVal & 2) j++; // I<p
  802.                             else if (cmpVal & 4) break; // I>p
  803.  
  804.  
  805.                             i++;
  806.  
  807.                         }
  808.  
  809.                         // before: j-1  after: j
  810.  
  811.                         let indexBefore = j - 1;
  812.                         let indexAfter = j;
  813.                         if (indexBefore < 0) indexBefore = 0;
  814.                         if (indexAfter > possibleResults.length - 1) indexAfter = possibleResults.length - 1;
  815.  
  816.                         //    setTimeout(function(){
  817.                         for (let i = indexBefore; i <= indexAfter; i++) {
  818.                             const s = possibleResults[i];
  819.                             const {
  820.                                 area1,
  821.                                 area2,
  822.                                 areaI
  823.                             } = overlapArea(targetElm.getBoundingClientRect(), s.getBoundingClientRect())
  824.                             const criteria = area1 * 0.7
  825.                             if (areaI > 0.9 * area2) {
  826.  
  827.  
  828.                                 return s.getAttribute('src')
  829.  
  830.  
  831.                             }
  832.                         }
  833.                         //   },1000);
  834.  
  835.                     }).then((sUrl) => {
  836.  
  837.                         if (typeof sUrl != 'string') return;
  838.  
  839.                         //console.log(targetElm, targetElm.querySelectorAll('img').length)
  840.  
  841.                         // console.log(313, evt.target, s)
  842.                         let _nImg = nImgFunc();
  843.  
  844.  
  845.                         if (_nImg.parentNode !== targetElm) {
  846.                             _nImg.setAttribute('src', sUrl);
  847.                             targetElm.insertBefore(_nImg, targetElm.firstChild);
  848.                             wmHoverUrl.set(targetElm, sUrl);
  849.                             targetElm.setAttribute($.utHoverBlock, '7');
  850.                         }
  851.  
  852.  
  853.  
  854.                     })
  855.  
  856.             }
  857.  
  858.             document.addEventListener('mouseenter', function(evt) {
  859.                 lastMouseEnterElm = evt.target
  860.                 lastMouseEnterAt = +new Date;
  861.                 if (!lastMouseEnterCid) lastMouseEnterCid = setTimeout(mouseEnter, 82)
  862.             }, $.eh_capture_passive())
  863.  
  864.  
  865.  
  866.         }
  867.  
  868.     }
  869.  
  870.     // $.holdingElm=null;
  871.  
  872.     $.mainEnableScript();
  873.  
  874.     if (isSupportAdvancedEventListener()) $.lpEnable(); // top capture event for alt-click
  875.  
  876.     $.mainEvents(
  877.         function(evt) {
  878.             //   $.holdingElm=evt.target;
  879.             //   console.log('down',evt.target)
  880.             if ($.onceCssHighlightSelection) window.requestAnimationFrame($.onceCssHighlightSelection);
  881.             if (evt.button == 2 || evt.type == "contextmenu") $.mAlert_DOWN();
  882.         },
  883.         function(evt) {
  884.             //  $.holdingElm=null;
  885.             //   console.log('up',evt.target)
  886.             if (evt.button == 2) $.mAlert_UP();
  887.             if ($.enableDragging) {
  888.                 $.enableDragging = false;
  889.             }
  890.         }
  891.     );
  892.  
  893.     $.disableHoverBlock();
  894.  
  895.     console.log('userscript running - To Re-Enable Selection & Copying');
  896.  
  897.  
  898.  
  899.  
  900. })();