☰

通用脚本重开启选取复制

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

目前为 2023-01-04 提交的版本。查看 最新版本。

  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.8.1.8
  6. // @description         Enables select, right-click, copy and drag on pages that disable them. Enhanced Feature: Alt Key HyperLink Text Selection
  7. // @description:zh-TW   破解鎖右鍵，解除禁止復制、剪切、選擇文本、右鍵菜單、文字複製、文字選取、圖片右鍵等限制。增強功能：Alt鍵超連結文字選取。
  8. // @description:zh-CN   破解锁右键，解除禁止复制、剪切、选择文本、右键菜单、文字复制、文字选取、图片右键等限制。增强功能：Alt键超连结文字选取。
  9. // @namespace           https://greasyfork.org/users/371179
  10. // @author              CY Fung
  11. // @supportURL          https://github.com/cyfung1031/userscript-supports
  12. // @run-at              document-start
  13. // @match               http://*/*
  14. // @match               https://*/*
  15. // @exclude             /^https?://\S+\.(txt|png|jpg|jpeg|gif|xml|svg|manifest|log|ini)[^\/]*$/
  16. // @exclude             https://github.dev/*/*
  17. // @exclude             https://www.photopea.com/*
  18. // @icon                https://cdn-icons-png.flaticon.com/512/3388/3388671.png
  19. // @grant               GM_registerMenuCommand
  20. // @grant               GM_unregisterMenuCommand
  21. // @grant               GM_setValue
  22. // @grant               GM_getValue
  23. // @grant               GM_addValueChangeListener
  24. // ==/UserScript==
  25. (function $$() {
  26.     'use strict';
  27.     if (document == null || !document.documentElement) return window.requestAnimationFrame($$); // this is tampermonkey bug?? not sure
  28.     //console.log('script at', location)
  29.  
  30.     function $nil() {}
  31.  
  32.     function isLatestBrowser(){
  33.  
  34.         let res;
  35.         try{
  36.             let o ={$nil};
  37.             o?.$nil();
  38.             o=null;
  39.             o?.$nil();
  40.             res = true;
  41.         }catch(e){}
  42.         return !!res;
  43.     }
  44.     if(!isLatestBrowser()) throw 'Browser version before 2020-01-01 is not supported. Please update to the latest version.';
  45.  
  46.     function isSupportAdvancedEventListener() {
  47.         if ('_b1750' in $) return $._b1750
  48.         var prop = 0;
  49.         document.createAttribute('z').addEventListener('nil', $nil, {
  50.             get passive() {
  51.                 prop++;
  52.             },
  53.             get once() {
  54.                 prop++;
  55.             }
  56.         });
  57.         return ($._b1750 = prop == 2);
  58.     }
  59.  
  60.     function isSupportPassiveEventListener() {
  61.         if ('_b1650' in $) return $._b1650
  62.         var prop = 0;
  63.         document.createAttribute('z').addEventListener('nil', $nil, {
  64.             get passive() {
  65.                 prop++;
  66.             }
  67.         });
  68.         return ($._b1650 = prop == 1);
  69.     }
  70.  
  71.     function inIframe () {
  72.         try {
  73.             return window.self !== window.top;
  74.         } catch (e) {
  75.             return true;
  76.         }
  77.     }
  78.  
  79.     var getSelection = window.getSelection || Error()(),
  80.         requestAnimationFrame = window.requestAnimationFrame || Error()(),
  81.         getComputedStyle = window.getComputedStyle.bind(window) || Error()();
  82.  
  83.     const $ = {
  84.         utSelectionColorHack: 'msmtwejkzrqa',
  85.         utTapHighlight: 'xfcklblvkjsj',
  86.         utLpSelection: 'gykqyzwufxpz',
  87.         utHoverBlock: 'meefgeibrtqx', //scc_emptyblock
  88.         //utNonEmptyElm: 'ilkpvtsnwmjb',
  89.         utNonEmptyElmPrevElm: 'jttkfplemwzo',
  90.         utHoverTextWrap: 'oseksntfvucn',
  91.         ksFuncReplacerNonFalse: '___dqzadwpujtct___',
  92.         ksEventReturnValue: ' ___ndjfujndrlsx___',
  93.         ksSetData: '___rgqclrdllmhr___',
  94.         ksNonEmptyPlainText: '___grpvyosdjhuk___',
  95.  
  96.         eh_capture_passive: () => isSupportPassiveEventListener() ? ($._eh_capture_passive = ($._eh_capture_passive || {
  97.             capture: true,
  98.             passive: true
  99.         })) : true,
  100.  
  101.         mAlert_DOWN: function() {}, //dummy function in case alert replacement is not valid
  102.         mAlert_UP: function() {}, //dummy function in case alert replacement is not valid
  103.  
  104.  
  105.         lpKeyPressing: false,
  106.         lpKeyPressingPromise: Promise.resolve(),
  107.  
  108.         isNum: (d) => (d > 0 || d < 0 || d === 0),
  109.  
  110.         isAnySelection: function() {
  111.             var sel = getSelection();
  112.             return !sel ? null : (typeof sel.isCollapsed == 'boolean') ? !sel.isCollapsed : (sel.toString().length > 0);
  113.         },
  114.  
  115.         createCSSElement: function(cssStyle, container) {
  116.             var css = document.createElement('style'); //slope: DOM throughout
  117.             css.type = 'text/css';
  118.             css.textContent = cssStyle;
  119.             if (container) container.appendChild(css);
  120.             return css;
  121.         },
  122.  
  123.         createFakeAlert: function(_alert) {
  124.             if (typeof _alert != 'function') return null;
  125.  
  126.             function alert(msg) {
  127.                 alert.__isDisabled__() ? console.log("alert msg disabled: ", msg) : _alert.apply(this, arguments);
  128.             };
  129.             alert.toString = () => "function alert() { [native code] }";
  130.             return alert;
  131.         },
  132.  
  133.         createFuncReplacer: function(originalFunc, pName, resFX) {
  134.             resFX = function(ev) {
  135.                 var res = originalFunc.apply(this, arguments);
  136.                 if (!this || this[pName] != resFX) return res; // if this is null or undefined, or this.onXXX is not this function
  137.                 if (res === false) return; // return undefined when "return false;"
  138.                 originalFunc[$.ksFuncReplacerNonFalse] = true;
  139.                 this[pName] = originalFunc; // restore original
  140.                 return res;
  141.             }
  142.             resFX.toString = () => originalFunc.toString();
  143.             return resFX;
  144.         },
  145.  
  146.         listenerDisableAll: function(evt) {
  147.             var elmNode = evt.target;
  148.             var pName = 'on' + evt.type;
  149.             evt = null;
  150.             Promise.resolve().then(() => {
  151.                 while (elmNode && elmNode.nodeType > 0) { //i.e. HTMLDocument or HTMLElement
  152.                     var f = elmNode[pName];
  153.                     if (typeof f == 'function' && f[$.ksFuncReplacerNonFalse] !== true) {
  154.                         var nf = $.createFuncReplacer(f, pName);
  155.                         nf[$.ksFuncReplacerNonFalse] = true;
  156.                         elmNode[pName] = nf;
  157.                     }
  158.                     elmNode = elmNode.parentNode;
  159.                 }
  160.             })
  161.         },
  162.  
  163.         onceCssHighlightSelection: () => {
  164.             if (document.documentElement.hasAttribute($.utLpSelection)) return;
  165.             $.onceCssHighlightSelection = null
  166.             Promise.resolve().then(() => {
  167.                 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
  168.                 var elm = !s.length ? document.body : s[s.length >> 1];
  169.                 return elm
  170.             }).then(elm => {
  171.                 var selectionStyle = getComputedStyle(elm, ':selection');
  172.                 if (/^rgba\(\d+,\s*\d+,\s*\d+,\s*0\)$/.test(selectionStyle.getPropertyValue('background-color'))) document.documentElement.setAttribute($.utSelectionColorHack, "");
  173.                 return elm;
  174.             }).then(elm => {
  175.                 var elmStyle = getComputedStyle(elm)
  176.                 if (/^rgba\(\d+,\s*\d+,\s*\d+,\s*0\)$/.test(elmStyle.getPropertyValue('-webkit-tap-highlight-color'))) document.documentElement.setAttribute($.utTapHighlight, "");
  177.             })
  178.         },
  179.  
  180.         clipDataProcess: function(clipboardData) {
  181.  
  182.             if (!clipboardData) return;
  183.             const evt = clipboardData[$.ksSetData]; //NOT NULL when preventDefault is called
  184.             if (!evt || evt.clipboardData !== clipboardData) return;
  185.             const plainText = clipboardData[$.ksNonEmptyPlainText]; //NOT NULL when setData is called with non empty input
  186.             if (!plainText) return;
  187.  
  188.             //BOTH preventDefault and setData are called.
  189.  
  190.             if (evt.cancelable !== true || evt.defaultPrevented !== false) return;
  191.             $.bypass = true;
  192.             evt.preventDefault();
  193.             $.bypass = false;
  194.  
  195.  
  196.             var trimedSelectionText = getSelection().toString().trim()
  197.  
  198.             if (trimedSelectionText) {
  199.                 //there is replacement data and the selection is not empty
  200.                 console.log({
  201.                     msg: "copy event - clipboardData replacement is allowed and the selection is not empty",
  202.                     oldText: trimedSelectionText,
  203.                     newText: plainText,
  204.                 })
  205.             } else {
  206.                 //there is replacement data and the selection is empty
  207.                 console.log({
  208.                     msg: "copy event - clipboardData replacement is allowed and the selection is empty",
  209.                     oldText: trimedSelectionText,
  210.                     newText: plainText,
  211.                 })
  212.             }
  213.  
  214.         },
  215.  
  216.         enableSelectClickCopy: function() {
  217.             $.eyEvts = ['keydown', 'keyup', 'copy', 'contextmenu', 'select', 'selectstart', 'dragstart', 'beforecopy']; //slope: throughout
  218.  
  219.             function isDeactivePreventDefault(evt) {
  220.                 if ($.bypass) return false;
  221.                 var j = $.eyEvts.indexOf(evt.type);
  222.                 switch (j) {
  223.                     case 6:
  224.                         if ($.enableDragging) return false;
  225.                         if (evt&&evt.target && evt.target.nodeType==1 && evt.target.hasAttribute('draggable')) {
  226.                             $.enableDragging = true;
  227.                             return false;
  228.                         }
  229.                         //if(evt.target.hasAttribute('draggable')&&evt.target!=window.getSelection().anchorNode)return false;
  230.                         return true;
  231.                     case 3:
  232.                         if (evt.target instanceof Element && (evt.target.textContent || "").trim().length === 0) return false; //exclude elements like video
  233.                         return true;
  234.                     case -1:
  235.                         return false;
  236.                     case 0:
  237.                     case 1:
  238.                         return (evt.keyCode == 67 && (evt.ctrlKey || evt.metaKey) && !evt.altKey && !evt.shiftKey && $.isAnySelection() === true);
  239.                     case 2:
  240.                         if (!('clipboardData' in evt && 'setData' in DataTransfer.prototype)) return true; // Event oncopy not supporting clipboardData
  241.                         if (evt.cancelable && evt.defaultPrevented === false) {} else return true;
  242.  
  243.                         if (evt.clipboardData[$.ksSetData] && evt.clipboardData[$.ksSetData] != evt) return true; //in case there is a bug
  244.                         evt.clipboardData[$.ksSetData] = evt;
  245.  
  246.                         $.clipDataProcess(evt.clipboardData);
  247.  
  248.                         return true; //preventDefault in clipDataProcess
  249.  
  250.  
  251.                     default:
  252.                         return true;
  253.                 }
  254.             }
  255.  
  256.             !(function($setData) {
  257.                 DataTransfer.prototype.setData = (function setData() {
  258.  
  259.                     if (arguments[0] == 'text/plain' && typeof arguments[1] == 'string') {
  260.                         if (arguments[1].trim().length > 0) {
  261.                             this[$.ksNonEmptyPlainText] = arguments[1]
  262.                         } else if (this[$.ksNonEmptyPlainText]) {
  263.                             arguments[1] = this[$.ksNonEmptyPlainText]
  264.                         }
  265.                     }
  266.  
  267.                     $.clipDataProcess(this)
  268.  
  269.                     let res = $setData.apply(this, arguments)
  270.  
  271.                     return res;
  272.  
  273.                 })
  274.             })(DataTransfer.prototype.setData);
  275.  
  276.             Object.defineProperties(DataTransfer.prototype, {
  277.                 [$.ksSetData]: { //store the event
  278.                     value: null,
  279.                     writable: true,
  280.                     enumerable: false,
  281.                     configurable: true
  282.                 },
  283.                 [$.ksNonEmptyPlainText]: { //store the text
  284.                     value: null,
  285.                     writable: true,
  286.                     enumerable: false,
  287.                     configurable: true
  288.                 }
  289.             })
  290.  
  291.  
  292.             Event.prototype.preventDefault = (function(f) {
  293.                 function preventDefault() {
  294.                     if (!isDeactivePreventDefault(this)) f.call(this);
  295.                 }
  296.                 preventDefault.toString = () => f.toString();
  297.                 return preventDefault;
  298.             })(Event.prototype.preventDefault);
  299.  
  300.             Object.defineProperty(Event.prototype, "returnValue", {
  301.                 get() {
  302.                     return $.ksEventReturnValue in this ? this[$.ksEventReturnValue] : true;
  303.                 },
  304.                 set(newValue) {
  305.                     if (newValue === false && !isDeactivePreventDefault(this)) this.preventDefault();
  306.                     this[$.ksEventReturnValue] = newValue;
  307.                 },
  308.                 enumerable: true,
  309.                 configurable: true
  310.             });
  311.  
  312.             for (var i = 2, eventsCount = $.eyEvts.length; i < eventsCount; i++) {
  313.                 document.addEventListener($.eyEvts[i], $.listenerDisableAll, true); // Capture Event; passive:false; expected occurrence COMPLETELY before Target Capture and Target Bubble
  314.             }
  315.  
  316.              // userscript bug ?  window.alert not working
  317.             let window_ = null;
  318.             try{
  319.                 window_ = new Function('return window')();
  320.             }catch(e){}
  321.             if(window_){
  322.                 let _alert = window_.alert; //slope: temporary
  323.                 if (typeof _alert == 'function') {
  324.                     let _mAlert = $.createFakeAlert(_alert);
  325.                     if (_mAlert) {
  326.                         let clickBlockingTo = 0;
  327.                         _mAlert.__isDisabled__ = () => clickBlockingTo > +new Date;
  328.                         $.mAlert_DOWN = () => (clickBlockingTo = +new Date + 50);
  329.                         $.mAlert_UP = () => (clickBlockingTo = +new Date + 20);
  330.                         window_.alert = _mAlert
  331.                     }
  332.                     _mAlert=null;
  333.                 }
  334.                 _alert=null;
  335.             }
  336.             window_=null;
  337.  
  338.         },
  339.  
  340.         lpCheckPointer: function(targetElm) {
  341.             if (targetElm && targetElm.nodeType == 1 && targetElm.matches('*:hover')) {
  342.                 if (getComputedStyle(targetElm).getPropertyValue('cursor') == 'pointer' && targetElm.textContent) return true;
  343.             }
  344.             return false;
  345.         },
  346.  
  347.         eventCancel: function(evt, toPreventDefault) {
  348.             $.bypass = true;
  349.             !toPreventDefault || evt.preventDefault()
  350.             evt.stopPropagation();
  351.             evt.stopImmediatePropagation();
  352.             $.bypass = false;
  353.         },
  354.  
  355.         lpHoverBlocks:[],
  356.         lpKeyAltLastPressAt:0,
  357.         lpKeyAltPressInterval:0,
  358.  
  359.         noPlayingVideo:function(){
  360.  
  361.             // prevent poor video preformance
  362.  
  363.             let noPlaying =true;
  364.             for(const video of document.querySelectorAll('video[src]')){
  365.  
  366.                 if(video.paused===false) noPlaying=false;
  367.  
  368.             }
  369.             return noPlaying;
  370.  
  371.  
  372.         },
  373.  
  374.  
  375.         lpKeyDown: function(evt) {
  376.  
  377.             if(!$.gm_lp_enable)return;
  378.  
  379.             const isAltPress= (evt.key == "Alt" && evt.altKey && !evt.ctrlKey && !evt.metaKey && !evt.shiftKey)
  380.  
  381.  
  382.  
  383.  
  384.             if (isAltPress) {
  385.  
  386.                 $.lpKeyAltLastPressAt=+new Date;
  387.  
  388.                 let element=evt.target
  389.  
  390.  
  391.                 if($.lpKeyPressing == false && element && element.parentNode && !evt.repeat && $.noPlayingVideo()){
  392.  
  393.                     $.lpKeyPressing = true;
  394.  
  395.                     $.cid_lpKeyPressing=setInterval(()=>{
  396.                         if($.lpKeyAltLastPressAt+500<+new Date){
  397.                             $.lpCancelKeyPressAlt();
  398.                         }
  399.                     },137);
  400.  
  401.                     const rootNode = $.rootHTML(element);
  402.                     if (rootNode) {
  403.                         let tmp_wmEty = null;
  404.  
  405.  
  406.                         let wmTextWrap = new WeakMap();
  407.  
  408.                         $.lpKeyPressingPromise = $.lpKeyPressingPromise.then(() => {
  409.                             for (const elm of $.lpHoverBlocks) {
  410.                                 elm.removeAttribute($.utNonEmptyElmPrevElm)
  411.                                 elm.removeAttribute($.utHoverTextWrap)
  412.                             }
  413.                             $.lpHoverBlocks.length=0;
  414.                         }).then(() => {
  415.                             tmp_wmEty = new WeakMap(); // 1,2,3.....: non-empty elm,  -1:empty elm
  416.                             const s = [...rootNode.querySelectorAll('*:not(button, textarea, input, script, noscript, style, link, img, br)')].filter((elm) => elm.childElementCount === 0 && (elm.textContent || '').trim().length > 0)
  417.                             for (const elm of s) tmp_wmEty.set(elm, 1);
  418.                             return s;
  419.                         }).then((s) => {
  420.                             let laterArr = [];
  421.                             let promises = [];
  422.  
  423.                             let promiseCallback = parentNode => {
  424.                                 if (wmTextWrap.get(parentNode) !== null) return;
  425.                                 const m = [...parentNode.children].some(elm => {
  426.                                     const value = getComputedStyle(elm).getPropertyValue('z-index');
  427.                                     if (typeof value == 'string' && value.length > 0) return $.isNum(+value)
  428.                                     return false
  429.                                 })
  430.                                 wmTextWrap.set(parentNode, m)
  431.                                 if (m) {
  432.                                     $.lpHoverBlocks.push(parentNode);
  433.                                     parentNode.setAttribute($.utHoverTextWrap, '')
  434.                                 }
  435.  
  436.                             };
  437.  
  438.                             for (const elm of s) {
  439.                                 let qElm = elm;
  440.                                 let qi = 1;
  441.                                 while (true) {
  442.                                     let pElm = qElm.previousElementSibling;
  443.                                     let anyEmptyHover = false;
  444.                                     while (pElm) {
  445.                                         if (tmp_wmEty.get(pElm) > 0) break;
  446.                                         if (!pElm.matches(`button, textarea, input, script, noscript, style, link, img, br`) && (pElm.textContent || '').length === 0 && pElm.clientWidth * pElm.clientHeight > 0) {
  447.                                             laterArr.push(pElm);
  448.                                             anyEmptyHover = true;
  449.                                         }
  450.                                         pElm = pElm.previousElementSibling;
  451.                                     }
  452.                                     if (anyEmptyHover && !wmTextWrap.has(qElm.parentNode)) {
  453.                                         wmTextWrap.set(qElm.parentNode, null)
  454.                                         promises.push(Promise.resolve(qElm.parentNode).then(promiseCallback))
  455.                                     }
  456.                                     qElm = qElm.parentNode;
  457.                                     if (!qElm || qElm === rootNode) break;
  458.                                     qi++
  459.                                     if (tmp_wmEty.get(qElm) > 0) break;
  460.                                     tmp_wmEty.set(qElm, qi)
  461.                                 }
  462.                             }
  463.  
  464.                             tmp_wmEty = null;
  465.  
  466.                             Promise.all(promises).then(() => {
  467.                                 promises.length = 0;
  468.                                 promises = null;
  469.                                 promiseCallback = null;
  470.                                 for (const pElm of laterArr) {
  471.                                     let parentNode = pElm.parentNode
  472.                                     if (wmTextWrap.get(parentNode) === true) {
  473.                                         $.lpHoverBlocks.push(pElm);
  474.                                         pElm.setAttribute($.utNonEmptyElmPrevElm, '');
  475.                                     }
  476.                                 }
  477.                                 laterArr.length = 0;
  478.                                 laterArr = null;
  479.                                 wmTextWrap = null;
  480.                             })
  481.                         })
  482.  
  483.                     }
  484.  
  485.                 }
  486.  
  487.  
  488.             }else if($.lpKeyPressing==true){
  489.  
  490.                 $.lpCancelKeyPressAlt();
  491.  
  492.             }
  493.  
  494.         },
  495.         lpCancelKeyPressAlt:()=>{
  496.             $.lpKeyPressing = false;
  497.             if($.cid_lpKeyPressing>0) $.cid_lpKeyPressing=clearInterval($.cid_lpKeyPressing)
  498.  
  499.             $.lpKeyPressingPromise = $.lpKeyPressingPromise.then(() => {
  500.                 for (const elm of $.lpHoverBlocks) {
  501.                     elm.removeAttribute($.utNonEmptyElmPrevElm)
  502.                     elm.removeAttribute($.utHoverTextWrap)
  503.                 }
  504.                 $.lpHoverBlocks.length=0;
  505.             })
  506.  
  507.  
  508.             setTimeout(function(){
  509.                 if($.lpMouseActive == 1){
  510.                     $.lpMouseUpClear();
  511.                     $.lpMouseActive=0;
  512.                 }
  513.             },32);
  514.  
  515.         },
  516.         lpKeyUp: function(evt) {
  517.  
  518.             if(!$.gm_lp_enable)return;
  519.  
  520.             if ($.lpKeyPressing == true) {
  521.                 $.lpCancelKeyPressAlt();
  522.             }
  523.  
  524.  
  525.         },
  526.  
  527.         lpAltRoots:[],
  528.  
  529.         lpMouseDown: function(evt) {
  530.  
  531.             if(!$.gm_lp_enable)return;
  532.  
  533.             $.lpMouseActive = 0;
  534.             if (evt.altKey && !evt.ctrlKey && !evt.metaKey && !evt.shiftKey && evt.button === 0 && $.noPlayingVideo()) {
  535.                 $.lpMouseActive = 1;
  536.                 $.eventCancel(evt, false);
  537.                 const rootNode = $.rootHTML(evt.target);
  538.                 $.lpAltRoots.push(rootNode);
  539.                 rootNode.setAttribute($.utLpSelection, '');
  540.             }
  541.         },
  542.  
  543.         lpMouseUpClear:function(){
  544.                 for(const rootNode of $.lpAltRoots) rootNode.removeAttribute($.utLpSelection);
  545.                 $.lpAltRoots.length=0;
  546.                 if ($.onceCssHighlightSelection) window.requestAnimationFrame($.onceCssHighlightSelection);
  547.         },
  548.  
  549.         lpMouseUp: function(evt) {
  550.  
  551.             if(!$.gm_lp_enable)return;
  552.  
  553.             if ($.lpMouseActive == 1) {
  554.                 $.lpMouseActive = 2;
  555.                 $.eventCancel(evt, false);
  556.                 $.lpMouseUpClear();
  557.             }
  558.         },
  559.  
  560.         lpClick: function(evt) {
  561.  
  562.             if(!$.gm_lp_enable)return;
  563.  
  564.             if ($.lpMouseActive == 2) {
  565.                 $.eventCancel(evt, false);
  566.             }
  567.         },
  568.  
  569.         lpEnable: function() { // this is an optional feature for modern browser
  570.             // the built-in browser feature has already disabled the default event behavior, the coding is just to ensure no "tailor-made behavior" occuring.
  571.             document.addEventListener('keydown', $.lpKeyDown, {
  572.                 capture: true,
  573.                 passive: true
  574.             })
  575.             document.addEventListener('keyup', $.lpKeyUp, {
  576.                 capture: true,
  577.                 passive: true
  578.             })
  579.             document.addEventListener('mousedown', $.lpMouseDown, {
  580.                 capture: true,
  581.                 passive: true
  582.             })
  583.             document.addEventListener('mouseup', $.lpMouseUp, {
  584.                 capture: true,
  585.                 passive: true
  586.             })
  587.             document.addEventListener('click', $.lpClick, {
  588.                 capture: true,
  589.                 passive: true
  590.             })
  591.         },
  592.  
  593.         rootHTML: (node) => {
  594.  
  595.             if (!node || !(node.nodeType > 0)) return null;
  596.             if (!node.ownerDocument) return node;
  597.             let rootNode = node.getRootNode ? node.getRootNode() : null
  598.             if (!rootNode) {
  599.                 let pElm = node;
  600.                 while (pElm) {
  601.  
  602.                     if (pElm.parentNode) pElm = pElm.parentNode;
  603.                     else break;
  604.  
  605.                 }
  606.                 rootNode = pElm;
  607.             }
  608.  
  609.  
  610.             rootNode = rootNode.querySelector('html') || node.ownerDocument.documentElement || null;
  611.             return rootNode
  612.  
  613.         },
  614.  
  615.         mainEnableScript: () => {
  616.             var cssStyleOnReady = `
  617.             html, html *,
  618.             html *::before, html *::after,
  619.             html *:hover, html *:link, html *:visited, html *:active,
  620.             html *[style], html *[class]{
  621.                 -khtml-user-select: auto !important; -moz-user-select: auto !important; -ms-user-select: auto !important;
  622.                 -webkit-touch-callout: default !important; -webkit-user-select: auto !important; user-select: auto !important;
  623.             }
  624.             *:hover>img[src]{pointer-events:auto !important;}
  625.  
  626.             [${$.utSelectionColorHack}] :not(input):not(textarea)::selection{ background-color: Highlight !important; color: HighlightText !important;}
  627.             [${$.utSelectionColorHack}] :not(input):not(textarea)::-moz-selection{ background-color: Highlight !important; color: HighlightText !important;}
  628.             [${$.utTapHighlight}] *{ -webkit-tap-highlight-color: rgba(0, 0, 0, 0.18) !important;}
  629.  
  630.             [${$.utHoverTextWrap}]>[${$.utNonEmptyElmPrevElm}]{pointer-events:none !important;}
  631.             [${$.utHoverTextWrap}]>*{z-index:inherit !important;}
  632.  
  633.             html[${$.utLpSelection}] *:hover, html[${$.utLpSelection}] *:hover * { cursor:text !important;}
  634.             html[${$.utLpSelection}] :not(input):not(textarea)::selection {background-color: rgba(255, 156, 179,0.5) !important;}
  635.             html[${$.utLpSelection}] :not(input):not(textarea)::-moz-selection {background-color: rgba(255, 156, 179,0.5) !important;}
  636.  
  637.             img[${$.utHoverBlock}="4"]{display:none !important;}
  638.             [${$.utHoverBlock}="7"]{padding:0 !important;overflow:hidden !important;}
  639.             [${$.utHoverBlock}="7"]>img[${$.utHoverBlock}="4"]:first-child{
  640.                 display:inline-block !important;
  641.                 position: relative !important;
  642.                 top: auto !important;
  643.                 left: auto !important;
  644.                 bottom: auto !important;
  645.                 right: auto !important;
  646.                 opacity: 0 !important;
  647.                 padding: 0 !important;
  648.                 margin: 0 !important;
  649.                 width: 100% !important;
  650.                 height: 100% !important;
  651.                 outline: 0 !important;
  652.                 border: 0 !important;
  653.                 box-sizing: border-box !important;
  654.                 transform: initial !important;
  655.                 user-select:none !important;
  656.                 z-index:1 !important;
  657.                 float: left !important;
  658.                 cursor:inherit !important;
  659.                 pointer-events:inherit !important;
  660.                 border-radius: inherit !important;
  661.                 background:none !important;
  662.             }
  663.  
  664.             `.trim();
  665.  
  666.             $.enableSelectClickCopy()
  667.             $.createCSSElement(cssStyleOnReady, document.documentElement);
  668.  
  669.         },
  670.  
  671.         mainEvents: (listenerPress, listenerRelease) => {
  672.             document.addEventListener("mousedown", listenerPress, true); // Capture Event; (desktop)
  673.             document.addEventListener("contextmenu", listenerPress, true); // Capture Event; (desktop&mobile)
  674.             document.addEventListener("mouseup", listenerRelease, false); // Bubble Event;
  675.         },
  676.  
  677.         disableHoverBlock: () => {
  678.  
  679.             var nMap = new WeakMap()
  680.  
  681.             function elmParam(elm) {
  682.  
  683.                 var mElm = nMap.get(elm);
  684.                 if (!mElm) nMap.set(elm, mElm = {});
  685.                 return mElm;
  686.             }
  687.  
  688.             function overlapArea(rect1, rect2) {
  689.  
  690.                 let l1 = {
  691.                     x: rect1.left,
  692.                     y: rect1.top
  693.                 }
  694.  
  695.                 let r1 = {
  696.                     x: rect1.right,
  697.                     y: rect1.bottom
  698.                 }
  699.                 let l2 = {
  700.                     x: rect2.left,
  701.                     y: rect2.top
  702.                 }
  703.  
  704.                 let r2 = {
  705.                     x: rect2.right,
  706.                     y: rect2.bottom
  707.                 }
  708.  
  709.                 // Area of 1st Rectangle
  710.                 let area1 = Math.abs(l1.x - r1.x) * Math.abs(l1.y - r1.y);
  711.  
  712.                 // Area of 2nd Rectangle
  713.                 let area2 = Math.abs(l2.x - r2.x) * Math.abs(l2.y - r2.y);
  714.  
  715.                 // Length of intersecting part i.e
  716.                 // start from max(l1.x, l2.x) of
  717.                 // x-coordinate and end at min(r1.x,
  718.                 // r2.x) x-coordinate by subtracting
  719.                 // start from end we get required
  720.                 // lengths
  721.                 let x_dist = Math.min(r1.x, r2.x) - Math.max(l1.x, l2.x);
  722.                 let y_dist = Math.min(r1.y, r2.y) - Math.max(l1.y, l2.y);
  723.                 let areaI = 0;
  724.                 if (x_dist > 0 && y_dist > 0) {
  725.                     areaI = x_dist * y_dist;
  726.                 }
  727.  
  728.                 return {
  729.                     area1,
  730.                     area2,
  731.                     areaI
  732.                 };
  733.  
  734.  
  735.             }
  736.  
  737.             function redirectEvent(event, toElement) {
  738.  
  739.                 toElement.dispatchEvent(new event.constructor(event.type, event));
  740.                 if (event.type != 'wheel') event.preventDefault();
  741.                 event.stopPropagation();
  742.             }
  743.  
  744.             const floatingBlockHover = new WeakMap();
  745.  
  746.             let _nImgs = [];
  747.  
  748.  
  749.             function nImgFunc() {
  750.  
  751.                 for (const s of _nImgs) {
  752.                     if (s.lastTime + 800 < +new Date) {
  753.                         s.lastTime = +new Date;
  754.                         return s.elm
  755.                     }
  756.                 }
  757.  
  758.                 let nImg = document.createElement('img');
  759.                 nImg.setAttribute('title', '　');
  760.                 nImg.setAttribute('alt', '　');
  761.                 nImg.onerror = function() {
  762.                     if (this.parentNode != null) this.parentNode.removeChild(this)
  763.                 }
  764.                 nImg.setAttribute($.utHoverBlock, '4');
  765.                 const handle = function(event) {
  766.                     if (this === event.target) {
  767.                         if (event.button != 2) redirectEvent(event, this.parentNode)
  768.                         Promise.resolve().then(() => {
  769.                             for (const s of _nImgs) {
  770.                                 if (s.elm === this) {
  771.                                     s.lastTime = +new Date
  772.                                 }
  773.                             }
  774.                         })
  775.                     }
  776.                 }
  777.                 nImg.addEventListener('click', handle, true);
  778.                 nImg.addEventListener('mousedown', handle, true);
  779.                 nImg.addEventListener('mouseup', handle, true);
  780.                 nImg.addEventListener('mousemove', handle, true);
  781.                 nImg.addEventListener('mouseover', handle, true);
  782.                 nImg.addEventListener('mouseout', handle, true);
  783.                 nImg.addEventListener('mouseenter', handle, true);
  784.                 nImg.addEventListener('mouseleave', handle, true);
  785.                 //nImg.addEventListener('wheel', handle, $.eh_capture_passive());
  786.                 let resObj = {
  787.                     elm: nImg,
  788.                     lastTime: +new Date,
  789.                     cid_fade: 0
  790.                 }
  791.                 _nImgs.push(resObj)
  792.  
  793.                 return nImg;
  794.  
  795.             }
  796.  
  797.             const wmHoverUrl = new WeakMap();
  798.             let lastMouseEnterElm = null;
  799.             let lastMouseEnterAt = 0;
  800.             let lastMouseEnterCid = 0;
  801.  
  802.             function mouseEnter() {
  803.                 lastMouseEnterCid = 0;
  804.  
  805.                 if (+new Date - lastMouseEnterAt < 30) {
  806.                     lastMouseEnterCid = setTimeout(mouseEnter, 82)
  807.                     return;
  808.                 }
  809.  
  810.                 //if($.lpKeyPressing)return;
  811.  
  812.                 const targetElm = lastMouseEnterElm
  813.  
  814.                 Promise.resolve()
  815.                     .then(() => {
  816.                         if (targetElm && targetElm.parentNode) {} else {
  817.                             return;
  818.                         }
  819.                         if (floatingBlockHover.get(targetElm)) {
  820.                             let url = null
  821.                             if (targetElm.getAttribute($.utHoverBlock) == '7' && (url = wmHoverUrl.get(targetElm)) && targetElm.querySelector(`[${$.utHoverBlock}]`) == null) {
  822.                                 let _nImg = nImgFunc();
  823.                                 if (_nImg.parentNode !== targetElm) {
  824.                                     _nImg.setAttribute('src', url);
  825.                                     targetElm.insertBefore(_nImg, targetElm.firstChild);
  826.                                 }
  827.                             }
  828.                             return;
  829.                         }
  830.                         floatingBlockHover.set(targetElm, 1);
  831.                         return 1;
  832.                     }).then((ayRes) => {
  833.                         if (!ayRes) return;
  834.  
  835.                         if (targetElm.nodeType != 1) return;
  836.                         if ("|SVG|IMG|HTML|BODY|VIDEO|AUDIO|BR|HEAD|NOSCRIPT|SCRIPT|STYLE|TEXTAREA|AREA|INPUT|FORM|BUTTON|".indexOf(`|${targetElm.nodeName}|`) >= 0) return;
  837.  
  838.                         const targetArea = targetElm.clientWidth * targetElm.clientHeight
  839.  
  840.                         if (targetArea > 0) {} else {
  841.                             return;
  842.                         }
  843.  
  844.                         const targetCSS = getComputedStyle(targetElm)
  845.                         const targetBgImage = targetCSS.getPropertyValue('background-image');
  846.                         let exec1 = null
  847.  
  848.                         if (targetBgImage != 'none' && (exec1 = /^\s*url\s*\("?([^"\)]+\b(\.gif|\.png|\.jpeg|\.jpg|\.webp)\b[^"\)]*)"?\)\s*$/i.exec(targetBgImage))) {
  849.                             if ((targetElm.textContent || "").trim().length > 0) return;
  850.                             const url = exec1[1];
  851.                             return url
  852.  
  853.                             // console.log(targetBgImage,[...exec1])
  854.                         }
  855.  
  856.  
  857.  
  858.                         if (targetCSS.getPropertyValue('position') == 'absolute' && +targetCSS.getPropertyValue('z-index') > 0) {} else {
  859.                             return;
  860.                         }
  861.                         if ((targetElm.textContent || "").trim().length > 0) return;
  862.  
  863.                         let possibleResults = [];
  864.  
  865.                         for (const imgElm of document.querySelectorAll('img[src]')) {
  866.                             const param = elmParam(imgElm)
  867.                             if (!param.area) {
  868.                                 const area = imgElm.clientWidth * imgElm.clientHeight
  869.                                 if (area > 0) param.area = area;
  870.                             }
  871.                             if (param.area > 0) {
  872.                                 if (targetArea > param.area * 0.9) possibleResults.push(imgElm)
  873.                             }
  874.                         }
  875.  
  876.                         let i = 0;
  877.                         let j = 0;
  878.                         for (const imgElm of possibleResults) {
  879.  
  880.                             const cmpVal = targetElm.compareDocumentPosition(imgElm)
  881.  
  882.                             /*
  883.  
  884.  
  885. 1: The two nodes do not belong to the same document.
  886. 2: p1 is positioned after p2.
  887. 4: p1 is positioned before p2.
  888. 8: p1 is positioned inside p2.
  889. 16: p2 is positioned inside p1.
  890. 32: The two nodes has no relationship, or they are two attributes on the same element.
  891.  
  892.             */
  893.  
  894.                             if (cmpVal & 8 || cmpVal & 16) return;
  895.                             if (cmpVal & 2) j++; // I<p
  896.                             else if (cmpVal & 4) break; // I>p
  897.  
  898.  
  899.                             i++;
  900.  
  901.                         }
  902.  
  903.                         // before: j-1  after: j
  904.  
  905.                         let indexBefore = j - 1;
  906.                         let indexAfter = j;
  907.                         if (indexBefore < 0) indexBefore = 0;
  908.                         if (indexAfter > possibleResults.length - 1) indexAfter = possibleResults.length - 1;
  909.  
  910.                         //    setTimeout(function(){
  911.                         for (let i = indexBefore; i <= indexAfter; i++) {
  912.                             const s = possibleResults[i];
  913.                             const {
  914.                                 area1,
  915.                                 area2,
  916.                                 areaI
  917.                             } = overlapArea(targetElm.getBoundingClientRect(), s.getBoundingClientRect())
  918.                             const criteria = area1 * 0.7
  919.                             if (areaI > 0.9 * area2) {
  920.  
  921.  
  922.                                 return s.getAttribute('src')
  923.  
  924.  
  925.                             }
  926.                         }
  927.                         //   },1000);
  928.  
  929.                     }).then((sUrl) => {
  930.  
  931.                         if (typeof sUrl != 'string') return;
  932.  
  933.                         //console.log(targetElm, targetElm.querySelectorAll('img').length)
  934.  
  935.                         // console.log(313, evt.target, s)
  936.                         let _nImg = nImgFunc();
  937.  
  938.  
  939.                         if (_nImg.parentNode !== targetElm) {
  940.                             _nImg.setAttribute('src', sUrl);
  941.                             targetElm.insertBefore(_nImg, targetElm.firstChild);
  942.                             wmHoverUrl.set(targetElm, sUrl);
  943.                             targetElm.setAttribute($.utHoverBlock, '7');
  944.                         }
  945.  
  946.  
  947.  
  948.                     })
  949.  
  950.             }
  951.  
  952.             document.addEventListener('mouseenter', function(evt) {
  953.                 if(!$.gm_disablehover_enable) return;
  954.                 lastMouseEnterElm = evt.target
  955.                 lastMouseEnterAt = +new Date;
  956.                 if (!lastMouseEnterCid) lastMouseEnterCid = setTimeout(mouseEnter, 82)
  957.             }, $.eh_capture_passive())
  958.  
  959.  
  960.  
  961.         },
  962.  
  963.         acrAuxDown: function(evt) {
  964.  
  965.             if(!$.gm_prevent_aux_click_enable) return;
  966.  
  967.             if (evt.button === 1 ){
  968.                 let check = $.dmmMouseUpLast > $.dmmMouseDownLast && evt.timeStamp - $.dmmMouseUpLast < 40
  969.                 $.dmmMouseDownLast = evt.timeStamp;
  970.                 if( check ) {
  971.                     $.eventCancel(evt, true);
  972.                 }
  973.             }
  974.  
  975.         },
  976.  
  977.         acrAuxUp: function(evt) {
  978.             if(!$.gm_prevent_aux_click_enable) return;
  979.  
  980.             if (evt.button === 1 ){
  981.                 let check = $.dmmMouseDownLast > $.dmmMouseUpLast && evt.timeStamp - $.dmmMouseDownLast < 40;
  982.                 $.dmmMouseUpLast = evt.timeStamp;
  983.                 if( check ) {
  984.                     $.dmmMouseUpCancel = evt.timeStamp;
  985.                     $.eventCancel(evt, true);
  986.                 }
  987.             }
  988.  
  989.         },
  990.  
  991.  
  992.         acrAuxClick: function(evt) {
  993.             if(!$.gm_prevent_aux_click_enable) return;
  994.  
  995.             if (evt.button === 1 ){
  996.                 if( evt.timeStamp - $.dmmMouseUpCancel < 40 ) {
  997.                     $.eventCancel(evt, true);
  998.                 }
  999.             }
  1000.  
  1001.  
  1002.         },
  1003.  
  1004.         preventAuxClickRepeat:function(){
  1005.  
  1006.             document.addEventListener('mousedown', $.acrAuxDown, {
  1007.                 capture: true,
  1008.                 passive: false
  1009.             })
  1010.             document.addEventListener('mouseup', $.acrAuxUp, {
  1011.                 capture: true,
  1012.                 passive: false
  1013.             })
  1014.             document.addEventListener('auxclick', $.acrAuxClick, {
  1015.                 capture: true,
  1016.                 passive: false
  1017.             })
  1018.  
  1019.  
  1020.         },
  1021.  
  1022.         MenuEnable: (
  1023.             class MenuEnable{
  1024.  
  1025.                 constructor(textToEnable, textToDisable, callback, initalEnable){
  1026.                     this.textToEnable=textToEnable;
  1027.                     this.textToDisable=textToDisable;
  1028.                     this.callback=callback;
  1029.                     this.gx=this.gx.bind(this);
  1030.                 }
  1031.  
  1032.                 unregister(){
  1033.                     (this.h>=0)?(GM_unregisterMenuCommand(this.h), (this.h=0)):0;
  1034.                 }
  1035.  
  1036.                 register(text){
  1037.                     if(typeof text == 'string') this.showText = text;
  1038.                     text = this.showText;
  1039.                     if(typeof text != 'string') return;
  1040.                     this.h=GM_registerMenuCommand(text, this.gx);
  1041.                 }
  1042.  
  1043.                 a(o){
  1044.  
  1045.                     if(this.enabled===o.bEnable) return;
  1046.                     this.enabled = o.bEnable;
  1047.                     this.unregister();
  1048.  
  1049.  
  1050.                     let pr= 0 ;
  1051.  
  1052.                     if($.gm_status_fn_store && $.gm_status_fn_store.indexOf(this)>=0){
  1053.  
  1054.                         let store = $.gm_status_fn_store
  1055.                         let idx = store.indexOf(this)
  1056.                         let count = store.length;
  1057.  
  1058.  
  1059.                         if(idx>=0&&idx<=count-2){
  1060.  
  1061.                             console.log(idx, count)
  1062.  
  1063.                             for(let jdx=idx+1;jdx<count;jdx++){
  1064.  
  1065.                                 store[jdx].unregister();
  1066.                             }
  1067.  
  1068.                             this.register (o.bText);
  1069.  
  1070.                             for(let jdx=idx+1;jdx<count;jdx++){
  1071.  
  1072.                                 store[jdx].register();
  1073.                             }
  1074.  
  1075.                             pr=1;
  1076.  
  1077.                         }
  1078.  
  1079.  
  1080.                     }
  1081.  
  1082.                     if(!pr) this.register (o.bText);
  1083.  
  1084.                     this.callback(this.enabled, o.byUserInput);
  1085.  
  1086.  
  1087.                 }
  1088.  
  1089.                 enableNow(byUserInput){
  1090.                     this.a({
  1091.                         bEnable: true,
  1092.                         bText: this.textToDisable,
  1093.                         byUserInput
  1094.                     });
  1095.  
  1096.                 }
  1097.  
  1098.                 gx(){
  1099.                     if(this.enabled) this.disableNow(true);
  1100.                     else this.enableNow(true);
  1101.  
  1102.                 }
  1103.  
  1104.                 disableNow(byUserInput){
  1105.                     this.a({
  1106.                         bEnable: false,
  1107.                         bText: this.textToEnable,
  1108.                         byUserInput
  1109.                     });
  1110.  
  1111.                 }
  1112.  
  1113.                 toggle(enable, byUserInput){
  1114.                     enable?this.enableNow(byUserInput):this.disableNow(byUserInput);
  1115.                 }
  1116.  
  1117.             }
  1118.         ),
  1119.  
  1120.         gm_status_fn: function(gm_name, textToEnable, textToDisable, callback){
  1121.  
  1122.             let menuEnableName = gm_name + "$menuEnable";
  1123.  
  1124.             function set_gm(enabled){
  1125.                 $[gm_name]=enabled;
  1126.                 let menuEnable = $[menuEnableName];
  1127.                 if( menuEnable ){
  1128.                     menuEnable.toggle(enabled)
  1129.                 };
  1130.                 callback(enabled)
  1131.             }
  1132.  
  1133.             set_gm(!!GM_getValue(gm_name));
  1134.  
  1135.             GM_addValueChangeListener(gm_name,function(name, old_value, new_value, remote){
  1136.  
  1137.                 if(old_value === new_value) return;
  1138.                 if(new_value === $[gm_name]) return;
  1139.                 set_gm(new_value);
  1140.  
  1141.             });
  1142.  
  1143.             if(!inIframe()){
  1144.  
  1145.                 $.gm_status_fn_store=$.gm_status_fn_store||[];
  1146.  
  1147.                 $[menuEnableName]=new $.MenuEnable(textToEnable, textToDisable, (enabled) => {
  1148.                     GM_setValue(gm_name, !!enabled);
  1149.                 });
  1150.  
  1151.                 $.gm_status_fn_store.push($[menuEnableName]);
  1152.  
  1153.                 $[menuEnableName].toggle(!!GM_getValue(gm_name));
  1154.  
  1155.             }
  1156.  
  1157.  
  1158.  
  1159.         }
  1160.  
  1161.     }
  1162.  
  1163.     // $.holdingElm=null;
  1164.  
  1165.     $.mainEnableScript();
  1166.  
  1167.     if (isSupportAdvancedEventListener()) $.lpEnable(); // top capture event for alt-click
  1168.  
  1169.     $.mainEvents(
  1170.         function(evt) {
  1171.             //   $.holdingElm=evt.target;
  1172.             //   console.log('down',evt.target)
  1173.             if ($.onceCssHighlightSelection) window.requestAnimationFrame($.onceCssHighlightSelection);
  1174.             if (evt.button == 2 || evt.type == "contextmenu") $.mAlert_DOWN();
  1175.         },
  1176.         function(evt) {
  1177.             //  $.holdingElm=null;
  1178.             //   console.log('up',evt.target)
  1179.             if (evt.button == 2) $.mAlert_UP();
  1180.             if ($.enableDragging) {
  1181.                 $.enableDragging = false;
  1182.             }
  1183.         }
  1184.     );
  1185.  
  1186.     $.disableHoverBlock();
  1187.     $.preventAuxClickRepeat();
  1188.  
  1189.     console.log('userscript running - To Re-Enable Selection & Copying');
  1190.  
  1191.  
  1192.     $.gm_status_fn("gm_lp_enable", "To Enable `Enhanced build-in Alt Text Selection`", "To Disable `Enhanced build-in Alt Text Selection`", ()=>{
  1193.     // callback
  1194.     });
  1195.     $.gm_status_fn("gm_disablehover_enable", "To Enable `Hover on Image`", "To Disable `Hover on Image`", ()=>{
  1196.     // callback
  1197.     });
  1198.     $.gm_status_fn("gm_prevent_aux_click_enable", "To Enable `Repetitive AuxClick Prevention`", "To Disable `Repetitive AuxClick Prevention`", ()=>{
  1199.     // callback
  1200.     });
  1201.  
  1202.  
  1203.  
  1204.  
  1205. })();