☰

HTML5 Video Player Enhance

To enhance the functionality of HTML5 Video Player (h5player) supporting all websites using shortcut keys similar to PotPlayer.

目前為 2021-07-06 提交的版本，檢視 最新版本。

  1. // ==UserScript==
  2. // @name         HTML5 Video Player Enhance
  3. // @version      2.9.5.14
  4. // @description  To enhance the functionality of HTML5 Video Player (h5player) supporting all websites using shortcut keys similar to PotPlayer.
  5. // @author       CY Fung
  6. // @icon https://image.flaticon.com/icons/png/128/3291/3291444.png
  7. // @match        https://*/*
  8. // @match        http://*/*
  9. // @run-at       document-start
  10. // @require https://cdnjs.cloudflare.com/ajax/libs/js-sha256/0.9.0/sha256.min.js
  11. // @namespace https://greasyfork.org/users/371179
  12. // @grant   GM_getValue
  13. // @grant   GM_setValue
  14. // @grant   GM_addStyle
  15. // @grant   unsafeWindow
  16. // ==/UserScript==
  17. /**
  18.  * Remarks
  19.  * This script support modern browser only with ES6+.
  20.  * fullscreen and pointerLock   buggy in shadowRoot
  21.  * Space Pause not success
  22.  * shift F key issue
  23.  **/
  24. !(function($winUnsafe, $winSafe) {
  25.     'use strict';
  26.  
  27.  
  28.     !(() => 0)({
  29.         requestAnimationFrame,
  30.         cancelAnimationFrame,
  31.         MutationObserver,
  32.         setInterval,
  33.         clearInterval,
  34.         EventTarget,
  35.         Promise,
  36.         ResizeObserver
  37.     });
  38.     //throw Error if your browser is too outdated. (eg ES6 script, no such window object)
  39.  
  40.     const window = $winUnsafe || $winSafe
  41.     const document = window.document
  42.     const $$uWin = $winUnsafe || $winSafe;
  43.  
  44.     const $rAf = $$uWin.requestAnimationFrame;
  45.     const $cAf = $$uWin.cancelAnimationFrame;
  46.  
  47.     const $$setTimeout = $$uWin.setTimeout
  48.     const $$clearTimeout = $$uWin.clearTimeout
  49.     const $$requestAnimationFrame = $$uWin.requestAnimationFrame;
  50.     const $$cancelAnimationFrame = $$uWin.cancelAnimationFrame;
  51.  
  52.     const $$addEventListener = Node.prototype.addEventListener;
  53.     const $$removeEventListener = Node.prototype.removeEventListener;
  54.  
  55.     const $bz = {
  56.             boosted: false
  57.         }
  58.  
  59.     const utPositioner='KVZX';
  60.  
  61.     1&&!(function(){
  62.  
  63.         let $requestAnimationFrame= window.requestAnimationFrame;
  64.         let $cancelAnimationFrame= window.cancelAnimationFrame;
  65.         let $setTimeout= window.setTimeout;
  66.         let $clearTimeout= window.clearTimeout;
  67.         let p = Promise.resolve();
  68.         window.setTimeout=function(f,d){
  69.             if(!$bz.boosted || arguments.length>2) return $setTimeout.apply(this,arguments);
  70.             let g=function(){
  71.                 p=p.then(()=>f.apply(this,arguments)).catch(console.warn)
  72.             }
  73.             return $setTimeout(g,d);
  74.         }
  75.         window.requestAnimationFrame=function(f){
  76.             if(!$bz.boosted || arguments.length!=1) return $requestAnimationFrame.apply(this,arguments);
  77.             let g=function(){
  78.                 p=p.then(()=>f.apply(this,arguments)).catch(console.warn)
  79.             }
  80.             return $requestAnimationFrame(g);
  81.         }
  82.  
  83.     })()
  84.  
  85.     1&&!(function $$() {
  86.         'use strict';
  87.  
  88.         if (!document) return;
  89.         if (!document.documentElement) return window.requestAnimationFrame($$);
  90.  
  91.         const prettyElm = function(elm) {
  92.             if (!elm || !elm.nodeName) return null;
  93.             const eId = elm.id || null;
  94.             const eClsName = elm.className || null;
  95.             return [elm.nodeName.toLowerCase(), typeof eId == 'string' ? "#" + eId : '', typeof eClsName == 'string' ? '.' + eClsName.replace(/\s+/g, '.') : ''].join('').trim();
  96.         }
  97.  
  98.         const delayCall = function(p, f, d) {
  99.             if (delayCall[p] > 0) delayCall[p] = window.clearTimeout(delayCall[p])
  100.             if (f) delayCall[p] = window.setTimeout(f, d)
  101.         }
  102.  
  103.         function isVideoPlaying(video){
  104.             return video.currentTime > 0 && !video.paused && !video.ended && video.readyState > video.HAVE_CURRENT_DATA;
  105.         }
  106.  
  107.  
  108.         const wmListeners = new WeakMap();
  109.  
  110.         class Listeners {
  111.             constructor() {}
  112.             get count() {
  113.                 return (this._count || 0)
  114.             }
  115.             makeId() {
  116.                 return ++this._lastId
  117.             }
  118.             add(lh) {
  119.                 this[++this._lastId] = lh;
  120.             }
  121.             remove(lh_removal) {
  122.                 for (let k in this) {
  123.                     let lh = this[k]
  124.                     if (lh && lh.constructor == ListenerHandle && lh_removal.isEqual(lh)) {
  125.                         delete this[k];
  126.                         this._count--;
  127.                     }
  128.                 }
  129.             }
  130.         }
  131.  
  132.  
  133.         class ListenerHandle {
  134.             constructor(func, options) {
  135.                 this.func = func
  136.                 this.options = options
  137.             }
  138.             isEqual(anotherLH) {
  139.                 if (this.func != anotherLH.func) return false;
  140.                 if (this.options === anotherLH.options) return true;
  141.                 if (this.options && anotherLH.options && typeof this.options == 'object' && typeof anotherLH.options == 'object') {} else {
  142.                     return false;
  143.                 }
  144.                 return this.uOpt() == anotherLH.uOpt()
  145.             }
  146.             uOpt() {
  147.                 let opt1 = "";
  148.                 for (var k in this.options) {
  149.                     opt1 += ", " + k + " : " + (typeof this[k] == 'boolean' ? this[k] : "N/A");
  150.                 }
  151.                 return opt1;
  152.             }
  153.         }
  154.  
  155.  
  156.         Object.defineProperties(Listeners.prototype, {
  157.             _lastId: {
  158.                 value: 0,
  159.                 writable: true,
  160.                 enumerable: false,
  161.                 configurable: true
  162.             },
  163.             _count: {
  164.                 value: 0,
  165.                 writable: true,
  166.                 enumerable: false,
  167.                 configurable: true
  168.             }
  169.         });
  170.  
  171.  
  172.  
  173.  
  174.         let _debug_h5p_logging_ = false;
  175.  
  176.         try {
  177.             _debug_h5p_logging_ = +window.localStorage.getItem('_h5_player_sLogging_') > 0
  178.         } catch (e) {}
  179.  
  180.  
  181.  
  182.         const SHIFT = 1;
  183.         const CTRL = 2;
  184.         const ALT = 4;
  185.         const TERMINATE = 0x842;
  186.         const _sVersion_ = 1817;
  187.         const str_postMsgData = '__postMsgData__'
  188.         const DOM_ACTIVE_FOUND = 1;
  189.         const DOM_ACTIVE_SRC_LOADED = 2;
  190.         const DOM_ACTIVE_ONCE_PLAYED = 4;
  191.         const DOM_ACTIVE_MOUSE_CLICK = 8;
  192.         const DOM_ACTIVE_KEY_DOWN = 64;
  193.         const DOM_ACTIVE_FULLSCREEN = 128;
  194.         const DOM_ACTIVE_MOUSE_IN = 16;
  195.         const DOM_ACTIVE_DELAYED_PAUSED = 32;
  196.         const DOM_ACTIVE_INVALID_PARENT = 2048;
  197.  
  198.         var console = {};
  199.  
  200.         console.log = function() {
  201.             window.console.log(...['[h5p]', ...arguments])
  202.         }
  203.         console.error = function() {
  204.             window.console.error(...['[h5p]', ...arguments])
  205.         }
  206.  
  207.         function makeNoRoot(shadowRoot) {
  208.             const doc = shadowRoot.ownerDocument || document;
  209.             const htmlInShadowRoot = doc.createElement('noroot'); // pseudo element
  210.             const childNodes = [...shadowRoot.childNodes]
  211.             shadowRoot.insertBefore(htmlInShadowRoot, shadowRoot.firstChild)
  212.             for (const childNode of childNodes) htmlInShadowRoot.appendChild(childNode);
  213.             return shadowRoot.querySelector('noroot');
  214.         }
  215.  
  216.         let _endlessloop = null;
  217.         const isIframe = (window.top !== window.self && window.top && window.self);
  218.         const rootDocs = [];
  219.  
  220.         const _getRoot = Element.prototype.getRootNode || HTMLElement.prototype.getRootNode || function() {
  221.             let elm = this;
  222.             while (elm) {
  223.                 if ('host' in elm) return elm;
  224.                 elm = elm.parentNode;
  225.             }
  226.             return elm;
  227.         }
  228.  
  229.         const getRoot = (elm) => _getRoot.call(elm);
  230.  
  231.  
  232.  
  233.         class VQuery{
  234.  
  235.             constructor(){
  236.             this.videos={};
  237.                 this.wmMutations={};
  238.             }
  239.             setVideo(key, value){this.videos[key]=value}
  240.             player(key){
  241.                 const video=this.videos[key];
  242.                 return video&&video.parentNode?video:null;
  243.             }
  244.             rootNode(key){
  245.                 const video=this.videos[key];
  246.                 return video?getRoot(video):null;
  247.             }
  248.  
  249.         }
  250.  
  251.         const $vQuery=new VQuery();
  252.  
  253.         const isShadowRoot = (elm) => (elm && ('host' in elm)) ? elm.nodeType == 11 && !!elm.host && elm.host.nodeType == 1 : null; //instanceof ShadowRoot
  254.  
  255.  
  256.         const domAppender = (d) => d.querySelector('head') || d.querySelector('html') || d.querySelector('noroot') || null;
  257.  
  258.         const playerConfs = {}
  259.  
  260.         const hanlderResizeVideo = (entries) => {
  261.             const detected_changes = {};
  262.             for (let entry of entries) {
  263.                 const player = entry.target.nodeName == "VIDEO" ? entry.target : entry.target.querySelector("VIDEO[_h5ppid]");
  264.                 if (!player || !player.parentNode) continue;
  265.                 const vpid = player.getAttribute('_h5ppid');
  266.                 if (!vpid) continue;
  267.                 if (vpid in detected_changes) continue;
  268.                 detected_changes[vpid] = true;
  269.                 const {wPlayerInner,wPlayer} = $hs.getPlayerBlockElement(player)
  270.                 if (!wPlayerInner) continue;
  271.                 const layoutBoxInner = wPlayerInner.parentNode
  272.                 if (!layoutBoxInner) continue;
  273.                 let tipsDom = layoutBoxInner.querySelector('[data-h5p-pot-tips]');
  274.  
  275.                 if (tipsDom) {
  276.                     if (tipsDom._tips_display_none) tipsDom.setAttribute('data-h5p-pot-tips', '')
  277.                     $hs.fixNonBoxingVideoTipsPosition(tipsDom, player);
  278.                 } else {
  279.                     tipsDom = $vQuery.rootNode(vpid).querySelector(`#${player.getAttribute('_h5player_tips')}`)
  280.                     if (tipsDom) {
  281.                         if (tipsDom._tips_display_none) tipsDom.setAttribute('data-h5p-pot-tips', '')
  282.                         $hs.change_layoutBox(tipsDom, player);
  283.                         $hs.tipsDomObserve(tipsDom, player);
  284.                     }
  285.                 }
  286.  
  287.             }
  288.         };
  289.  
  290.         const $mb = {
  291.  
  292.  
  293.  
  294.             nightly_isSupportQueueMicrotask: function() {
  295.  
  296.                 if ('_isSupportQueueMicrotask' in $mb) return $mb._isSupportQueueMicrotask;
  297.  
  298.                 $mb._isSupportQueueMicrotask = false;
  299.                 $mb.queueMicrotask = window.queueMicrotask;
  300.                 if (typeof $mb.queueMicrotask == 'function') {
  301.                     $mb._isSupportQueueMicrotask = true;
  302.                 }
  303.  
  304.                 return $mb._isSupportQueueMicrotask;
  305.  
  306.             },
  307.  
  308.             stable_isSupportAdvancedEventListener: function() {
  309.  
  310.                 if ('_isSupportAdvancedEventListener' in $mb) return $mb._isSupportAdvancedEventListener
  311.                 let prop = 0;
  312.                 $$addEventListener.call(document.createAttribute('z'), 'z', () => 0, {
  313.                     get passive() {
  314.                         prop++;
  315.                     },
  316.                     get once() {
  317.                         prop++;
  318.                     }
  319.                 });
  320.                 return ($mb._isSupportAdvancedEventListener = (prop == 2));
  321.             },
  322.  
  323.             stable_isSupportPassiveEventListener: function() {
  324.  
  325.                 if ('_isSupportPassiveEventListener' in $mb) return $mb._isSupportPassiveEventListener
  326.                 let prop = 0;
  327.                 $$addEventListener.call(document.createAttribute('z'), 'z', () => 0, {
  328.                     get passive() {
  329.                         prop++;
  330.                     }
  331.                 });
  332.                 return ($mb._isSupportPassiveEventListener = (prop == 1));
  333.             },
  334.  
  335.             eh_capture_passive: () => ($mb._eh_capture_passive = $mb._eh_capture_passive || ($mb.stable_isSupportPassiveEventListener() ? {
  336.                 capture: true,
  337.                 passive: true
  338.             } : true)),
  339.  
  340.             eh_bubble_passive: () => ($mb._eh_capture_passive = $mb._eh_capture_passive || ($mb.stable_isSupportPassiveEventListener() ? {
  341.                 capture: false,
  342.                 passive: true
  343.             } : false))
  344.  
  345.         }
  346.  
  347.  
  348.  
  349.         Element.prototype.__matches__ = (Element.prototype.matches || Element.prototype.matchesSelector ||
  350.             Element.prototype.mozMatchesSelector || Element.prototype.msMatchesSelector ||
  351.             Element.prototype.oMatchesSelector || Element.prototype.webkitMatchesSelector ||
  352.             Element.prototype.matches()); // throw Error if not supported
  353.  
  354.         //  built-in hash - https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest
  355.         async function digestMessage(message) {
  356.             return $winSafe.sha256(message)
  357.         }
  358.  
  359.         const dround = (x) => ~~(x + .5);
  360.  
  361.         const jsonStringify_replacer = function(key, val) {
  362.             if (val && (val instanceof Element || val instanceof Document)) return val.toString();
  363.             return val; // return as is
  364.         };
  365.  
  366.         const jsonParse = function() {
  367.             try {
  368.                 return JSON.parse.apply(this, arguments)
  369.             } catch (e) {}
  370.             return null;
  371.         }
  372.         const jsonStringify = function(obj) {
  373.             try {
  374.                 return JSON.stringify.call(this, obj, jsonStringify_replacer)
  375.             } catch (e) {}
  376.             return null;
  377.         }
  378.  
  379.         function _postMsg() {
  380.             //async is needed. or error handling for postMessage
  381.             const [win, tag, ...data] = arguments;
  382.             if (typeof tag == 'string') {
  383.                 let postMsgObj = {
  384.                     tag,
  385.                     passing: true,
  386.                     winOrder: _postMsg.a
  387.                 }
  388.                 try {
  389.                     let k = 'msg-' + (+new Date)
  390.                     win.document[str_postMsgData] = win.document[str_postMsgData] || {}
  391.                     win.document[str_postMsgData][k] = data; //direct
  392.                     postMsgObj.str = k;
  393.                     postMsgObj.stype = 1;
  394.                 } catch (e) {}
  395.                 if (!postMsgObj.stype) {
  396.                     postMsgObj.str = jsonStringify({
  397.                         d: data
  398.                     })
  399.                     if (postMsgObj.str && postMsgObj.str.length) postMsgObj.stype = 2;
  400.                 }
  401.                 if (!postMsgObj.stype) {
  402.                     postMsgObj.str = "" + data;
  403.                     postMsgObj.stype = 0;
  404.                 }
  405.                 win.postMessage(postMsgObj, '*');
  406.             }
  407.  
  408.         }
  409.  
  410.         function postMsg() {
  411.             let win = window;
  412.             let a = 0;
  413.             while ((win = win.parent) && ('postMessage' in win)) {
  414.                 _postMsg.a = ++a;
  415.                 _postMsg(win, ...arguments)
  416.                 if (win == top) break;
  417.             }
  418.         }
  419.  
  420.  
  421.         function crossBrowserTransition(type) {
  422.             if (crossBrowserTransition['_result_' + type]) return crossBrowserTransition['_result_' + type]
  423.             let el = document.createElement("fakeelement");
  424.  
  425.             const capital = (x) => x[0].toUpperCase() + x.substr(1);
  426.             const capitalType = capital(type);
  427.  
  428.             const transitions = {
  429.                 [type]: `${type}end`,
  430.                 [`O${capitalType}`]: `o${capitalType}End`,
  431.                 [`Moz${capitalType}`]: `${type}end`,
  432.                 [`Webkit${capitalType}`]: `webkit${capitalType}End`,
  433.                 [`MS${capitalType}`]: `MS${capitalType}End`
  434.             }
  435.  
  436.             for (let styleProp in transitions) {
  437.                 if (el.style[styleProp] !== undefined) {
  438.                     return (crossBrowserTransition['_result_' + type] = transitions[styleProp]);
  439.                 }
  440.             }
  441.         }
  442.  
  443.         function isInOperation(elm) {
  444.             let elmInFocus = elm || document.activeElement;
  445.             if (!elmInFocus) return false;
  446.             let res1 = elmInFocus.__matches__(
  447.                 'a[href],link[href],button,input:not([type="hidden"]),select,textarea,iframe,frame,menuitem,[draggable],[contenteditable]'
  448.             );
  449.             return res1;
  450.         }
  451.  
  452.         const fn_toString = (f, n = 50) => {
  453.             let s = (f + "");
  454.             if (s.length > 2 * n + 5) {
  455.                 s = s.substr(0, n) + ' ... ' + s.substr(-n);
  456.             }
  457.             return s
  458.         };
  459.  
  460.         function consoleLog() {
  461.             if (!_debug_h5p_logging_) return;
  462.             if (isIframe) postMsg('consoleLog', ...arguments);
  463.             else console.log.apply(console, arguments);
  464.         }
  465.  
  466.         function consoleLogF() {
  467.             if (isIframe) postMsg('consoleLog', ...arguments);
  468.             else console.log.apply(console, arguments);
  469.         }
  470.  
  471.         class AFLooperArray extends Array {
  472.             constructor() {
  473.                 super();
  474.                 this.activeLoopsCount = 0;
  475.                 this.cid = 0;
  476.                 this.loopingFrame = this.loopingFrame.bind(this);
  477.             }
  478.  
  479.             loopingFrame() {
  480.                 if (!this.cid) return; //cancelled
  481.                 for (const opt of this) {
  482.                     if (opt.isFunctionLooping) opt.fn();
  483.                 }
  484.             }
  485.  
  486.             get isArrayLooping() {
  487.                 return this.cid > 0;
  488.             }
  489.  
  490.             loopStart() {
  491.                 this.cid = window.setInterval(this.loopingFrame, 300);
  492.             }
  493.             loopStop() {
  494.                 if (this.cid) window.clearInterval(this.cid);
  495.                 this.cid = 0;
  496.             }
  497.             appendLoop(fn) {
  498.                 if (typeof fn != 'function' || !this) return;
  499.                 const opt = new AFLooperFunc(fn, this);
  500.                 super.push(opt);
  501.                 return opt;
  502.             }
  503.         }
  504.  
  505.         class AFLooperFunc {
  506.             constructor(fn, bind) {
  507.                 this._looping = false;
  508.                 this.bind = bind;
  509.                 this.fn = fn;
  510.             }
  511.             get isFunctionLooping() {
  512.                 return this._looping;
  513.             }
  514.             loopingStart() {
  515.                 if (this._looping === false) {
  516.                     this._looping = true;
  517.                     if (++this.bind.activeLoopsCount == 1) this.bind.loopStart();
  518.                 }
  519.             }
  520.             loopingStop() {
  521.                 if (this._looping === true) {
  522.                     this._looping = false;
  523.                     if (--this.bind.activeLoopsCount == 0) this.bind.loopStop();
  524.                 }
  525.             }
  526.         }
  527.  
  528.         function decimalEqual(a, b) {
  529.             return Math.round(a * 100000000) == Math.round(b * 100000000)
  530.         }
  531.  
  532.         function nonZeroNum(a) {
  533.             return a > 0 || a < 0;
  534.         }
  535.  
  536.         class PlayerConf {
  537.  
  538.             get scaleFactor() {
  539.                 return this.mFactor * this.vFactor;
  540.             }
  541.  
  542.             cssTransform() {
  543.  
  544.                 const playerConf = this;
  545.                 const player = playerConf.domElement;
  546.                 if (!player || !player.parentNode) return;
  547.                 const videoScale = playerConf.scaleFactor;
  548.  
  549.                 let {
  550.                     x,
  551.                     y
  552.                 } = playerConf.translate;
  553.  
  554.                 let [_x, _y] = ((playerConf.rotate % 180) == 90) ? [y, x] : [x, y];
  555.  
  556.  
  557.                 if ((playerConf.rotate % 360) == 270) _x = -_x;
  558.                 if ((playerConf.rotate % 360) == 90) _y = -_y;
  559.  
  560.                 var s = [
  561.                     playerConf.rotate > 0 ? 'rotate(' + playerConf.rotate + 'deg)' : '',
  562.                     !decimalEqual(videoScale, 1.0) ? 'scale(' + videoScale + ')' : '',
  563.                     (nonZeroNum(_x) || nonZeroNum(_y)) ? `translate(${_x}px, ${_y}px)` : '',
  564.                 ];
  565.  
  566.                 player.style.transform = s.join(' ').trim()
  567.  
  568.             }
  569.  
  570.             constructor() {
  571.  
  572.                 this.translate = {
  573.                     x: 0,
  574.                     y: 0
  575.                 };
  576.                 this.rotate = 0;
  577.                 this.mFactor = 1.0;
  578.                 this.vFactor = 1.0;
  579.                 this.fps = 30;
  580.                 this.filter_key = {};
  581.                 this.filter_view_units = {
  582.                     'hue-rotate': 'deg',
  583.                     'blur': 'px'
  584.                 };
  585.                 this.filterReset();
  586.  
  587.             }
  588.  
  589.             setFilter(prop, f) {
  590.  
  591.                 let oldValue = this.filter_key[prop];
  592.                 if (typeof oldValue != 'number') return;
  593.                 let newValue = f(oldValue)
  594.                 if (oldValue != newValue) {
  595.  
  596.                     newValue = +newValue.toFixed(6); //javascript bug
  597.  
  598.                 }
  599.  
  600.                 this.filter_key[prop] = newValue
  601.                 this.filterSetup();
  602.  
  603.                 return newValue;
  604.  
  605.  
  606.  
  607.             }
  608.  
  609.             filterSetup(options) {
  610.  
  611.                 let ums = GM_getValue("unsharpen_mask")
  612.                 if (!ums) ums = ""
  613.  
  614.                 let view = []
  615.                 let playerElm = $hs.player();
  616.                 if (!playerElm || !playerElm.parentNode) return;
  617.                 for (let view_key in this.filter_key) {
  618.                     let filter_value = +((+this.filter_key[view_key] || 0).toFixed(3))
  619.                     let addTo = true;
  620.                     switch (view_key) {
  621.                         case 'brightness':
  622.                             /* fall through */
  623.                         case 'contrast':
  624.                             /* fall through */
  625.                         case 'saturate':
  626.                             if (decimalEqual(filter_value, 1.0)) addTo = false;
  627.                             break;
  628.                         case 'hue-rotate':
  629.                             /* fall through */
  630.                         case 'blur':
  631.                             if (decimalEqual(filter_value, 0.0)) addTo = false;
  632.                             break;
  633.                     }
  634.                     let view_unit = this.filter_view_units[view_key] || ''
  635.                     if (addTo) view.push(`${view_key}(${filter_value}${view_unit})`)
  636.                     this.filter_key[view_key] = Number(+this.filter_key[view_key] || 0)
  637.                 }
  638.                 if (ums) view.push(`url("#_h5p_${ums}")`);
  639.                 if (options && options.grey) view.push('url("#grey1")');
  640.                 playerElm.style.filter = view.join(' ').trim(); //performance in firefox is bad
  641.             }
  642.  
  643.             filterReset() {
  644.                 this.filter_key['brightness'] = 1.0
  645.                 this.filter_key['contrast'] = 1.0
  646.                 this.filter_key['saturate'] = 1.0
  647.                 this.filter_key['hue-rotate'] = 0.0
  648.                 this.filter_key['blur'] = 0.0
  649.                 this.filterSetup()
  650.             }
  651.  
  652.         }
  653.  
  654.         const Store = {
  655.             prefix: '_h5_player',
  656.             save: function(k, v) {
  657.                 if (!Store.available()) return false;
  658.                 if (typeof v != 'string') return false;
  659.                 Store.LS.setItem(Store.prefix + k, v)
  660.                 let sk = fn_toString(k + "", 30);
  661.                 let sv = fn_toString(v + "", 30);
  662.                 consoleLog(`localStorage Saved "${sk}" = "${sv}"`)
  663.                 return true;
  664.  
  665.             },
  666.             read: function(k) {
  667.                 if (!Store.available()) return false;
  668.                 let v = Store.LS.getItem(Store.prefix + k)
  669.                 let sk = fn_toString(k + "", 30);
  670.                 let sv = fn_toString(v + "", 30);
  671.                 consoleLog(`localStorage Read "${sk}" = "${sv}"`);
  672.                 return v;
  673.  
  674.             },
  675.             remove: function(k) {
  676.  
  677.                 if (!Store.available()) return false;
  678.                 Store.LS.removeItem(Store.prefix + k)
  679.                 let sk = fn_toString(k + "", 30);
  680.                 consoleLog(`localStorage Removed "${sk}"`)
  681.                 return true;
  682.             },
  683.             clearInvalid: function(sVersion) {
  684.                 if (!Store.available()) return false;
  685.  
  686.                 //let sVersion=1814;
  687.                 if (+Store.read('_sVersion_') < sVersion) {
  688.                     Store._keys()
  689.                         .filter(s => s.indexOf(Store.prefix) === 0)
  690.                         .forEach(key => window.localStorage.removeItem(key))
  691.                     Store.save('_sVersion_', sVersion + '')
  692.                     return 2;
  693.                 }
  694.                 return 1;
  695.  
  696.             },
  697.             available: function() {
  698.                 if (Store.LS) return true;
  699.                 if (!window) return false;
  700.                 const localStorage = window.localStorage;
  701.                 if (!localStorage) return false;
  702.                 if (typeof localStorage != 'object') return false;
  703.                 if (!('getItem' in localStorage)) return false;
  704.                 if (!('setItem' in localStorage)) return false;
  705.                 Store.LS = localStorage;
  706.                 return true;
  707.  
  708.             },
  709.             _keys: function() {
  710.                 return Object.keys(localStorage);
  711.             },
  712.             _setItem: function(key, value) {
  713.                 return localStorage.setItem(key, value)
  714.             },
  715.             _getItem: function(key) {
  716.                 return localStorage.getItem(key)
  717.             },
  718.             _removeItem: function(key) {
  719.                 return localStorage.removeItem(key)
  720.             }
  721.  
  722.         }
  723.  
  724.         const domTool = {
  725.             cssWH: function(m, r) {
  726.                 if (!r) r = getComputedStyle(m, null);
  727.                 let c = (x) => +x.replace('px', '');
  728.                 return {
  729.                     w: m.offsetWidth || c(r.width),
  730.                     h: m.offsetHeight || c(r.height)
  731.                 }
  732.             },
  733.             _isActionBox_1: function(vEl, pEl) {
  734.  
  735.                 const vElCSS = domTool.cssWH(vEl);
  736.                 let vElCSSw = vElCSS.w;
  737.                 let vElCSSh = vElCSS.h;
  738.  
  739.                 let vElx = vEl;
  740.                 const res = [];
  741.                 //let mLevel = 0;
  742.                 if (vEl && pEl && vEl != pEl && pEl.contains(vEl)) {
  743.                     while (vElx && vElx != pEl) {
  744.                         vElx = vElx.parentNode;
  745.                         let vElx_css = null;
  746.                         if (isShadowRoot(vElx)) {} else {
  747.                             vElx_css = getComputedStyle(vElx, null);
  748.                             let vElx_wp = parseFloat(vElx_css.paddingLeft) + parseFloat(vElx_css.paddingRight)
  749.                             vElCSSw += vElx_wp
  750.                             let vElx_hp = parseFloat(vElx_css.paddingTop) + parseFloat(vElx_css.paddingBottom)
  751.                             vElCSSh += vElx_hp
  752.                         }
  753.                         res.push({
  754.                             //level: ++mLevel,
  755.                             padW: vElCSSw,
  756.                             padH: vElCSSh,
  757.                             elm: vElx,
  758.                             css: vElx_css
  759.                         })
  760.  
  761.                     }
  762.                 }
  763.  
  764.                 // in the array, each item is the parent of video player
  765.                 //res.vEl_cssWH = vElCSS
  766.  
  767.                 return res;
  768.  
  769.             },
  770.             _isActionBox: function(vEl, walkRes, pEl_idx) {
  771.  
  772.                 function absDiff(w1, w2, h1, h2) {
  773.                     const w = (w1 - w2),
  774.                         h = h1 - h2;
  775.                     return [(w > 0 ? w : -w), (h > 0 ? h : -h)]
  776.                 }
  777.  
  778.                 function midPoint(rect) {
  779.                     return {
  780.                         x: (rect.left + rect.right) / 2,
  781.                         y: (rect.top + rect.bottom) / 2
  782.                     }
  783.                 }
  784.  
  785.                 const parentCount = walkRes.length;
  786.                 if (pEl_idx >= 0 && pEl_idx < parentCount) {} else {
  787.                     return;
  788.                 }
  789.                 const pElr = walkRes[pEl_idx]
  790.                 if (!pElr.css) {
  791.                     //shadowRoot
  792.                     return true;
  793.                 }
  794.  
  795.                 const pEl = pElr.elm;
  796.  
  797.                 //prevent activeElement==body
  798.                 const pElCSS = domTool.cssWH(pEl, pElr.css);
  799.  
  800.                 //check prediction of parent dimension
  801.                 const d1v = absDiff(pElCSS.w, pElr.padW, pElCSS.h, pElr.padH)
  802.  
  803.                 const d1x = d1v[0] < 10
  804.                 const d1y = d1v[1] < 10;
  805.  
  806.                 if (d1x && d1y) return true; //both edge along the container   -  fit size
  807.                 if (!d1x && !d1y) return false; //no edge along the container     -  body contain the video element, fixed width&height
  808.  
  809.                 //case: youtube video fullscreen
  810.  
  811.                 //check centre point
  812.  
  813.                 const pEl_rect = pEl.getBoundingClientRect()
  814.                 const vEl_rect = vEl.getBoundingClientRect()
  815.  
  816.                 const pEl_center = midPoint(pEl_rect)
  817.                 const vEl_center = midPoint(vEl_rect)
  818.  
  819.                 const d2v = absDiff(pEl_center.x, vEl_center.x, pEl_center.y, vEl_center.y);
  820.  
  821.                 const d2x = d2v[0] < 10;
  822.                 const d2y = d2v[1] < 10;
  823.  
  824.                 return (d2x && d2y);
  825.  
  826.             },
  827.             addStyle: //GM_addStyle,
  828.                 function(css, head) {
  829.                     if (!head) {
  830.                         let _doc = document.documentElement;
  831.                         head = domAppender(_doc);
  832.                     }
  833.                     let doc = head.ownerDocument;
  834.                     let style = doc.createElement('style');
  835.                     style.type = 'text/css';
  836.                     style.textContent = css;
  837.                     head.appendChild(style);
  838.                     //console.log(document.head,style,'add style')
  839.                     return style;
  840.                 }
  841.         };
  842.  
  843.         const handle = {
  844.  
  845.  
  846.             afPlaybackRecording: async function() {
  847.                 const opts = this;
  848.  
  849.                 let qTime = +new Date;
  850.                 if (qTime >= opts.pTime) {
  851.                     opts.pTime = qTime + opts.timeDelta; //prediction of next Interval
  852.                     opts.savePlaybackProgress()
  853.                 }
  854.  
  855.             },
  856.             savePlaybackProgress: function() {
  857.  
  858.                 //this refer to endless's opts
  859.                 let player = this.player;
  860.  
  861.                 let _uid = this.player_uid; //_h5p_uid_encrypted
  862.                 if (!_uid) return;
  863.  
  864.                 let shallSave = true;
  865.                 let currentTimeToSave = ~~player.currentTime;
  866.  
  867.                 if (this._lastSave == currentTimeToSave) shallSave = false;
  868.  
  869.                 if (shallSave) {
  870.  
  871.                     this._lastSave = currentTimeToSave
  872.  
  873.                     Promise.resolve().then(() => {
  874.  
  875.                         //console.log('aasas',this.player_uid, shallSave, '_play_progress_'+_uid, currentTimeToSave)
  876.  
  877.                         Store.save('_play_progress_' + _uid, jsonStringify({
  878.                             't': currentTimeToSave
  879.                         }))
  880.                     })
  881.  
  882.                 }
  883.                 //console.log('playback logged')
  884.  
  885.             },
  886.             playingWithRecording: function() {
  887.                 let player = this.player;
  888.                 if (!player.paused && !this.isFunctionLooping) {
  889.                     let player = this.player;
  890.                     let _uid = player.getAttribute('_h5p_uid_encrypted') || ''
  891.                     if (_uid) {
  892.                         this.player_uid = _uid;
  893.                         this.pTime = 0;
  894.                         this.loopingStart();
  895.                     }
  896.                 }
  897.             }
  898.  
  899.         };
  900.  
  901.         /*
  902.         class Momentary extends Map {
  903.             act(uniqueId, fn_start, fn_end, delay) {
  904.                 if (!uniqueId) return;
  905.                 uniqueId = uniqueId + "";
  906.                 const last_cid = this.get(uniqueId);
  907.                 if (last_cid > 0) window.clearTimeout(last_cid);
  908.                 fn_start();
  909.                 const new_cid = window.setTimeout(fn_end, delay)
  910.                 this.set(uniqueId, new_cid)
  911.             }
  912.         }
  913.  
  914.         const momentary = new Momentary();*/
  915.  
  916.         const $hs = {
  917.  
  918.             /* 提示文本的字號 */
  919.             fontSize: 16,
  920.             enable: true,
  921.             playerInstance: null,
  922.             /* 快進快退步長 */
  923.             skipStep: 5,
  924.  
  925.             mouseMoveCount: 0,
  926.  
  927.             //video mouse enter and leave
  928.             mouseActioner: {
  929.                 calls: [],
  930.                 time: 0,
  931.                 cid: 0,
  932.                 lastFound: null,
  933.                 lastHoverElm: null
  934.             },
  935.  
  936.             mouseEnteredElement: null,
  937.  
  938.             actionBoxRelations: {},
  939.             tipsClassName: 'html_player_enhance_tips',
  940.  
  941.             //cursor control
  942.             mointoringVideo:false, //false -> xxx -> null -> xxx
  943.  
  944.             //global focused video
  945.             focusHookVId: '',
  946.  
  947.             /* 獲取當前播放器的實例 */
  948.             player: function() {
  949.                 let res = $hs.playerInstance || null;
  950.                 if (res && res.parentNode == null) {
  951.                     $hs.playerInstance = null;
  952.                     res = null;
  953.                 }
  954.  
  955.                 if (res == null) {
  956.                     for (let k in playerConfs) {
  957.                         let playerConf = playerConfs[k];
  958.                         if (playerConf && playerConf.domElement && playerConf.domElement.parentNode) return playerConf.domElement;
  959.                     }
  960.                 }
  961.                 if(res && res.parentNode)return res;
  962.                 return null;
  963.             },
  964.  
  965.             pictureInPicture: function(videoElm) {
  966.                 if (document.pictureInPictureElement) {
  967.                     document.exitPictureInPicture();
  968.                 } else if ('requestPictureInPicture' in videoElm) {
  969.                     videoElm.requestPictureInPicture()
  970.                 } else {
  971.                     $hs.tips('PIP is not supported.');
  972.                 }
  973.             },
  974.  
  975.             getPlayerConf: function(video) {
  976.  
  977.                 if (!video) return null;
  978.                 let vpid = video.getAttribute('_h5ppid') || null;
  979.                 if (!vpid) return null;
  980.                 return playerConfs[vpid] || null;
  981.  
  982.             },
  983.             debug01: function(evt, videoActive) {
  984.  
  985.                 if (!$hs.eventHooks) {
  986.                     document.__h5p_eventhooks = ($hs.eventHooks = {
  987.                         _debug_: []
  988.                     });
  989.                 }
  990.                 $hs.eventHooks._debug_.push([videoActive, evt.type]);
  991.                 // console.log('h5p eventhooks = document.__h5p_eventhooks')
  992.             },
  993.  
  994.             swtichPlayerInstance: function() {
  995.  
  996.                 let newPlayerInstance = null;
  997.                 const ONLY_PLAYING_NONE = 0x4A00;
  998.                 const ONLY_PLAYING_MORE_THAN_ONE = 0x5A00;
  999.                 let onlyPlayingInstance = ONLY_PLAYING_NONE;
  1000.                 for (let k in playerConfs) {
  1001.                     let playerConf = playerConfs[k] || {};
  1002.                     let {
  1003.                         domElement,
  1004.                         domActive
  1005.                     } = playerConf;
  1006.                     if (domElement) {
  1007.                         if (domActive & DOM_ACTIVE_INVALID_PARENT) continue;
  1008.                         if (!domElement.parentNode) {
  1009.                             playerConf.domActive |= DOM_ACTIVE_INVALID_PARENT;
  1010.                             continue;
  1011.                         }
  1012.                         if ((domActive & DOM_ACTIVE_MOUSE_CLICK) || (domActive & DOM_ACTIVE_KEY_DOWN) || (domActive & DOM_ACTIVE_FULLSCREEN)) {
  1013.                             newPlayerInstance = domElement
  1014.                             break;
  1015.                         }
  1016.                         if (domActive & DOM_ACTIVE_ONCE_PLAYED && (domActive & DOM_ACTIVE_DELAYED_PAUSED) == 0) {
  1017.                             if (onlyPlayingInstance == ONLY_PLAYING_NONE) onlyPlayingInstance = domElement;
  1018.                             else onlyPlayingInstance = ONLY_PLAYING_MORE_THAN_ONE;
  1019.                         }
  1020.                     }
  1021.                 }
  1022.                 if (newPlayerInstance == null && onlyPlayingInstance.nodeType == 1) {
  1023.                     newPlayerInstance = onlyPlayingInstance;
  1024.                 }
  1025.  
  1026.                 $hs.playerInstance = newPlayerInstance
  1027.  
  1028.  
  1029.             },
  1030.  
  1031.  
  1032.             handlerVideoPlaying: function(evt) {
  1033.                 const videoElm = evt.target || this || null;
  1034.  
  1035.                 if (!videoElm || videoElm.nodeName != "VIDEO") return;
  1036.  
  1037.                 const vpid = videoElm.getAttribute('_h5ppid')
  1038.  
  1039.                 if (!vpid) return;
  1040.  
  1041.                         $bv.boostVideoPerformanceActivate();
  1042.  
  1043.                 //console.log('video play',videoElm.duration,videoElm.currentTime)
  1044.  
  1045.                 Promise.resolve().then(() => {
  1046.  
  1047.                     if ($hs.cid_playHook > 0) window.clearTimeout($hs.cid_playHook);
  1048.                     $hs.cid_playHook = window.setTimeout(function() {
  1049.                         let onlyPlayed = null;
  1050.                         for (var k in playerConfs) {
  1051.                             if (k == vpid) {
  1052.                                 if (playerConfs[k].domElement.paused === false) onlyPlayed = true;
  1053.                             } else if (playerConfs[k].domElement.paused === false) {
  1054.                                 onlyPlayed = false;
  1055.                                 break;
  1056.                             }
  1057.                         }
  1058.                         if (onlyPlayed === true) {
  1059.                             $hs.focusHookVId = vpid
  1060.                         }
  1061.  
  1062.                         $hs.hcDelayMouseHideAndStartMointoring(videoElm);
  1063.  
  1064.                     }, 100)
  1065.  
  1066.                 }).then(() => {
  1067.  
  1068.                     const playerConf = $hs.getPlayerConf(videoElm)
  1069.  
  1070.                     if (playerConf) {
  1071.                         if (playerConf.timeout_pause > 0) playerConf.timeout_pause = window.clearTimeout(playerConf.timeout_pause);
  1072.                         playerConf.lastPauseAt = 0
  1073.                         playerConf.domActive |= DOM_ACTIVE_ONCE_PLAYED;
  1074.                         playerConf.domActive &= ~DOM_ACTIVE_DELAYED_PAUSED;
  1075.                     }
  1076.  
  1077.                 }).then(() => {
  1078.  
  1079.                     $hs._actionBoxObtain(videoElm);
  1080.  
  1081.                 }).then(() => {
  1082.  
  1083.                     $hs.swtichPlayerInstance();
  1084.  
  1085.  
  1086.  
  1087.                 }).then(() => {
  1088.  
  1089.                     if (!$hs.enable) return $hs.tips(false);
  1090.  
  1091.                     if (videoElm._isThisPausedBefore_) consoleLog('resumed')
  1092.                     let _pausedbefore_ = videoElm._isThisPausedBefore_
  1093.  
  1094.                     if (videoElm.playpause_cid) {
  1095.                         window.clearTimeout(videoElm.playpause_cid);
  1096.                         videoElm.playpause_cid = 0;
  1097.                     }
  1098.                     let _last_paused = videoElm._last_paused
  1099.                     videoElm._last_paused = videoElm.paused
  1100.                     if (_last_paused === !videoElm.paused) {
  1101.                         videoElm.playpause_cid = window.setTimeout(() => {
  1102.                             if (videoElm.paused === !_last_paused && !videoElm.paused && _pausedbefore_) {
  1103.                                 $hs.tips('Playback resumed', undefined, 2500)
  1104.                             }
  1105.                         }, 90)
  1106.                     }
  1107.  
  1108.                     /* 播放的時候進行相關同步操作 */
  1109.  
  1110.                     if (!videoElm._record_continuous) {
  1111.  
  1112.                         /* 同步之前設定的播放速度 */
  1113.                         $hs.setPlaybackRate()
  1114.  
  1115.                         if (!_endlessloop) _endlessloop = new AFLooperArray();
  1116.  
  1117.                         videoElm._record_continuous = _endlessloop.appendLoop(handle.afPlaybackRecording);
  1118.                         videoElm._record_continuous._lastSave = -999;
  1119.  
  1120.                         videoElm._record_continuous.timeDelta = 2000;
  1121.                         videoElm._record_continuous.player = videoElm
  1122.                         videoElm._record_continuous.savePlaybackProgress = handle.savePlaybackProgress;
  1123.                         videoElm._record_continuous.playingWithRecording = handle.playingWithRecording;
  1124.                     }
  1125.  
  1126.                     videoElm._record_continuous.playingWithRecording(videoElm); //try to start recording
  1127.  
  1128.                     videoElm._isThisPausedBefore_ = false;
  1129.  
  1130.                 })
  1131.  
  1132.             },
  1133.  
  1134.  
  1135.             handlerVideoPause: function(evt) {
  1136.  
  1137.                 const videoElm = evt.target || this || null;
  1138.  
  1139.                 if (!videoElm || videoElm.nodeName != "VIDEO") return;
  1140.  
  1141.                 const vpid = videoElm.getAttribute('_h5ppid')
  1142.  
  1143.                 if (!vpid) return;
  1144.                         $bv.boostVideoPerformanceDeactivate();
  1145.  
  1146.                 const isVideoEnded = (decimalEqual(videoElm.duration,videoElm.currentTime));
  1147.  
  1148.  
  1149.  
  1150.                 Promise.resolve().then(() => {
  1151.  
  1152.                     if ($hs.cid_playHook > 0) window.clearTimeout($hs.cid_playHook);
  1153.                     $hs.cid_playHook = window.setTimeout(function() {
  1154.                         let allPaused = true;
  1155.                         for (var k in playerConfs) {
  1156.                             if (playerConfs[k].domElement.paused === false) {
  1157.                                 allPaused = false;
  1158.                                 break;
  1159.                             }
  1160.                         }
  1161.                         if (allPaused) {
  1162.                             $hs.focusHookVId = vpid
  1163.                         }
  1164.                     }, 100)
  1165.  
  1166.                 }).then(() => {
  1167.  
  1168.                     const playerConf = $hs.getPlayerConf(videoElm)
  1169.                     if (playerConf) {
  1170.                         playerConf.lastPauseAt = +new Date;
  1171.                         playerConf.timeout_pause = window.setTimeout(() => {
  1172.                             if (playerConf.lastPauseAt > 0) playerConf.domActive |= DOM_ACTIVE_DELAYED_PAUSED;
  1173.                         }, 600)
  1174.                     }
  1175.  
  1176.                 }).then(() => {
  1177.  
  1178.                     if(!isVideoEnded){
  1179.  
  1180.                         if (!$hs.enable) return $hs.tips(false);
  1181.                         consoleLog('pause')
  1182.                         videoElm._isThisPausedBefore_ = true;
  1183.  
  1184.                         let _last_paused = videoElm._last_paused
  1185.                         videoElm._last_paused = videoElm.paused
  1186.                         if (videoElm.playpause_cid) {
  1187.                             window.clearTimeout(videoElm.playpause_cid);
  1188.                             videoElm.playpause_cid = 0;
  1189.                         }
  1190.                         if (_last_paused === !videoElm.paused) {
  1191.                             videoElm.playpause_cid = window.setTimeout(() => {
  1192.                                 if (videoElm.paused === !_last_paused && videoElm.paused) {
  1193.                                     $hs._tips(videoElm, 'Playback paused', undefined, 2500)
  1194.                                 }
  1195.                             }, 90)
  1196.                         }
  1197.  
  1198.                     }else{
  1199.  
  1200.                         videoElm._isThisPausedBefore_ = true;
  1201.                     }
  1202.  
  1203.  
  1204.                     if (videoElm._record_continuous && videoElm._record_continuous.isFunctionLooping) {
  1205.                         window.setTimeout(function() {
  1206.                             if (videoElm.paused === true && !videoElm._record_continuous.isFunctionLooping) videoElm._record_continuous.savePlaybackProgress(); //savePlaybackProgress once before stopping  //handle.savePlaybackProgress;
  1207.                         }, 380)
  1208.                         videoElm._record_continuous.loopingStop();
  1209.                     }
  1210.  
  1211.  
  1212.                 })
  1213.  
  1214.  
  1215.             },
  1216.             handlerVideoVolumeChange: function(evt) {
  1217.  
  1218.                 let videoElm = evt.target || this || null;
  1219.  
  1220.                 if (videoElm.nodeName != "VIDEO") return;
  1221.                 if (videoElm.volume >= 0) {} else {
  1222.                     return;
  1223.                 }
  1224.  
  1225.                 if ($hs._volume_change_counter > 0) return;
  1226.                 $hs._volume_change_counter = ($hs._volume_change_counter || 0) + 1
  1227.  
  1228.                 window.requestAnimationFrame(function() {
  1229.  
  1230.                     let makeTips = false;
  1231.                     Promise.resolve(videoElm).then((videoElm) => {
  1232.  
  1233.  
  1234.                         let cVol = videoElm.volume;
  1235.                         let cMuted = videoElm.muted;
  1236.  
  1237.                         if (cVol === videoElm._volume_p && cMuted === videoElm._muted_p) {
  1238.                             // nothing changed
  1239.                         } else if (cVol === videoElm._volume_p && cMuted !== videoElm._muted_p) {
  1240.                             // muted changed
  1241.                         } else { // cVol != pVol
  1242.  
  1243.                             // only volume changed
  1244.  
  1245.                             let shallShowTips = videoElm._volume >= 0; //prevent initialization
  1246.  
  1247.                             if (!cVol) {
  1248.                                 videoElm.muted = true;
  1249.                             } else if (cMuted) {
  1250.                                 videoElm.muted = false;
  1251.                                 videoElm._volume = cVol;
  1252.                             } else if (!cMuted) {
  1253.                                 videoElm._volume = cVol;
  1254.                             }
  1255.                             consoleLog('volume changed');
  1256.  
  1257.                             if (shallShowTips) makeTips = true;
  1258.  
  1259.                         }
  1260.  
  1261.                         videoElm._volume_p = cVol;
  1262.                         videoElm._muted_p = cMuted;
  1263.  
  1264.                         return videoElm;
  1265.  
  1266.                     }).then((videoElm) => {
  1267.  
  1268.                         if (makeTips) $hs._tips(videoElm, 'Volume: ' + dround(videoElm.volume * 100) + '%', undefined, 3000);
  1269.  
  1270.                         $hs._volume_change_counter = 0;
  1271.  
  1272.                     })
  1273.                     videoElm = null
  1274.  
  1275.                 })
  1276.  
  1277.  
  1278.  
  1279.             },
  1280.             handlerVideoLoadedMetaData: function(evt) {
  1281.                 const videoElm = evt.target || this || null;
  1282.  
  1283.                 if (!videoElm || videoElm.nodeName != "VIDEO") return;
  1284.  
  1285.                 Promise.resolve(videoElm).then((videoElm) => {
  1286.  
  1287.                     consoleLog('video size', videoElm.videoWidth + ' x ' + videoElm.videoHeight);
  1288.  
  1289.                     let vpid = videoElm.getAttribute('_h5ppid') || null;
  1290.                     if (!vpid || !videoElm.currentSrc) return;
  1291.  
  1292.                     let videoElm_withSrcChanged = null
  1293.  
  1294.                     if ($hs.varSrcList[vpid] != videoElm.currentSrc) {
  1295.                         $hs.varSrcList[vpid] = videoElm.currentSrc;
  1296.                         $hs.videoSrcFound(videoElm);
  1297.                         videoElm_withSrcChanged = videoElm;
  1298.                     }
  1299.                     if (!videoElm._onceVideoLoaded) {
  1300.                         videoElm._onceVideoLoaded = true;
  1301.                         playerConfs[vpid].domActive |= DOM_ACTIVE_SRC_LOADED;
  1302.                     }
  1303.  
  1304.                     return videoElm_withSrcChanged
  1305.                 }).then((videoElm_withSrcChanged) => {
  1306.  
  1307.                     if (videoElm_withSrcChanged) $hs._actionBoxObtain(videoElm_withSrcChanged);
  1308.  
  1309.  
  1310.  
  1311.                 })
  1312.  
  1313.             },
  1314.             handlerSizing:(entries)=>{
  1315.  
  1316.                 for(const {target} of entries){
  1317.  
  1318.                     let cw=target.clientWidth
  1319.                     let ch=target.clientHeight
  1320.                     target.__clientWidth = cw
  1321.                     target.__clientHeight = ch
  1322.                     target.mouseMoveMax = Math.sqrt(cw * cw + ch * ch) * 0.06;
  1323.  
  1324.  
  1325.                 }
  1326.  
  1327.             },
  1328.  
  1329.             mouseAct: function() {
  1330.  
  1331.                 $hs.mouseActioner.cid = 0;
  1332.  
  1333.                 if (+new Date - $hs.mouseActioner.time < 30) {
  1334.                     $hs.mouseActioner.cid = window.setTimeout($hs.mouseAct, 82)
  1335.                     return;
  1336.                 }
  1337.  
  1338.                 if ($hs.mouseDownAt && $hs.mouseActioner.lastFound && $hs.mouseDownAt.insideVideo === $hs.mouseActioner.lastFound) {
  1339.  
  1340.                     return;
  1341.  
  1342.                 }
  1343.  
  1344.                 const getVideo = (target) => {
  1345.  
  1346.  
  1347.                     const actionBoxRelation = $hs.getActionBoxRelationFromDOM(target);
  1348.                     if (!actionBoxRelation) return;
  1349.                     const actionBox = actionBoxRelation.actionBox
  1350.                     if (!actionBox) return;
  1351.                     const vpid = actionBox.getAttribute('_h5p_actionbox_');
  1352.                     const videoElm = actionBoxRelation.player;
  1353.                     if (!videoElm) return;
  1354.  
  1355.                     return videoElm
  1356.                 }
  1357.  
  1358.                 Promise.resolve().then(() => {
  1359.                     for (const {
  1360.                             type,
  1361.                             target
  1362.                         } of $hs.mouseActioner.calls) {
  1363.                         if (type == 'mouseenter') {
  1364.                             const videoElm = getVideo(target);
  1365.                             if (videoElm) {
  1366.                                 return videoElm
  1367.                             }
  1368.                         }
  1369.                     }
  1370.                     return null;
  1371.                 }).then(videoFound => {
  1372.  
  1373.                     Promise.resolve().then(() => {
  1374.  
  1375.                         var plastHoverElm = $hs.mouseActioner.lastHoverElm;
  1376.                         $hs.mouseActioner.lastHoverElm = $hs.mouseEnteredElement;
  1377.  
  1378.                         //console.log(!!$hs.mointoringVideo , !!videoFound)
  1379.                         //console.log(554,'mointoringVideo:'+!!$hs.mointoringVideo,'videoFound:'+ !!videoFound)
  1380.  
  1381.                         if ($hs.mointoringVideo && !videoFound) {
  1382.                             $hs.hcShowMouseAndRemoveMointoring($vQuery.player($hs.mointoringVideo))
  1383.                         } else if ($hs.mointoringVideo && videoFound) {
  1384.                             if (plastHoverElm != $hs.mouseActioner.lastHoverElm) $hs.hcMouseShowWithMonitoring(videoFound);
  1385.                         } else if (!$hs.mointoringVideo && videoFound) {
  1386.                             $hs.hcDelayMouseHideAndStartMointoring(videoFound)
  1387.                         }
  1388.  
  1389.                         $hs.mouseMoveCount = 0;
  1390.                         $hs.mouseActioner.calls.length = 0;
  1391.                         $hs.mouseActioner.lastFound = videoFound;
  1392.  
  1393.                     })
  1394.  
  1395.  
  1396.  
  1397.                     if (videoFound !== $hs.mouseActioner.lastFound) {
  1398.                         if ($hs.mouseActioner.lastFound) {
  1399.                             $hs.handlerElementMouseLeaveVideo($hs.mouseActioner.lastFound)
  1400.                         }
  1401.                         if (videoFound) {
  1402.                             $hs.handlerElementMouseEnterVideo(videoFound)
  1403.                         }
  1404.                     }
  1405.  
  1406.  
  1407.                 })
  1408.  
  1409.             },
  1410.             handlerElementMouseEnterVideo: function(video) {
  1411.  
  1412.                 //console.log('mouseenter video')
  1413.  
  1414.                 const playerConf = $hs.getPlayerConf(video)
  1415.                 if (playerConf) {
  1416.                     playerConf.domActive |= DOM_ACTIVE_MOUSE_IN;
  1417.                 }
  1418.  
  1419.                 $hs._actionBoxObtain(video);
  1420.  
  1421.                 $hs.enteredActionBoxRelation = $hs.actionBoxRelations[video.getAttribute('_h5ppid') || 'null'] || null
  1422.  
  1423.             },
  1424.             handlerElementMouseLeaveVideo: function(video) {
  1425.  
  1426.                 //console.log('mouseleave video')
  1427.  
  1428.                 const playerConf = $hs.getPlayerConf(video)
  1429.                 if (playerConf) {
  1430.                     playerConf.domActive &= ~DOM_ACTIVE_MOUSE_IN;
  1431.                 }
  1432.  
  1433.  
  1434.                 $hs.enteredActionBoxRelation = null
  1435.  
  1436.  
  1437.             },
  1438.             handlerElementMouseEnter: function(evt) {
  1439.                 if ($hs.intVideoInitCount > 0) {} else {
  1440.                     return;
  1441.                 }
  1442.                 if (!evt || !evt.target || !(evt.target.nodeType > 0)) return;
  1443.  
  1444.                 $hs.mouseEnteredElement = evt.target
  1445.  
  1446.                 if ($hs.mouseDownAt && $hs.mouseDownAt.insideVideo) return;
  1447.  
  1448.                 if ($hs.enteredActionBoxRelation && $hs.enteredActionBoxRelation.pContainer && $hs.enteredActionBoxRelation.pContainer.contains(evt.target)) return;
  1449.  
  1450.                 //console.log('mouseenter call')
  1451.  
  1452.                 $hs.mouseActioner.calls.length = 1;
  1453.                 $hs.mouseActioner.calls[0] = {
  1454.                     type: evt.type,
  1455.                     target: evt.target
  1456.                 }
  1457.  
  1458.  
  1459.                 //$hs.mouseActioner.calls.push({type:evt.type,target:evt.target});
  1460.                 $hs.mouseActioner.time = +new Date;
  1461.  
  1462.                 if (!$hs.mouseActioner.cid) {
  1463.                     $hs.mouseActioner.cid = window.setTimeout($hs.mouseAct, 82)
  1464.                 }
  1465.  
  1466.                 //console.log(evt.target)
  1467.  
  1468.             },
  1469.             handlerElementMouseLeave: function(evt) {
  1470.                 if ($hs.intVideoInitCount > 0) {} else {
  1471.                     return;
  1472.                 }
  1473.                 if (!evt || !evt.target || !(evt.target.nodeType > 0)) return;
  1474.  
  1475.                 if ($hs.mouseDownAt && $hs.mouseDownAt.insideVideo) return;
  1476.  
  1477.                 if ($hs.enteredActionBoxRelation && $hs.enteredActionBoxRelation.pContainer && !$hs.enteredActionBoxRelation.pContainer.contains(evt.target)) {
  1478.  
  1479.                     //console.log('mouseleave call')
  1480.  
  1481.                     //$hs.mouseActioner.calls.push({type:evt.type,target:evt.target});
  1482.                     $hs.mouseActioner.time = +new Date;
  1483.  
  1484.                     if (!$hs.mouseActioner.cid) {
  1485.                         $hs.mouseActioner.cid = window.setTimeout($hs.mouseAct, 82)
  1486.                     }
  1487.                 }
  1488.  
  1489.             },
  1490.             handlerElementMouseDown: function(evt) {
  1491.                 if ($hs.mouseDownAt) return;
  1492.                 $hs.mouseDownAt = {
  1493.                     elm: evt.target,
  1494.                     insideVideo: false,
  1495.                     pContainer: null
  1496.                 };
  1497.  
  1498.  
  1499.                 if ($hs.intVideoInitCount > 0) {} else {
  1500.                     return;
  1501.                 }
  1502.  
  1503.                 //  $hs._mouseIsDown=true;
  1504.  
  1505.                 if (!evt || !evt.target || !(evt.target.nodeType > 0)) return;
  1506.  
  1507.                 if ($hs.mouseActioner.lastFound && $hs.mointoringVideo) $hs.hcMouseShowWithMonitoring($hs.mouseActioner.lastFound)
  1508.  
  1509.                 Promise.resolve(evt.target).then((evtTarget) => {
  1510.  
  1511.  
  1512.                     if (document.readyState != "complete") return;
  1513.  
  1514.  
  1515.                     function notAtVideo() {
  1516.                         if ($hs.focusHookVId) $hs.focusHookVId = ''
  1517.                     }
  1518.  
  1519.  
  1520.                     const actionBoxRelation = $hs.getActionBoxRelationFromDOM(evtTarget);
  1521.                     if (!actionBoxRelation) return notAtVideo();
  1522.                     const actionBox = actionBoxRelation.actionBox
  1523.                     if (!actionBox) return notAtVideo();
  1524.                     const vpid = actionBox.getAttribute('_h5p_actionbox_');
  1525.                     if (!vpid) return notAtVideo();
  1526.                     const videoElm = actionBoxRelation.player;
  1527.                     if (!videoElm) return notAtVideo();
  1528.  
  1529.                     if (!$hs.mouseDownAt) return;
  1530.                     $hs.mouseDownAt.insideVideo = videoElm;
  1531.  
  1532.                     $hs.mouseDownAt.pContainer = actionBoxRelation.pContainer;
  1533.  
  1534.                     $hs.focusHookVId = vpid
  1535.  
  1536.  
  1537.  
  1538.                     const playerConf = $hs.getPlayerConf(videoElm)
  1539.                     if (playerConf) {
  1540.                         delayCall("$$actionBoxClicking", function() {
  1541.                             playerConf.domActive &= ~DOM_ACTIVE_MOUSE_CLICK;
  1542.                         }, 137)
  1543.                         playerConf.domActive |= DOM_ACTIVE_MOUSE_CLICK;
  1544.                     }
  1545.  
  1546.  
  1547.                     return videoElm
  1548.  
  1549.                 }).then((videoElm) => {
  1550.  
  1551.                     if (!videoElm) return;
  1552.  
  1553.                     $hs._actionBoxObtain(videoElm);
  1554.  
  1555.                     return videoElm
  1556.  
  1557.                 }).then((videoElm) => {
  1558.  
  1559.                     if (!videoElm) return;
  1560.  
  1561.                     $hs.swtichPlayerInstance();
  1562.  
  1563.                 })
  1564.  
  1565.             },
  1566.             handlerElementMouseUp: function(evt) {
  1567.  
  1568.                 if ($hs.pendingTips) {
  1569.  
  1570.                     let pendingTips = $hs.pendingTips;
  1571.                     $hs.pendingTips = null;
  1572.  
  1573.                     for (let vpid in pendingTips) {
  1574.                         const tipsDom = pendingTips[vpid]
  1575.                         Promise.resolve(tipsDom).then((tipsDom) => {
  1576.                             if(tipsDom.getAttribute('_h5p_animate')=='P') tipsDom.setAttribute('_h5p_animate','');
  1577.                         })
  1578.                     }
  1579.                     pendingTips = null;
  1580.  
  1581.                 }
  1582.                 if ($hs.mouseDownAt) {
  1583.  
  1584.                     $hs.mouseDownAt = null;
  1585.                 }
  1586.             },
  1587.             handlerElementWheelTuneVolume: function(evt) { //shift + wheel
  1588.  
  1589.                 if ($hs.intVideoInitCount > 0) {} else {
  1590.                     return;
  1591.                 }
  1592.  
  1593.                 if (!evt.shiftKey || !evt.target || !(evt.target.nodeType > 0)) return;
  1594.  
  1595.                 const fDeltaY = (evt.deltaY > 0) ? 1 : (evt.deltaY < 0) ? -1 : 0;
  1596.                 if (fDeltaY) {
  1597.  
  1598.  
  1599.  
  1600.                     const randomID = +new Date
  1601.                     $hs.handlerElementWheelTuneVolume._randomID = randomID;
  1602.  
  1603.  
  1604.                     Promise.resolve(evt.target).then((evtTarget) => {
  1605.  
  1606.  
  1607.                         const actionBoxRelation = $hs.getActionBoxRelationFromDOM(evtTarget);
  1608.                         if (!actionBoxRelation) return;
  1609.                         const actionBox = actionBoxRelation.actionBox
  1610.                         if (!actionBox) return;
  1611.                         const vpid = actionBox.getAttribute('_h5p_actionbox_');
  1612.                         const videoElm = actionBoxRelation.player;
  1613.                         if (!videoElm) return;
  1614.  
  1615.                         let player = $hs.player();
  1616.                         if (!player || !player.parentNode || player != videoElm) return;
  1617.  
  1618.                         return videoElm
  1619.  
  1620.                     }).then((videoElm) => {
  1621.                         if (!videoElm) return;
  1622.  
  1623.                         if ($hs.handlerElementWheelTuneVolume._randomID != randomID) return;
  1624.                         // $hs._actionBoxObtain(videoElm);
  1625.                         return videoElm;
  1626.                     }).then((player) => {
  1627.                         if (!player || !player.parentNode) return;
  1628.                         if ($hs.handlerElementWheelTuneVolume._randomID != randomID) return;
  1629.                         if (fDeltaY > 0) {
  1630.                             if ((player.muted && player.volume === 0) && player._volume > 0) {
  1631.                                 player.muted = false;
  1632.                                 player.volume = player._volume;
  1633.                             } else if (player.muted && (player.volume > 0 || !player._volume)) {
  1634.                                 player.muted = false;
  1635.                             }
  1636.                             $hs.tuneVolume(-0.05)
  1637.                         } else if (fDeltaY < 0) {
  1638.                             if ((player.muted && player.volume === 0) && player._volume > 0) {
  1639.                                 player.muted = false;
  1640.                                 player.volume = player._volume;
  1641.                             } else if (player.muted && (player.volume > 0 || !player._volume)) {
  1642.                                 player.muted = false;
  1643.                             }
  1644.                             $hs.tuneVolume(+0.05)
  1645.                         }
  1646.                     })
  1647.                     evt.stopPropagation()
  1648.                     evt.preventDefault()
  1649.                     return false
  1650.                 }
  1651.             },
  1652.  
  1653.             handlerWinMessage: async function(e) {
  1654.                 let tag, ed;
  1655.                 if (typeof e.data == 'object' && typeof e.data.tag == 'string') {
  1656.                     tag = e.data.tag;
  1657.                     ed = e.data
  1658.                 } else {
  1659.                     return;
  1660.                 }
  1661.                 let msg = null,
  1662.                     success = 0;
  1663.                 let msg_str, msg_stype, p
  1664.                 switch (tag) {
  1665.                     case 'consoleLog':
  1666.                         msg_str = ed.str;
  1667.                         msg_stype = ed.stype;
  1668.                         if (msg_stype === 1) {
  1669.                             msg = (document[str_postMsgData] || {})[msg_str] || [];
  1670.                             success = 1;
  1671.                         } else if (msg_stype === 2) {
  1672.                             msg = jsonParse(msg_str);
  1673.                             if (msg && msg.d) {
  1674.                                 success = 2;
  1675.                                 msg = msg.d;
  1676.                             }
  1677.                         } else {
  1678.                             msg = msg_str
  1679.                         }
  1680.                         p = (ed.passing && ed.winOrder) ? [' | from win-' + ed.winOrder] : [];
  1681.                         if (success) {
  1682.                             console.log(...msg, ...p)
  1683.                             //document[ed.data]=null;   // also delete the information
  1684.                         } else {
  1685.                             console.log('msg--', msg, ...p, ed);
  1686.                         }
  1687.                         break;
  1688.  
  1689.                 }
  1690.             },
  1691.  
  1692.             toolCheckFullScreen: function(doc) {
  1693.                 if (typeof doc.fullScreen == 'boolean') return doc.fullScreen;
  1694.                 if (typeof doc.webkitIsFullScreen == 'boolean') return doc.webkitIsFullScreen;
  1695.                 if (typeof doc.mozFullScreen == 'boolean') return doc.mozFullScreen;
  1696.                 return null;
  1697.             },
  1698.  
  1699.             toolFormatCT: function(u) {
  1700.  
  1701.                 let w = Math.round(u, 0)
  1702.                 let a = w % 60
  1703.                 w = (w - a) / 60
  1704.                 let b = w % 60
  1705.                 w = (w - b) / 60
  1706.                 let str = ("0" + b).substr(-2) + ":" + ("0" + a).substr(-2);
  1707.                 if (w) str = w + ":" + str
  1708.  
  1709.                 return str
  1710.  
  1711.             },
  1712.  
  1713.             loopOutwards: function(startPoint, maxStep) {
  1714.  
  1715.  
  1716.                 let c = 0,
  1717.                     p = startPoint,
  1718.                     q = null;
  1719.                 while (p && (++c <= maxStep)) {
  1720.                     if (p.querySelectorAll('video').length !== 1) {
  1721.                         return q;
  1722.                         break;
  1723.                     }
  1724.                     q = p;
  1725.                     p = p.parentNode;
  1726.                 }
  1727.  
  1728.                 return p || q || null;
  1729.  
  1730.             },
  1731.  
  1732.             getActionBlockElement: function(player, layoutBox) {
  1733.  
  1734.                 //player,  $hs.getPlayerBlockElement(player).parentNode;
  1735.                 //player, player.parentNode .... player.parentNode.parentNode.parentNode
  1736.  
  1737.                 //layoutBox: a container element containing video and with innerHeight>=player.innerHeight [skipped wrapping]
  1738.                 //layoutBox parentSize > layoutBox Size
  1739.  
  1740.                 //actionBox: a container with video and controls
  1741.                 //can be outside layoutbox (bilibili)
  1742.                 //assume maximum 3 layers
  1743.  
  1744.  
  1745.                 let outerLayout = $hs.loopOutwards(layoutBox, 3); //i.e.   layoutBox.parent.parent.parent
  1746.  
  1747.  
  1748.                 const allFullScreenBtns = $hs.queryFullscreenBtnsIndependant(outerLayout)
  1749.                 //console.log('xx', outerLayout.querySelectorAll('[class*="-fullscreen"]').length, allFullScreenBtns.length)
  1750.                 let actionBox = null;
  1751.  
  1752.                 // console.log('fa0a', allFullScreenBtns.length, layoutBox)
  1753.                 if (allFullScreenBtns.length > 0) {
  1754.                     //  console.log('faa', allFullScreenBtns.length)
  1755.  
  1756.                     for (const possibleFullScreenBtn of allFullScreenBtns) possibleFullScreenBtn.setAttribute('__h5p_fsb__', '');
  1757.                     let pElm = player.parentNode;
  1758.                     let fullscreenBtns = null;
  1759.                     while (pElm && pElm.parentNode) {
  1760.                         fullscreenBtns = pElm.querySelectorAll('[__h5p_fsb__]');
  1761.                         if (fullscreenBtns.length > 0) {
  1762.                             break;
  1763.                         }
  1764.                         pElm = pElm.parentNode;
  1765.                     }
  1766.                     for (const possibleFullScreenBtn of allFullScreenBtns) possibleFullScreenBtn.removeAttribute('__h5p_fsb__');
  1767.                     if (fullscreenBtns && fullscreenBtns.length > 0) {
  1768.                         actionBox = pElm;
  1769.                         fullscreenBtns = $hs.exclusiveElements(fullscreenBtns);
  1770.                         return {
  1771.                             actionBox,
  1772.                             fullscreenBtns
  1773.                         };
  1774.                     }
  1775.                 }
  1776.  
  1777.                 let walkRes = domTool._isActionBox_1(player, layoutBox);
  1778.                 //walkRes.elm = player... player.parentNode.parentNode (i.e. wPlayer)
  1779.                 let parentCount = walkRes.length;
  1780.  
  1781.                 if (parentCount - 1 >= 0 && domTool._isActionBox(player, walkRes, parentCount - 1)) {
  1782.                     actionBox = walkRes[parentCount - 1].elm;
  1783.                 } else if (parentCount - 2 >= 0 && domTool._isActionBox(player, walkRes, parentCount - 2)) {
  1784.                     actionBox = walkRes[parentCount - 2].elm;
  1785.                 } else {
  1786.                     actionBox = player;
  1787.                 }
  1788.  
  1789.                 return {
  1790.                     actionBox,
  1791.                     fullscreenBtns: []
  1792.                 };
  1793.  
  1794.  
  1795.  
  1796.  
  1797.             },
  1798.  
  1799.  
  1800.             actionBoxMutationCallback: function(mutations, observer) {
  1801.                 for (const mutation of mutations) {
  1802.  
  1803.  
  1804.                     const vpid = mutation.target.getAttribute('_h5p_mf_');
  1805.                     if (!vpid) continue;
  1806.  
  1807.                     const actionBoxRelation = $hs.actionBoxRelations[vpid];
  1808.                     if (!actionBoxRelation) continue;
  1809.  
  1810.  
  1811.                     const removedNodes = mutation.removedNodes;
  1812.                     if (removedNodes && removedNodes.length > 0) {
  1813.                         for (const node of removedNodes) {
  1814.                             if (node.nodeType == 1) {
  1815.                                 actionBoxRelation.mutationRemovalsCount++
  1816.                                 node.removeAttribute('_h5p_mf_');
  1817.                             }
  1818.                         }
  1819.  
  1820.                     }
  1821.  
  1822.                     const addedNodes = mutation.addedNodes;
  1823.                     if (addedNodes && addedNodes.length > 0) {
  1824.                         for (const node of addedNodes) {
  1825.                             if (node.nodeType == 1) {
  1826.                                 actionBoxRelation.mutationAdditionsCount++
  1827.                             }
  1828.                         }
  1829.  
  1830.                     }
  1831.  
  1832.  
  1833.  
  1834.  
  1835.                 }
  1836.             },
  1837.  
  1838.  
  1839.             getActionBoxRelationFromDOM: function(elm) {
  1840.  
  1841.                 //assume action boxes are mutually exclusive
  1842.  
  1843.                 for (let vpid in $hs.actionBoxRelations) {
  1844.                     const actionBoxRelation = $hs.actionBoxRelations[vpid];
  1845.                     const actionBox = actionBoxRelation.actionBox
  1846.                     //console.log('ab', actionBox)
  1847.                     if (actionBox && actionBox.parentNode) {
  1848.                         if (elm == actionBox || actionBox.contains(elm)) {
  1849.                             return actionBoxRelation;
  1850.                         }
  1851.                     }
  1852.                 }
  1853.  
  1854.  
  1855.                 return null;
  1856.  
  1857.             },
  1858.  
  1859.  
  1860.  
  1861.             _actionBoxObtain: function(player) {
  1862.  
  1863.                 if (!player || !player.parentNode) return null;
  1864.                 let vpid = player.getAttribute('_h5ppid');
  1865.                 if (!vpid) return null;
  1866.  
  1867.                 let actionBoxRelation = $hs.actionBoxRelations[vpid],
  1868.                     layoutBox = null,
  1869.                     actionBox = null,
  1870.                     boxSearchResult = null,
  1871.                     fullscreenBtns = null,
  1872.                     wPlayer = null;
  1873.  
  1874.                 function a() {
  1875.                     let wPlayerr= $hs.getPlayerBlockElement(player);
  1876.                     wPlayer = wPlayerr.wPlayer;
  1877.                     layoutBox = wPlayer.parentNode;
  1878.                     boxSearchResult = $hs.getActionBlockElement(player, layoutBox);
  1879.                     actionBox = boxSearchResult.actionBox
  1880.                     fullscreenBtns = boxSearchResult.fullscreenBtns
  1881.                 }
  1882.  
  1883.                 function setDOM_mflag(startElm, endElm, vpid) {
  1884.                     if (!startElm || !endElm) return;
  1885.                     if (startElm == endElm) startElm.setAttribute('_h5p_mf_', vpid)
  1886.                     else if (endElm.contains(startElm)) {
  1887.  
  1888.                         let p = startElm
  1889.                         while (p) {
  1890.                             p.setAttribute('_h5p_mf_', vpid)
  1891.                             if (p == endElm) break;
  1892.                             p = p.parentNode
  1893.                         }
  1894.  
  1895.                     }
  1896.                 }
  1897.  
  1898.                 function b(domNodes) {
  1899.  
  1900.                     actionBox.setAttribute('_h5p_actionbox_', vpid);
  1901.                     if (!$hs.actionBoxMutationObserver) $hs.actionBoxMutationObserver = new MutationObserver($hs.actionBoxMutationCallback);
  1902.  
  1903.                     // console.log('Major Mutation on Player Container')
  1904.                     const actionRelation = {
  1905.                         player: player,
  1906.                         wPlayer: wPlayer,
  1907.                         layoutBox: layoutBox,
  1908.                         actionBox: actionBox,
  1909.                         mutationRemovalsCount: 0,
  1910.                         mutationAdditionsCount: 0,
  1911.                         fullscreenBtns: fullscreenBtns,
  1912.                         pContainer: domNodes[domNodes.length - 1], // the block Element as the entire player (including control btns) having size>=video
  1913.                         ppContainer: domNodes[domNodes.length - 1].parentNode, // reference to the webpage
  1914.                     }
  1915.                     domNodes=null;
  1916.  
  1917.  
  1918.                     const pContainer = actionRelation.pContainer;
  1919.                     setDOM_mflag(player, pContainer, vpid)
  1920.                     for (const btn of fullscreenBtns) setDOM_mflag(btn, pContainer, vpid)
  1921.                     setDOM_mflag = null;
  1922.  
  1923.                     $hs.actionBoxRelations[vpid] = actionRelation
  1924.  
  1925.  
  1926.                     //console.log('mutt0',pContainer)
  1927.                     $hs.actionBoxMutationObserver.observe(pContainer, {
  1928.                         childList: true,
  1929.                         subtree: true
  1930.                     });
  1931.                 }
  1932.  
  1933.                 if (actionBoxRelation) {
  1934.                     //console.log('ddx', actionBoxRelation.mutationCount)
  1935.                     if (actionBoxRelation.pContainer && actionBoxRelation.pContainer.parentNode && actionBoxRelation.pContainer.parentNode === actionBoxRelation.ppContainer) {
  1936.  
  1937.                         if (actionBoxRelation.fullscreenBtns && actionBoxRelation.fullscreenBtns.length > 0) {
  1938.  
  1939.                             if (actionBoxRelation.mutationRemovalsCount === 0 && actionBoxRelation.mutationAdditionsCount === 0) return actionBoxRelation.actionBox
  1940.  
  1941.                             //  if (actionBoxRelation.mutationCount === 0 && actionBoxRelation.fullscreenBtns.every(btn=>actionBoxRelation.actionBox.contains(btn))) return actionBoxRelation.actionBox
  1942.                             //console.log('Minor Mutation on Player Container', actionBoxRelation ? actionBoxRelation.mutationRemovalsCount : null, actionBoxRelation ? actionBoxRelation.mutationAdditionsCount : null)
  1943.                             a();
  1944.                             //console.log(3535,fullscreenBtns.length)
  1945.                             if (actionBox == actionBoxRelation.actionBox && layoutBox == actionBoxRelation.layoutBox && wPlayer == actionBoxRelation.wPlayer) {
  1946.                                 //pContainer remains the same as actionBox and layoutBox remain unchanged
  1947.                                 actionBoxRelation.ppContainer = actionBoxRelation.pContainer.parentNode; //just update the reference
  1948.                                 if (actionBoxRelation.ppContainer) { //in case removed from DOM
  1949.                                     actionBoxRelation.mutationRemovalsCount = 0;
  1950.                                     actionBoxRelation.mutationAdditionsCount = 0;
  1951.                                     actionBoxRelation.fullscreenBtns = fullscreenBtns;
  1952.                                     return actionBox;
  1953.                                 }
  1954.                             }
  1955.  
  1956.                         }
  1957.  
  1958.                     }
  1959.  
  1960.                     for(const rootDoc of rootDocs) {
  1961.                         const elms = rootDoc.querySelectorAll(`[_h5p_mf_="${vpid}"]`)
  1962.                         for (const elm of elms) elm.removeAttribute('_h5p_mf_')
  1963.                         actionBoxRelation.pContainer.removeAttribute('_h5p_mf_')
  1964.                     }
  1965.  
  1966.                     for (var k in actionBoxRelation) delete actionBoxRelation[k]
  1967.                     actionBoxRelation = null;
  1968.                     delete $hs.actionBoxRelations[vpid]
  1969.                 }
  1970.  
  1971.                 if (boxSearchResult == null) a();
  1972.                 a = null;
  1973.                 if (actionBox) {
  1974.                     let domNodes = [];
  1975.                     let pElm = player;
  1976.                     let containing = 0;
  1977.                     while (pElm) {
  1978.                         domNodes.push(pElm);
  1979.                         if (pElm === actionBox) containing |= 1;
  1980.                         if (pElm === layoutBox) containing |= 2;
  1981.                         if (containing === 3) {
  1982.                             b(domNodes);
  1983.                             domNodes=null;
  1984.                             pElm=null;
  1985.                             b = null;
  1986.                             return actionBox
  1987.                         }
  1988.                         pElm = pElm.parentNode;
  1989.                     }
  1990.                 }
  1991.  
  1992.                 return null;
  1993.  
  1994.  
  1995.                 // if (!actionBox.hasAttribute('tabindex')) actionBox.setAttribute('tabindex', '-1');
  1996.  
  1997.  
  1998.  
  1999.  
  2000.             },
  2001.  
  2002.             videoSrcFound: function(player) {
  2003.  
  2004.                 // src loaded
  2005.  
  2006.                 if (!player || !player.parentNode) return;
  2007.                 let vpid = player.getAttribute('_h5ppid') || null;
  2008.                 if (!vpid || !player.currentSrc) return;
  2009.  
  2010.                 player._isThisPausedBefore_ = false;
  2011.  
  2012.                 player.removeAttribute('_h5p_uid_encrypted');
  2013.  
  2014.                 if (player._record_continuous) player._record_continuous._lastSave = -999; //first time must save
  2015.  
  2016.                 let uid_A = location.pathname.replace(/[^\d+]/g, '') + '.' + location.search.replace(/[^\d+]/g, '');
  2017.                 let _uid = location.hostname.replace('www.', '').toLowerCase() + '!' + location.pathname.toLowerCase() + 'A' + uid_A + 'W' + player.videoWidth + 'H' + player.videoHeight + 'L' + (player.duration << 0);
  2018.  
  2019.                 digestMessage(_uid).then(function(_uid_encrypted) {
  2020.  
  2021.                     let d = +new Date;
  2022.  
  2023.                     let recordedTime = null;
  2024.  
  2025.                     ;
  2026.                     (function() {
  2027.                         //read the last record only;
  2028.  
  2029.                         let k3 = `_h5_player_play_progress_${_uid_encrypted}`;
  2030.                         let k3n = `_play_progress_${_uid_encrypted}`;
  2031.                         let m2 = Store._keys().filter(key => key.substr(0, k3.length) == k3); //all progress records for this video
  2032.                         let m2v = m2.map(keyName => +(keyName.split('+')[1] || '0'))
  2033.                         let m2vMax = Math.max(0, ...m2v)
  2034.                         if (!m2vMax) recordedTime = null;
  2035.                         else {
  2036.                             let _json_recordedTime = null;
  2037.                             _json_recordedTime = Store.read(k3n + '+' + m2vMax);
  2038.                             if (!_json_recordedTime) _json_recordedTime = {};
  2039.                             else _json_recordedTime = jsonParse(_json_recordedTime);
  2040.                             if (typeof _json_recordedTime == 'object') recordedTime = _json_recordedTime;
  2041.                             else recordedTime = null;
  2042.                             recordedTime = typeof recordedTime == 'object' ? recordedTime.t : recordedTime;
  2043.                             if (typeof recordedTime == 'number' && (+recordedTime >= 0 || +recordedTime <= 0)) {
  2044.  
  2045.                             } else if (typeof recordedTime == 'string' && recordedTime.length > 0 && (+recordedTime >= 0 || +recordedTime <= 0)) {
  2046.                                 recordedTime = +recordedTime
  2047.                             } else {
  2048.                                 recordedTime = null
  2049.                             }
  2050.                         }
  2051.                         if (recordedTime !== null) {
  2052.                             player._h5player_lastrecord_ = recordedTime;
  2053.                         } else {
  2054.                             player._h5player_lastrecord_ = null;
  2055.                         }
  2056.                         if (player._h5player_lastrecord_ > 5) {
  2057.                             consoleLog('last record playing', player._h5player_lastrecord_);
  2058.                             window.setTimeout(function() {
  2059.                                 $hs._tips(player, `Press Shift-R to restore Last Playback: ${$hs.toolFormatCT(player._h5player_lastrecord_)}`, 5000, 4000)
  2060.                             }, 1000)
  2061.                         }
  2062.  
  2063.                     })();
  2064.                     // delay the recording by 5.4s => prevent ads or mis operation
  2065.                     window.setTimeout(function() {
  2066.  
  2067.  
  2068.  
  2069.                         let k1 = '_h5_player_play_progress_';
  2070.                         let k3 = `_h5_player_play_progress_${_uid_encrypted}`;
  2071.                         let k3n = `_play_progress_${_uid_encrypted}`;
  2072.  
  2073.                         //re-read all the localStorage keys
  2074.                         let m1 = Store._keys().filter(key => key.substr(0, k1.length) == k1); //all progress records in this site
  2075.                         let p = m1.length + 1;
  2076.  
  2077.                         for (const key of m1) { //all progress records for this video
  2078.                             if (key.substr(0, k3.length) == k3) {
  2079.                                 Store._removeItem(key); //remove previous record for the current video
  2080.                                 p--;
  2081.                             }
  2082.                         }
  2083.  
  2084.                         let asyncPromise = Promise.resolve();
  2085.  
  2086.                         if (recordedTime !== null) {
  2087.                             asyncPromise = asyncPromise.then(() => {
  2088.                                 Store.save(k3n + '+' + d, jsonStringify({
  2089.                                     't': recordedTime
  2090.                                 })) //prevent loss of last record
  2091.                             })
  2092.                         }
  2093.  
  2094.                         const _record_max_ = 48;
  2095.                         const _record_keep_ = 26;
  2096.  
  2097.                         if (p > _record_max_) {
  2098.                             //exisiting 48 records for one site;
  2099.                             //keep only 26 records
  2100.  
  2101.                             asyncPromise = asyncPromise.then(() => {
  2102.                                 const comparator = (a, b) => (a.t < b.t ? -1 : a.t > b.t ? 1 : 0);
  2103.  
  2104.                                 m1
  2105.                                     .map(keyName => ({
  2106.                                         keyName,
  2107.                                         t: +(keyName.split('+')[1] || '0')
  2108.                                     }))
  2109.                                     .sort(comparator)
  2110.                                     .slice(0, -_record_keep_)
  2111.                                     .forEach((item) => localStorage.removeItem(item.keyName));
  2112.  
  2113.                                 consoleLog(`stored progress: reduced to ${_record_keep_}`)
  2114.                             })
  2115.                         }
  2116.  
  2117.                         asyncPromise = asyncPromise.then(() => {
  2118.                             player.setAttribute('_h5p_uid_encrypted', _uid_encrypted + '+' + d);
  2119.  
  2120.                             //try to start recording
  2121.                             if (player._record_continuous) player._record_continuous.playingWithRecording();
  2122.                         })
  2123.  
  2124.                     }, 5400);
  2125.  
  2126.                 })
  2127.  
  2128.             },
  2129.             bindDocEvents: function(rootNode) {
  2130.                 if (!rootNode._onceBindedDocEvents) {
  2131.  
  2132.                     rootNode._onceBindedDocEvents = true;
  2133.                     rootNode.addEventListener('keydown', $hs.handlerRootKeyDownEvent, true)
  2134.                     //document._debug_rootNode_ = rootNode;
  2135.  
  2136.                     rootNode.addEventListener('mouseenter', $hs.handlerElementMouseEnter, true)
  2137.                     rootNode.addEventListener('mouseleave', $hs.handlerElementMouseLeave, true)
  2138.                     rootNode.addEventListener('mousedown', $hs.handlerElementMouseDown, true)
  2139.                     rootNode.addEventListener('mouseup', $hs.handlerElementMouseUp, true)
  2140.                     rootNode.addEventListener('wheel', $hs.handlerElementWheelTuneVolume, {
  2141.                         passive: false
  2142.                     });
  2143.  
  2144.                     // wheel - bubble events to keep it simple (i.e. it must be passive:false & capture:false)
  2145.  
  2146.  
  2147.                     rootNode.addEventListener('focus', $hs.handlerElementFocus, $mb.eh_capture_passive())
  2148.                     rootNode.addEventListener('fullscreenchange', $hs.handlerFullscreenChanged, true)
  2149.  
  2150.                     //rootNode.addEventListener('mousemove', $hs.handlerOverrideMouseMove, {capture:true, passive:false})
  2151.  
  2152.                 }
  2153.             },
  2154.             fireGlobalInit: function() {
  2155.                 if ($hs.intVideoInitCount != 1) return;
  2156.                 if (!$hs.varSrcList) $hs.varSrcList = {};
  2157.  
  2158.                 Store.clearInvalid(_sVersion_)
  2159.  
  2160.  
  2161.                 Promise.resolve().then(() => {
  2162.  
  2163.                     GM_addStyle(`
  2164.                         .ytp-chrome-bottom+span#volumeUI:last-child:empty{
  2165.                             display:none;
  2166.                         }
  2167.                         html[_h5p_hide_cursor]{
  2168.                             cursor:none !important;
  2169.                         }
  2170.                     `)
  2171.                 })
  2172.  
  2173.             },
  2174.             getPlaybackRate: function() {
  2175.                 let playbackRate = Store.read('_playback_rate_');
  2176.                 if(+playbackRate>0) return +((+playbackRate).toFixed(1));
  2177.                 return 1.0;
  2178.             },
  2179.  
  2180.             _getPlayerBlockElement:function(player){
  2181.  
  2182.  
  2183.                 let layoutBox = null,
  2184.                     wPlayer = null, wPlayerInner=null;
  2185.  
  2186.                 if (!player || !player.parentNode) {
  2187.                     return null;
  2188.                 }
  2189.  
  2190. /*
  2191.                 if (useCache === true) {
  2192.                     let vpid = player.getAttribute('_h5ppid');
  2193.                     let actionBoxRelation = $hs.actionBoxRelations[vpid]
  2194.                     if (actionBoxRelation && actionBoxRelation.mutationRemovalsCount === 0) {
  2195.                         return actionBoxRelation.wPlayer
  2196.                     }
  2197.                 }*/
  2198.  
  2199.  
  2200.                 //without checkActiveBox, just a DOM for you to append tipsDom
  2201.  
  2202.                 function oWH(elm) {
  2203.                     return [elm.offsetWidth, elm.offsetHeight].join(',');
  2204.                 }
  2205.  
  2206.                 function search_nodes() {
  2207.  
  2208.                     wPlayer = player; // NOT NULL
  2209.                     layoutBox = wPlayer.parentNode; // NOT NULL
  2210.  
  2211.                     while (layoutBox.parentNode && layoutBox.nodeType == 1 && layoutBox.offsetHeight == 0) {
  2212.                         wPlayer = layoutBox; // NOT NULL
  2213.                         layoutBox = layoutBox.parentNode; // NOT NULL
  2214.                     }
  2215.                     //container must be with offsetHeight
  2216.  
  2217.                     while (layoutBox.parentNode && layoutBox.nodeType == 1 && layoutBox.offsetHeight < player.offsetHeight) {
  2218.                         wPlayer = layoutBox; // NOT NULL
  2219.                         layoutBox = layoutBox.parentNode; // NOT NULL
  2220.                     }
  2221.                     //container must have height >= player height
  2222.  
  2223.                     wPlayerInner=wPlayer
  2224.  
  2225.                     const layoutOWH = oWH(layoutBox)
  2226.                     //const playerOWH=oWH(player)
  2227.  
  2228.                     //skip all inner wraps
  2229.                     while (layoutBox.parentNode && layoutBox.nodeType == 1 && oWH(layoutBox.parentNode) == layoutOWH) {
  2230.                         wPlayer = layoutBox; // NOT NULL
  2231.                         layoutBox = layoutBox.parentNode; // NOT NULL
  2232.                     }
  2233.  
  2234.                     // oWH of layoutBox.parentNode != oWH of layoutBox and layoutBox.offsetHeight >= player.offsetHeight
  2235.  
  2236.                 }
  2237.  
  2238.                 search_nodes();
  2239.  
  2240.                 if (layoutBox.nodeType == 11) {
  2241.                     makeNoRoot(layoutBox);
  2242.                     search_nodes();
  2243.                 }
  2244.  
  2245.  
  2246.  
  2247.                 //condition:
  2248.                 //!layoutBox.parentNode || layoutBox.nodeType != 1 || layoutBox.offsetHeight > player.offsetHeight
  2249.  
  2250.                 // layoutBox is a node contains <video> and offsetHeight>=video.offsetHeight
  2251.                 // wPlayer is a HTML Element (nodeType==1)
  2252.                 // you can insert the DOM element into the layoutBox
  2253.  
  2254.                 if (layoutBox && wPlayer && layoutBox.nodeType === 1 && wPlayer.parentNode == layoutBox && layoutBox.parentNode){
  2255.                     let p={wPlayerInner,wPlayer};
  2256.                     return p;
  2257.                 }
  2258.                 throw 'unknown error';
  2259.             },
  2260.  
  2261.             parentingN:function(elm, parent, n){
  2262.  
  2263.                 if(!elm || !parent) return false;
  2264.                 let pElm=elm;
  2265.                 for(let i =0;i<n && pElm;i++) pElm=pElm.parentNode;
  2266.                 return (pElm===parent);
  2267.  
  2268.  
  2269.  
  2270.             },
  2271.  
  2272.             parentingInclusive:function(elm, parent){
  2273.  
  2274.  
  2275.                     let pElm=elm, arr=[];
  2276.                     while(pElm){
  2277.                         arr.push(pElm);
  2278.                         if(pElm===parent)break;
  2279.                         pElm=pElm.parentNode;
  2280.                     }
  2281.                     if(pElm===parent) return arr;
  2282.                 return null;
  2283.  
  2284.             },
  2285.             __layout_resize_observer_callback__:(entries, observer)=>{
  2286.                         const player = observer.player;
  2287.                         player._cache_wPlayerr=null;
  2288.                         for(const {target} of entries){
  2289.                             if('__to_player_n__' in target && target.__to_player_n__>=0){
  2290.                                 if(!$hs.parentingN(player, target, target.__to_player_n__)) observer.unobserve(target)
  2291.                             }else{
  2292.                                 observer.unobserve(target)
  2293.                             }
  2294.                         }
  2295.                     },
  2296.             getPlayerBlockElement: function(player) {
  2297.  
  2298.                 if (!player || !player.parentNode) {
  2299.                     return null;
  2300.                 }
  2301.  
  2302.                 if(!player.__layout_resize_observer__){
  2303.  
  2304.                     let wPlayerr = $hs._getPlayerBlockElement(player)
  2305.                     let {wPlayerInner,wPlayer}=wPlayerr
  2306.                     let layoutBox = wPlayer.parentNode
  2307.  
  2308.                     player.__layout_resize_observer__=new ResizeObserver($hs.__layout_resize_observer_callback__)
  2309.                     player.__layout_resize_observer__.player=player;
  2310.  
  2311.                     let kh= $hs.parentingInclusive(player, layoutBox);
  2312.                     if(kh){
  2313.  
  2314.                         for(const elm of kh) player.__layout_resize_observer__.observe(elm)
  2315.                         player.__layout_resize_n__=kh.length
  2316.  
  2317.                     }else{
  2318.                         player.__layout_resize_n__=0
  2319.                     }
  2320.  
  2321.                     player._cache_wPlayerr=wPlayerr;
  2322.                     return player._cache_wPlayerr;
  2323.                 }
  2324.  
  2325.  
  2326.                 if(player._cache_wPlayerr && player.__layout_resize_n__>0) {
  2327.                     let kt=$hs.parentingN(player, player._cache_wPlayerr.wPlayer.parentNode, player.__layout_resize_n__-1);
  2328.                     if(kt) return player._cache_wPlayerr;
  2329.                 }
  2330.  
  2331.                 let wPlayerr=$hs._getPlayerBlockElement(player);
  2332.  
  2333.                 let {wPlayerInner,wPlayer} = wPlayerr
  2334.                 let layoutBox = wPlayer.parentNode
  2335.  
  2336.                 let kh= $hs.parentingInclusive(player, layoutBox);
  2337.  
  2338.                 if(kh){
  2339.  
  2340.                     let wi=0;
  2341.                     for(const elm of kh) {
  2342.                         elm.__to_player_n__=wi;
  2343.                         player.__layout_resize_observer__.observe(elm)
  2344.                         wi++;
  2345.                     }
  2346.                     player.__layout_resize_n__=kh.length
  2347.                 }else{
  2348.                     player.__layout_resize_n__=0
  2349.                 }
  2350.                 player._cache_wPlayerr=wPlayerr
  2351.                 return player._cache_wPlayerr;
  2352.  
  2353.             },
  2354.             change_layoutBox: function(tipsDom, player) {
  2355.                 if (!player || !player.parentNode) return;
  2356.                 let {wPlayerInner,wPlayer} = $hs.getPlayerBlockElement(player);
  2357.                 let layoutBoxInner = wPlayerInner.parentNode;
  2358.                 let beforeParent = tipsDom.parentNode;
  2359.  
  2360.                 if ((layoutBoxInner && layoutBoxInner.nodeType == 1) && (!beforeParent || beforeParent !== layoutBoxInner)) {
  2361.  
  2362.                     consoleLog('changed_layoutBox')
  2363.                     if (beforeParent && beforeParent !== layoutBoxInner){
  2364.                         if($hs.observer_resizeVideos) $hs.observer_resizeVideos.unobserve(beforeParent)
  2365.                         if(tipsDom.nextSibling && tipsDom.nextSibling.nodeName==utPositioner) beforeParent.removeChild(tipsDom.nextSibling);
  2366.                     }
  2367.                     layoutBoxInner.insertBefore(tipsDom, wPlayerInner);
  2368.  
  2369.                 }
  2370.  
  2371.                 tipsDom._playerVPID = player.getAttribute('_h5ppid');
  2372.             },
  2373.  
  2374.             _hasEventListener: function(elm, p) {
  2375.                 if (typeof elm['on' + p] == 'function') return true;
  2376.                 let listeners = $hs._getEventListeners(elm)
  2377.                 if (listeners) {
  2378.                     const cache = listeners[p]
  2379.                     return cache && cache.count > 0
  2380.                 }
  2381.                 return false;
  2382.             },
  2383.  
  2384.             _getEventListeners: function(elmNode) {
  2385.  
  2386.  
  2387.                 let listeners = wmListeners.get(elmNode);
  2388.  
  2389.                 if (listeners && typeof listeners == 'object') return listeners;
  2390.  
  2391.                 return null;
  2392.  
  2393.             },
  2394.  
  2395.             queryFullscreenBtnsIndependant: function(parentNode) {
  2396.  
  2397.                 let btns = [];
  2398.  
  2399.                 function elmCallback(elm) {
  2400.  
  2401.                     let hasClickListeners = null,
  2402.                         childElementCount = null,
  2403.                         isVisible = null,
  2404.                         btnElm = elm;
  2405.                     var pElm = elm;
  2406.                     while (pElm && pElm.nodeType === 1 && pElm != parentNode && pElm.querySelector('video') === null) {
  2407.  
  2408.                         let funcTest = $hs._hasEventListener(pElm, 'click');
  2409.                         funcTest = funcTest || $hs._hasEventListener(pElm, 'mousedown');
  2410.                         funcTest = funcTest || $hs._hasEventListener(pElm, 'mouseup');
  2411.  
  2412.                         if (funcTest) {
  2413.                             hasClickListeners = true
  2414.                             btnElm = pElm;
  2415.                             break;
  2416.                         }
  2417.  
  2418.                         pElm = pElm.parentNode;
  2419.                     }
  2420.                     if (btns.indexOf(btnElm) >= 0) return; //btn>a.fullscreen-1>b.fullscreen-2>c.fullscreen-3
  2421.  
  2422.  
  2423.                     if ('childElementCount' in elm) {
  2424.  
  2425.                         childElementCount = elm.childElementCount;
  2426.  
  2427.                     }
  2428.                     if ('offsetParent' in elm) {
  2429.                         isVisible = !!elm.offsetParent; //works with parent/self display none; not work with visiblity hidden / opacity0
  2430.  
  2431.                     }
  2432.  
  2433.                     if (hasClickListeners) {
  2434.                         let btn = {
  2435.                             elm,
  2436.                             btnElm,
  2437.                             isVisible,
  2438.                             hasClickListeners,
  2439.                             childElementCount,
  2440.                             isContained: null
  2441.                         };
  2442.  
  2443.                         //console.log('btnElm', btnElm)
  2444.  
  2445.                         btns.push(btnElm)
  2446.  
  2447.                     }
  2448.                 }
  2449.  
  2450.  
  2451.                 for (const elm of parentNode.querySelectorAll('[class*="full"][class*="screen"]')) {
  2452.                     let className = (elm.getAttribute('class') || "");
  2453.                     if (/\b(fullscreen|full-screen)\b/i.test(className.replace(/([A-Z][a-z]+)/g, '-$1-').replace(/[\_\-]+/g, '-'))) {
  2454.                         elmCallback(elm)
  2455.                     }
  2456.                 }
  2457.  
  2458.  
  2459.                 for (const elm of parentNode.querySelectorAll('[id*="full"][id*="screen"]')) {
  2460.                     let idName = (elm.getAttribute('id') || "");
  2461.                     if (/\b(fullscreen|full-screen)\b/i.test(idName.replace(/([A-Z][a-z]+)/g, '-$1-').replace(/[\_\-]+/g, '-'))) {
  2462.                         elmCallback(elm)
  2463.                     }
  2464.                 }
  2465.  
  2466.                 for (const elm of parentNode.querySelectorAll('[name*="full"][name*="screen"]')) {
  2467.                     let nName = (elm.getAttribute('name') || "");
  2468.                     if (/\b(fullscreen|full-screen)\b/i.test(nName.replace(/([A-Z][a-z]+)/g, '-$1-').replace(/[\_\-]+/g, '-'))) {
  2469.                         elmCallback(elm)
  2470.                     }
  2471.                 }
  2472.  
  2473.                 parentNode = null;
  2474.  
  2475.                 return btns;
  2476.  
  2477.             },
  2478.             exclusiveElements: function(elms) {
  2479.  
  2480.                 //not containing others
  2481.                 let res = [];
  2482.  
  2483.                 for (const roleElm of elms) {
  2484.  
  2485.                     let isContained = false;
  2486.                     for (const testElm of elms) {
  2487.                         if (testElm != roleElm && roleElm.contains(testElm)) {
  2488.                             isContained = true;
  2489.                             break;
  2490.                         }
  2491.                     }
  2492.                     if (!isContained) res.push(roleElm)
  2493.                 }
  2494.                 return res;
  2495.  
  2496.             },
  2497.  
  2498.             getWithFullscreenBtn: function(actionBoxRelation) {
  2499.  
  2500.  
  2501.  
  2502.                 //console.log('callFullScreenBtn', 300)
  2503.  
  2504.                 if (actionBoxRelation && actionBoxRelation.actionBox) {
  2505.                     let actionBox = actionBoxRelation.actionBox;
  2506.                     let btnElements = actionBoxRelation.fullscreenBtns;
  2507.  
  2508.                     //  console.log('callFullScreenBtn', 400)
  2509.                     if (btnElements && btnElements.length > 0) {
  2510.  
  2511.                         // console.log('callFullScreenBtn', 500, btnElements, actionBox.contains(btnElements[0]))
  2512.  
  2513.                         let btnElement_idx = btnElements._only_idx;
  2514.  
  2515.                         if (btnElement_idx >= 0) {
  2516.  
  2517.                         } else if (btnElements.length === 1) {
  2518.                             btnElement_idx = 0;
  2519.                         } else if (btnElements.length > 1) {
  2520.                             //web-fullscreen-on/off ;  fullscreen-on/off ....
  2521.  
  2522.                             const strList = btnElements.map(elm => [elm.className || 'null', elm.id || 'null', elm.name || 'null'].join('-').replace(/([A-Z][a-z]+)/g, '-$1-').replace(/[\_\-]+/g, '-'))
  2523.  
  2524.                             const filterOutScores = new Array(strList.length).fill(0);
  2525.                             const filterInScores = new Array(strList.length).fill(0);
  2526.                             const filterScores = new Array(strList.length).fill(0);
  2527.                             for (const [j, str] of strList.entries()) {
  2528.                                 if (/\b(fullscreen|full-screen)\b/i.test(str)) filterInScores[j] += 1
  2529.                                 if (/\b(web-fullscreen|web-full-screen)\b/i.test(str)) filterOutScores[j] += 1
  2530.                                 if (/\b(fullscreen-on|full-screen-on)\b/i.test(str)) filterInScores[j] += 1
  2531.                                 if (/\b(fullscreen-off|full-screen-off)\b/i.test(str)) filterOutScores[j] += 1
  2532.                                 if (/\b(on-fullscreen|on-full-screen)\b/i.test(str)) filterInScores[j] += 1
  2533.                                 if (/\b(off-fullscreen|off-full-screen)\b/i.test(str)) filterOutScores[j] += 1
  2534.                             }
  2535.  
  2536.                             let maxScore = -1e7;
  2537.                             for (const [j, str] of strList.entries()) {
  2538.                                 filterScores[j] = filterInScores[j] * 3 - filterOutScores[j] * 2
  2539.                                 if (filterScores[j] > maxScore) maxScore = filterScores[j];
  2540.                             }
  2541.                             btnElement_idx = filterScores.indexOf(maxScore)
  2542.                             if (btnElement_idx < 0) btnElement_idx = 0; //unknown
  2543.                         }
  2544.  
  2545.                         btnElements._only_idx = btnElement_idx
  2546.  
  2547.  
  2548.                         //consoleLog('original fullscreen')
  2549.                         return btnElements[btnElement_idx];
  2550.  
  2551.                     }
  2552.  
  2553.  
  2554.                 }
  2555.                 return null
  2556.             },
  2557.  
  2558.             callFullScreenBtn: function() {
  2559.                 console.log('callFullScreenBtn')
  2560.  
  2561.  
  2562.  
  2563.                 let player = $hs.player()
  2564.                 if (!player || !player.parentNode || !player.ownerDocument || !('exitFullscreen' in player.ownerDocument)) return;
  2565.  
  2566.                 let btnElement = null;
  2567.  
  2568.                 let vpid = player.getAttribute('_h5ppid') || null;
  2569.  
  2570.                 if (!vpid) return;
  2571.  
  2572.  
  2573.                 const chFull = $hs.toolCheckFullScreen(player.ownerDocument);
  2574.  
  2575.  
  2576.  
  2577.                 if (chFull === true) {
  2578.                     player.ownerDocument.exitFullscreen();
  2579.                     return;
  2580.                 }
  2581.  
  2582.                 let actionBoxRelation = $hs.actionBoxRelations[vpid];
  2583.  
  2584.  
  2585.                 let asyncRes = Promise.resolve(actionBoxRelation)
  2586.                 if (chFull === false) asyncRes = asyncRes.then($hs.getWithFullscreenBtn);
  2587.                 else asyncRes = asyncRes.then(() => null)
  2588.  
  2589.                 asyncRes.then((btnElement) => {
  2590.  
  2591.                     if (btnElement) {
  2592.  
  2593.                         window.requestAnimationFrame(() => btnElement.click());
  2594.                         player = null;
  2595.                         actionBoxRelation = null;
  2596.                         return;
  2597.                     }
  2598.  
  2599.                     let fsElm = $vQuery.rootNode(vpid).querySelector(`[_h5p_fsElm_="${vpid}"]`); //it is set in fullscreenchange
  2600.  
  2601.                     let gPlayer = fsElm
  2602.  
  2603.                     if (gPlayer) {
  2604.  
  2605.                     } else if (actionBoxRelation && actionBoxRelation.actionBox) {
  2606.                         gPlayer = actionBoxRelation.actionBox;
  2607.                     } else if (actionBoxRelation && actionBoxRelation.layoutBox) {
  2608.                         gPlayer = actionBoxRelation.layoutBox;
  2609.                     } else {
  2610.                         gPlayer = player;
  2611.                     }
  2612.  
  2613.  
  2614.                     player = null;
  2615.                     actionBoxRelation = null;
  2616.  
  2617.                     if (gPlayer != fsElm && !fsElm) {
  2618.                         delayCall('$$videoReset_fsElm', function() {
  2619.                             gPlayer.removeAttribute('_h5p_fsElm_')
  2620.                         }, 137)
  2621.                     }
  2622.  
  2623.                     console.log('DOM fullscreen', gPlayer)
  2624.                     try {
  2625.                         const res = gPlayer.requestFullscreen()
  2626.                         if (res && res.constructor.name == "Promise") res.catch((e) => 0)
  2627.                     } catch (e) {
  2628.                         console.log('DOM fullscreen Error', e)
  2629.                     }
  2630.  
  2631.  
  2632.  
  2633.  
  2634.                 })
  2635.  
  2636.  
  2637.  
  2638.  
  2639.             },
  2640.             /* 設置播放速度 */
  2641.             setPlaybackRate: function(num, flagTips) {
  2642.                 let player = $hs.player()
  2643.                 let curPlaybackRate
  2644.                 if (num) {
  2645.                     num = +num
  2646.                     if (num > 0) { // also checking the type of variable
  2647.                         curPlaybackRate = num < 0.1 ? 0.1 : +(num.toFixed(1))
  2648.                     } else {
  2649.                         console.error('h5player: 播放速度轉換出錯')
  2650.                         return false
  2651.                     }
  2652.                 } else {
  2653.                     curPlaybackRate = $hs.getPlaybackRate()
  2654.                 }
  2655.                 /* 記錄播放速度的信息 */
  2656.  
  2657.                 let changed = curPlaybackRate !== player.playbackRate;
  2658.  
  2659.                 if (curPlaybackRate !== player.playbackRate) {
  2660.  
  2661.                     Store.save('_playback_rate_', curPlaybackRate + '')
  2662.                     player.playbackRate = curPlaybackRate
  2663.                     /* 本身處於1被播放速度的時候不再提示 */
  2664.                     //if (!num && curPlaybackRate === 1) return;
  2665.  
  2666.                 }
  2667.  
  2668.                 flagTips = (flagTips < 0) ? false : (flagTips > 0) ? true : changed;
  2669.                 if (flagTips) $hs.tips('Playback speed: ' + player.playbackRate + 'x')
  2670.             },
  2671.             tuneCurrentTimeTips: function(_amount, changed) {
  2672.  
  2673.                 $hs.tips(false);
  2674.                 if (changed) {
  2675.                     if (_amount > 0) $hs.tips(_amount + ' Sec. Forward', undefined, 3000);
  2676.                     else $hs.tips(-_amount + ' Sec. Backward', undefined, 3000)
  2677.                 }
  2678.             },
  2679.             tuneCurrentTime: function(amount) {
  2680.                 let _amount = +(+amount).toFixed(1);
  2681.                 if (!$hs.isNum(_amount)) return;
  2682.                 let player = $hs.player();
  2683.  
  2684.                 let newCurrentTime = player.currentTime + _amount;
  2685.                 if (newCurrentTime < 0) newCurrentTime = 0;
  2686.                 if (newCurrentTime > player.duration) newCurrentTime = player.duration;
  2687.  
  2688.                 let changed = newCurrentTime != player.currentTime && newCurrentTime >= 0 && newCurrentTime <= player.duration;
  2689.  
  2690.                 if (changed) {
  2691.                     //player.currentTime = newCurrentTime;
  2692.                     //player.pause();
  2693.  
  2694.  
  2695.                     const video = player;
  2696.                     var isPlaying = isVideoPlaying(video);
  2697.  
  2698.                     if (isPlaying) {
  2699.                         player.pause();
  2700.                         $hs.ccad = $hs.ccad || function() {
  2701.                             if (player.paused) player.play();
  2702.                         };
  2703.                         player.addEventListener('seeked', $hs.ccad, {
  2704.                             passive: true,
  2705.                             capture: true,
  2706.                             once: true
  2707.                         });
  2708.  
  2709.                     }
  2710.  
  2711.  
  2712.  
  2713.  
  2714.                     player.currentTime = +newCurrentTime.toFixed(0)
  2715.  
  2716.                     $hs.tuneCurrentTimeTips(_amount, changed)
  2717.  
  2718.  
  2719.                 }
  2720.  
  2721.             },
  2722.             tuneVolume: function(amount) {
  2723.  
  2724.                 let player = $hs.player()
  2725.  
  2726.                 let intAmount = Math.round(amount * 100)
  2727.  
  2728.                 let intOldVol = Math.round(player.volume * 100)
  2729.                 let intNewVol = intOldVol + intAmount
  2730.  
  2731.  
  2732.                 //0.53 -> 0.55
  2733.  
  2734.                 //0.53 / 0.05 =10.6 => 11  => 11*0.05 = 0.55
  2735.  
  2736.                 intNewVol = Math.round(intNewVol / intAmount) * intAmount
  2737.                 if (intAmount > 0 && intNewVol - intOldVol > intAmount) intNewVol -= intAmount;
  2738.                 else if (intAmount < 0 && intNewVol - intOldVol < intAmount) intNewVol -= intAmount;
  2739.  
  2740.  
  2741.                 let _amount = intAmount / 100;
  2742.                 let oldVol = intOldVol / 100;
  2743.                 let newVol = intNewVol / 100;
  2744.  
  2745.  
  2746.                 if (newVol < 0) newVol = 0;
  2747.                 if (newVol > 1) newVol = 1;
  2748.                 let chVol = oldVol !== newVol && newVol >= 0 && newVol <= 1;
  2749.  
  2750.                 if (chVol) {
  2751.  
  2752.                     if (_amount > 0 && oldVol < 1) {
  2753.                         player.volume = newVol // positive
  2754.                     } else if (_amount < 0 && oldVol > 0) {
  2755.                         player.volume = newVol // negative
  2756.                     }
  2757.                     $hs.tips(false);
  2758.                     $hs.tips('Volume: ' + dround(player.volume * 100) + '%', undefined)
  2759.                 }
  2760.             },
  2761.             switchPlayStatus: function() {
  2762.                 let player = $hs.player()
  2763.                 if (player.paused) {
  2764.                     player.play()
  2765.                     if (player._isThisPausedBefore_) {
  2766.                         $hs.tips(false);
  2767.                         $hs.tips('Playback resumed', undefined, 2500)
  2768.                     }
  2769.                 } else {
  2770.                     player.pause()
  2771.                     $hs.tips(false);
  2772.                     $hs.tips('Playback paused', undefined, 2500)
  2773.                 }
  2774.             },
  2775.             tipsDomObserve: (tipsDom, player) => {
  2776.  
  2777.                 //observe not fire twice for the same element.
  2778.                 if (!$hs.observer_resizeVideos) $hs.observer_resizeVideos = new ResizeObserver(hanlderResizeVideo)
  2779.                 $hs.observer_resizeVideos.observe(tipsDom.parentNode)
  2780.                 $hs.observer_resizeVideos.observe(player)
  2781.  
  2782.                 $hs.fixNonBoxingVideoTipsPosition(tipsDom, player);
  2783.  
  2784.  
  2785.             },
  2786.             _tips: function(player, str, duration, order) {
  2787.  
  2788.  
  2789.                 if (!player || !player.parentNode) return;
  2790.                 const vpid = player.getAttribute('_h5ppid');
  2791.                 if (!vpid) return;
  2792.                 //$vQuery.rootNode(vpid)
  2793.                 let fSetDOM = false;
  2794.  
  2795.                 Promise.resolve().then(() => {
  2796.  
  2797.  
  2798.                     if (!player.getAttribute('_h5player_tips')){
  2799.  
  2800.                         // first time to trigger this player
  2801.                         if (!player.hasAttribute('playsinline')) player.setAttribute('playsinline', 'playsinline');
  2802.                         if (!player.hasAttribute('x-webkit-airplay')) player.setAttribute('x-webkit-airplay', 'deny');
  2803.                         if (!player.hasAttribute('preload')) player.setAttribute('preload', 'auto');
  2804.                         //player.style['image-rendering'] = 'crisp-edges';
  2805.  
  2806.                         $hs.initTips(player);
  2807.                     }
  2808.  
  2809.                 }).then(() => {
  2810.  
  2811.                     let tipsSelector = '#' + player.getAttribute('_h5player_tips') //if this attribute still doesnt exist, set it to the base cls name
  2812.                     let tipsDom = $vQuery.rootNode(vpid).querySelector(tipsSelector)
  2813.                     if (!tipsDom) {
  2814.                         consoleLog('init h5player tips dom error...')
  2815.                         return false
  2816.                     }
  2817.  
  2818.                     return tipsDom
  2819.  
  2820.                 }).then((tipsDom) => {
  2821.                     if (tipsDom === false) return false;
  2822.  
  2823.                     if (str === false) {
  2824.                         if ((tipsDom.getAttribute('data-h5p-pot-tips') || '').length) {
  2825.                             tipsDom.setAttribute('data-h5p-pot-tips', '');
  2826.                             tipsDom._tips_display_none = true;
  2827.                         }
  2828.                     } else {
  2829.                         order = order || 1000
  2830.                         tipsDom.tipsOrder = tipsDom.tipsOrder || 0;
  2831.  
  2832.                         let shallDisplay = true
  2833.                         if (order < tipsDom.tipsOrder && tipsDom._tips_display_none == false) shallDisplay = false
  2834.  
  2835.                         if (shallDisplay) {
  2836.  
  2837.                             if (tipsDom._tips_display_none || tipsDom._playerVPID != vpid) {
  2838.  
  2839.                                 $hs.change_layoutBox(tipsDom, player);
  2840.                                 fSetDOM = true;
  2841.  
  2842.                             }
  2843.  
  2844.                             if (duration === undefined) duration = 2000
  2845.  
  2846.                             $hs.pendingTips = $hs.pendingTips || {};
  2847.  
  2848.                             if($hs.pendingTips[tipsDom._playerVPID] && tipsDom.tipsOrder == order && duration > 0){
  2849.  
  2850.                                 tipsDom.setAttribute('data-h5p-pot-tips', str);
  2851.                                 tipsDom.style['animation-duration']=duration+'ms';
  2852.  
  2853.  
  2854.                             }else{
  2855.  
  2856.                                 $hs.pendingTips[tipsDom._playerVPID] = tipsDom
  2857.  
  2858.  
  2859.                                 tipsDom.removeAttribute('_h5p_animate'); //force animation reset
  2860.  
  2861.                                 tipsDom.setAttribute('data-h5p-pot-tips', str);
  2862.                                 tipsDom._tips_display_none = false;
  2863.  
  2864.                                 if(duration>0) tipsDom.style['animation-duration']=duration+'ms';
  2865.  
  2866.  
  2867.                                 const withFadeOut = duration > 0 && !($hs.mouseDownAt && $hs.mouseDownAt.insideVideo === player);
  2868.  
  2869.  
  2870.                                 1&&!(function(tipsDom, withFadeOut) {
  2871.                                     window.requestAnimationFrame(function() {
  2872.                                         tipsDom.setAttribute('_h5p_animate', withFadeOut?'':'P');
  2873.                                         if(withFadeOut) delete $hs.pendingTips[tipsDom._playerVPID];
  2874.                                         tipsDom=null;
  2875.                                     })
  2876.                                 })(tipsDom, withFadeOut);
  2877.  
  2878.  
  2879.  
  2880.                                 if (!(duration > 0)) {
  2881.                                     order = -1;
  2882.                                 }
  2883.  
  2884.                                 tipsDom.tipsOrder = order
  2885.  
  2886.                             }
  2887.  
  2888.  
  2889.                         }
  2890.  
  2891.                     }
  2892.  
  2893.                     return tipsDom;
  2894.  
  2895.                 }).then((tipsDom) => {
  2896.                     if (tipsDom === false) return false;
  2897.  
  2898.                     if (fSetDOM) {
  2899.                         $hs.tipsDomObserve(tipsDom, player);
  2900.  
  2901.                     }
  2902.  
  2903.                 })
  2904.  
  2905.             },
  2906.             tips: function(str, duration, order) {
  2907.                 let player = $hs.player()
  2908.                 if (!player || !player.parentNode) {
  2909.                     consoleLog('h5Player Tips:', str)
  2910.                 } else {
  2911.                     $hs._tips(player, str, duration, order)
  2912.  
  2913.                 }
  2914.  
  2915.             },
  2916.             handler_tipsDom_animation:function(e) {
  2917.                     this._tips_display_none = true;
  2918.                 },
  2919.             initTips: function(player) {
  2920.                 /* 設置提示DOM的樣式 */
  2921.  
  2922.                 if(!player || !player.parentNode)return;
  2923.  
  2924.                 let shadowRoot = getRoot(player);
  2925.                 let doc = player.ownerDocument;
  2926.                 //console.log((document.documentElement.qq=player),shadowRoot,'xax')
  2927.                 let parentNode = player.parentNode
  2928.                 let tcn = player.getAttribute('_h5player_tips') || ($hs.tipsClassName + '_' + (+new Date));
  2929.                 player.setAttribute('_h5player_tips', tcn)
  2930.                 if (shadowRoot.querySelector('#' + tcn)) return false;
  2931.  
  2932.                 if (!shadowRoot._onceAddedCSS) {
  2933.                     shadowRoot._onceAddedCSS = true;
  2934.  
  2935.                     let cssStyle = `
  2936.                     ${utPositioner}{
  2937.                         position:absolute !important;
  2938.                         top:auto !important;
  2939.                         left:auto !important;
  2940.                         right:auto !important;
  2941.                         bottom:auto !important;
  2942.                         width:0 !important;
  2943.                         height:0 !important;
  2944.                         margin:0 !important;
  2945.                         padding:0 !important;
  2946.                         border:0 !important;
  2947.                         outline:0 !important;
  2948.                         transform:none !important;
  2949.                     }
  2950.                     [data-h5p-pot-tips][_h5p_animate]{
  2951.                         animation: 2s linear 0s normal forwards 1 delayHide;
  2952.                     }
  2953.  
  2954.                     [data-h5p-pot-tips][_h5p_animate="P"]{
  2955.                         animation-play-state:paused;
  2956.                     }
  2957.                     [data-h5p-pot-tips]{
  2958.                         opacity:.95; transform: translate(0px, 0px);
  2959.                     }
  2960.  
  2961.                     @keyframes delayHide{
  2962.                         0%, 99% { opacity:0.95; transform: translate(0px, 0px); }
  2963.                         100% { opacity:0; transform:translate(-9999px, -9999px); }
  2964.                     }
  2965.                     [data-h5p-pot-tips]{
  2966.                         font-weight: bold !important;
  2967.                         position:absolute !important;
  2968.                         top:auto !important;
  2969.                         left:auto !important;
  2970.                         right:auto !important;
  2971.                         bottom:auto !important;
  2972.  
  2973.                         display:inline-block;
  2974.                         z-index: 999 !important;
  2975.                         font-size: ${$hs.fontSize || 16}px !important;
  2976.                         padding: 0px !important;
  2977.                         border:none !important;
  2978.                         background: rgba(0,0,0,0) !important;
  2979.                         color:#738CE6 !important;
  2980.                         text-shadow: -1px -1px 0 #000, 1px -1px 0 #000, -1px 1px 0 #000, 1px 1px 0 #000;
  2981.                         max-width:500px;max-height:50px;
  2982.                         border-radius:3px;
  2983.                         font-family: 'microsoft yahei', Verdana, Geneva, sans-serif;
  2984.                         pointer-events: none;
  2985.                     }
  2986.                     [data-h5p-pot-tips]::before{
  2987.                         content:attr(data-h5p-pot-tips);
  2988.                         display:inline-block;
  2989.                         position:relative;
  2990.  
  2991.                     }
  2992.                     body div[data-h5p-pot-tips]{
  2993.                         -webkit-user-select: none !important;
  2994.                         -moz-user-select: none !important;
  2995.                         -ms-user-select: none !important;
  2996.                         user-select: none !important;
  2997.                         -webkit-touch-callout: none !important;
  2998.                         -webkit-user-select: none !important;
  2999.                         -khtml-user-drag: none !important;
  3000.                         -khtml-user-select: none !important;
  3001.                         -moz-user-select: none !important;
  3002.                         -moz-user-select: -moz-none !important;
  3003.                         -ms-user-select: none !important;
  3004.                         user-select: none !important;
  3005.                     }
  3006.                     .ytp-chrome-bottom+span#volumeUI:last-child:empty{
  3007.                         display:none;
  3008.                     }
  3009.                     `.replace(/\r\n/g, '');
  3010.  
  3011.  
  3012.                     let cssContainer = domAppender(shadowRoot);
  3013.  
  3014.  
  3015.                     if (!cssContainer) {
  3016.                         cssContainer = makeNoRoot(shadowRoot)
  3017.                     }
  3018.  
  3019.                     domTool.addStyle(cssStyle, cssContainer);
  3020.  
  3021.                 }
  3022.  
  3023.                 let tipsDom = doc.createElement('div')
  3024.  
  3025.                 tipsDom.addEventListener(crossBrowserTransition('animation'), $hs.handler_tipsDom_animation, $mb.eh_bubble_passive())
  3026.  
  3027.                 tipsDom.id = tcn;
  3028.                 tipsDom.setAttribute('data-h5p-pot-tips', '');
  3029.                 tipsDom._tips_display_none = true;
  3030.                 $hs.change_layoutBox(tipsDom, player);
  3031.  
  3032.                 return true;
  3033.             },
  3034.  
  3035.  
  3036.             isNum:(d)=>(d>0||d<0||d===0),
  3037.             fixNonBoxingVideoTipsPosition: function(tipsDom, player) {
  3038.  
  3039.                 if (!tipsDom || !player) return false;
  3040.  
  3041.                 let ct = tipsDom.parentNode
  3042.  
  3043.                 if (!ct) return false;
  3044.  
  3045. //return;
  3046.                 // absolute
  3047.  
  3048.                 let targetOffset = {
  3049.                     left: 10,
  3050.                     top: 15
  3051.                 };
  3052.                 if(!tipsDom.nextSibling||tipsDom.nextSibling.nodeName!=utPositioner){
  3053.                     tipsDom.parentNode.insertBefore(document.createElement(utPositioner),tipsDom.nextSibling);
  3054.                 }
  3055.                 let p = tipsDom.nextSibling.getBoundingClientRect();
  3056.                 let q = player.getBoundingClientRect();
  3057.                 let basePos = [+(p.left).toFixed(2), +(p.top).toFixed(2)];
  3058.                 let targetPos = [+(q.left + targetOffset.left).toFixed(2), +(q.top + targetOffset.top).toFixed(2)];
  3059.  
  3060.                 let tt=basePos.join(',')+','+targetPos.join(',')
  3061.  
  3062.                 if(tipsDom.__cache_dim__!=tt){
  3063.                     tipsDom.__cache_dim__=tt;
  3064.  
  3065.  
  3066.                     let y1 = targetPos[0]- basePos[0]
  3067.  
  3068.                     let y2 = targetPos[1]- basePos[1]
  3069.  
  3070.                     if($hs.isNum(y1) && $hs.isNum(y2)){
  3071.                         tipsDom.style.marginLeft = (y1) + 'px';
  3072.                         tipsDom.style.marginTop = (y2) + 'px';
  3073.                         return true;
  3074.                     }
  3075.  
  3076.                 }
  3077.  
  3078.                 tipsDom=null;
  3079.                 player=null;
  3080.  
  3081.             },
  3082.  
  3083.             playerTrigger: function(player, event) {
  3084.  
  3085.  
  3086.  
  3087.                 if (!player || !player.parentNode || !event) return
  3088.                 const pCode = event.code;
  3089.                 let keyAsm = (event.shiftKey ? SHIFT : 0) | ((event.ctrlKey || event.metaKey) ? CTRL : 0) | (event.altKey ? ALT : 0);
  3090.  
  3091.  
  3092.                 if (keyAsm == SHIFT && pCode == 'Backquote') {
  3093.                     $hs.enable = !$hs.enable;
  3094.                     $hs._tips(player, false);
  3095.                     if ($hs.enable) {
  3096.                         $hs._tips(player, '啟用h5Player插件')
  3097.                     } else {
  3098.                         $hs._tips(player, '禁用h5Player插件')
  3099.                     }
  3100.                     // 阻止事件冒泡
  3101.                     return TERMINATE
  3102.                 }
  3103.                 if (!$hs.enable) {
  3104.                     consoleLog('h5Player 已禁用~')
  3105.                     return false
  3106.                 }
  3107.  
  3108.  
  3109.                 if (!keyAsm && pCode == 'Enter') { //not NumberpadEnter
  3110.  
  3111.                     Promise.resolve(player).then((player) => {
  3112.                         $hs._actionBoxObtain(player);
  3113.                     }).then(() => {
  3114.                         $hs.callFullScreenBtn()
  3115.                     })
  3116.  
  3117.                     return TERMINATE
  3118.                 }
  3119.  
  3120.  
  3121.  
  3122.                 let vpid = player.getAttribute('_h5ppid') || null;
  3123.                 if (!vpid) return;
  3124.                 let playerConf = playerConfs[vpid]
  3125.                 if (!playerConf) return;
  3126.  
  3127.                 //shift + key
  3128.                 if (keyAsm == SHIFT) {
  3129.                     // 網頁FULLSCREEN
  3130.                     if (pCode === 'Enter') {
  3131.                         //$hs.callFullScreenBtn()
  3132.                         //return TERMINATE
  3133.                     } else if (pCode == 'KeyF') {
  3134.                         //change unsharpen filter
  3135.  
  3136.                         let resList = ["unsharpen3_05", "unsharpen3_10", "unsharpen5_05", "unsharpen5_10", "unsharpen9_05", "unsharpen9_10"]
  3137.                         let res = (prompt("Enter the unsharpen mask\n(" + resList.map(x => '"' + x + '"').join(', ') + ")", "unsharpen9_05") || "").toLowerCase();
  3138.                         if (resList.indexOf(res) < 0) res = ""
  3139.                         GM_setValue("unsharpen_mask", res)
  3140.                         for (const el of document.querySelectorAll('video[_h5p_uid_encrypted]')) {
  3141.                             if (el.style.filter == "" || el.style.filter) {
  3142.                                 let filterStr1 = el.style.filter.replace(/\s*url\(\"#_h5p_unsharpen[\d\_]+\"\)/, '');
  3143.                                 let filterStr2 = (res.length > 0 ? ' url("#_h5p_' + res + '")' : '')
  3144.                                 el.style.filter = filterStr1 + filterStr2;
  3145.                             }
  3146.                         }
  3147.                         return TERMINATE
  3148.  
  3149.                     }
  3150.                     // 進入或退出畫中畫模式
  3151.                     else if (pCode == 'KeyP') {
  3152.                         $hs.pictureInPicture(player)
  3153.  
  3154.                         return TERMINATE
  3155.                     } else if (pCode == 'KeyR') {
  3156.                         if (player._h5player_lastrecord_ !== null && (player._h5player_lastrecord_ >= 0 || player._h5player_lastrecord_ <= 0)) {
  3157.                             $hs.setPlayProgress(player, player._h5player_lastrecord_)
  3158.  
  3159.                             return TERMINATE
  3160.                         }
  3161.  
  3162.                     } else if (pCode == 'KeyO') {
  3163.                         let _debug_h5p_logging_ch = false;
  3164.                         try {
  3165.                             Store._setItem('_h5_player_sLogging_', 1 - Store._getItem('_h5_player_sLogging_'))
  3166.                             _debug_h5p_logging_ = +Store._getItem('_h5_player_sLogging_') > 0;
  3167.                             _debug_h5p_logging_ch = true;
  3168.                         } catch (e) {
  3169.  
  3170.                         }
  3171.                         consoleLogF('_debug_h5p_logging_', !!_debug_h5p_logging_, 'changed', _debug_h5p_logging_ch)
  3172.  
  3173.                         if (_debug_h5p_logging_ch) {
  3174.  
  3175.                             return TERMINATE
  3176.                         }
  3177.                     } else if (pCode == 'KeyT') {
  3178.                         if (/^blob/i.test(player.currentSrc)) {
  3179.                             alert(`The current video is ${player.currentSrc}\nSorry, it cannot be opened in PotPlayer.`);
  3180.                         } else {
  3181.                             let confirm_res = confirm(`The current video is ${player.currentSrc}\nDo you want to open it in PotPlayer?`);
  3182.                             if (confirm_res) window.open('potplayer://' + player.currentSrc, '_blank');
  3183.                         }
  3184.                         return TERMINATE
  3185.                     }
  3186.  
  3187.  
  3188.  
  3189.                     let videoScale = playerConf.vFactor;
  3190.  
  3191.                     function tipsForVideoScaling() {
  3192.  
  3193.                         playerConf.vFactor = +videoScale.toFixed(1);
  3194.  
  3195.                         playerConf.cssTransform();
  3196.                         let tipsMsg = `視頻縮放率：${ +(videoScale * 100).toFixed(2) }%`
  3197.                         if (playerConf.translate.x) {
  3198.                             tipsMsg += `，水平位移：${playerConf.translate.x}px`
  3199.                         }
  3200.                         if (playerConf.translate.y) {
  3201.                             tipsMsg += `，垂直位移：${playerConf.translate.y}px`
  3202.                         }
  3203.                         $hs.tips(false);
  3204.                         $hs.tips(tipsMsg)
  3205.  
  3206.  
  3207.                     }
  3208.  
  3209.                     // 視頻畫面縮放相關事件
  3210.  
  3211.                     switch (pCode) {
  3212.                         // shift+X：視頻縮小 -0.1
  3213.                         case 'KeyX':
  3214.                             videoScale -= 0.1
  3215.                             if (videoScale < 0.1) videoScale = 0.1;
  3216.                             tipsForVideoScaling();
  3217.                             return TERMINATE
  3218.                             break
  3219.                             // shift+C：視頻放大 +0.1
  3220.                         case 'KeyC':
  3221.                             videoScale += 0.1
  3222.                             if (videoScale > 16) videoScale = 16;
  3223.                             tipsForVideoScaling();
  3224.                             return TERMINATE
  3225.                             break
  3226.                             // shift+Z：視頻恢復正常大小
  3227.                         case 'KeyZ':
  3228.                             videoScale = 1.0
  3229.                             playerConf.translate.x = 0;
  3230.                             playerConf.translate.y = 0;
  3231.                             tipsForVideoScaling();
  3232.                             return TERMINATE
  3233.                             break
  3234.                         case 'ArrowRight':
  3235.                             playerConf.translate.x += 10
  3236.                             tipsForVideoScaling();
  3237.                             return TERMINATE
  3238.                             break
  3239.                         case 'ArrowLeft':
  3240.                             playerConf.translate.x -= 10
  3241.                             tipsForVideoScaling();
  3242.                             return TERMINATE
  3243.                             break
  3244.                         case 'ArrowUp':
  3245.                             playerConf.translate.y -= 10
  3246.                             tipsForVideoScaling();
  3247.                             return TERMINATE
  3248.                             break
  3249.                         case 'ArrowDown':
  3250.                             playerConf.translate.y += 10
  3251.                             tipsForVideoScaling();
  3252.                             return TERMINATE
  3253.                             break
  3254.  
  3255.                     }
  3256.  
  3257.                 }
  3258.                 // 防止其它無關組合鍵衝突
  3259.                 if (!keyAsm) {
  3260.                     let kControl = null
  3261.                     let newPBR, oldPBR, nv, numKey;
  3262.                     switch (pCode) {
  3263.                         // 方向鍵右→：快進3秒
  3264.                         case 'ArrowRight':
  3265.                             if (1) {
  3266.                                 let aCurrentTime = player.currentTime;
  3267.                                 window.requestAnimationFrame(() => {
  3268.                                     let diff = player.currentTime - aCurrentTime
  3269.                                     diff = Math.round(diff * 5) / 5;
  3270.                                     if (Math.abs(diff) < 0.8) {
  3271.                                         $hs.tuneCurrentTime(+$hs.skipStep);
  3272.                                     } else {
  3273.                                         $hs.tuneCurrentTimeTips(diff, true)
  3274.                                     }
  3275.                                 })
  3276.                                 //if(document.domain.indexOf('youtube.com')>=0){}else{
  3277.                                 //$hs.tuneCurrentTime($hs.skipStep);
  3278.                                 //return TERMINATE;
  3279.                                 //}
  3280.                             }
  3281.                             break;
  3282.                             // 方向鍵左←：後退3秒
  3283.                         case 'ArrowLeft':
  3284.  
  3285.                             if (1) {
  3286.                                 let aCurrentTime = player.currentTime;
  3287.                                 window.requestAnimationFrame(() => {
  3288.                                     let diff = player.currentTime - aCurrentTime
  3289.                                     diff = Math.round(diff * 5) / 5;
  3290.                                     if (Math.abs(diff) < 0.8) {
  3291.                                         $hs.tuneCurrentTime(-$hs.skipStep);
  3292.                                     } else {
  3293.                                         $hs.tuneCurrentTimeTips(diff, true)
  3294.                                     }
  3295.                                 })
  3296.                                 //if(document.domain.indexOf('youtube.com')>=0){}else{
  3297.                                 //
  3298.                                 //return TERMINATE;
  3299.                                 //}
  3300.                             }
  3301.                             break;
  3302.                             // 方向鍵上↑：音量升高 1%
  3303.                         case 'ArrowUp':
  3304.                             if ((player.muted && player.volume === 0) && player._volume > 0) {
  3305.  
  3306.                                 player.muted = false;
  3307.                                 player.volume = player._volume;
  3308.                             } else if (player.muted && (player.volume > 0 || !player._volume)) {
  3309.                                 player.muted = false;
  3310.                             }
  3311.                             $hs.tuneVolume(0.01);
  3312.                             return TERMINATE;
  3313.                             break;
  3314.                             // 方向鍵下↓：音量降低 1%
  3315.                         case 'ArrowDown':
  3316.  
  3317.                             if ((player.muted && player.volume === 0) && player._volume > 0) {
  3318.  
  3319.                                 player.muted = false;
  3320.                                 player.volume = player._volume;
  3321.                             } else if (player.muted && (player.volume > 0 || !player._volume)) {
  3322.                                 player.muted = false;
  3323.                             }
  3324.                             $hs.tuneVolume(-0.01);
  3325.                             return TERMINATE;
  3326.                             break;
  3327.                             // 空格鍵：暫停/播放
  3328.                         case 'Space':
  3329.                             $hs.switchPlayStatus();
  3330.                             return TERMINATE;
  3331.                             break;
  3332.                             // 按鍵X：減速播放 -0.1
  3333.                         case 'KeyX':
  3334.                             if (player.playbackRate > 0) {
  3335.                                 $hs.tips(false);
  3336.                                 let t=player.playbackRate - 0.1;
  3337.                                 if(t<0.1)t=0.1;
  3338.                                 $hs.setPlaybackRate(t, true);
  3339.                                 return TERMINATE
  3340.                             }
  3341.                             break;
  3342.                             // 按鍵C：加速播放 +0.1
  3343.                         case 'KeyC':
  3344.                             if (player.playbackRate < 16) {
  3345.                                 $hs.tips(false);
  3346.                                 $hs.setPlaybackRate(player.playbackRate + 0.1, true);
  3347.                                 return TERMINATE
  3348.                             }
  3349.  
  3350.                             break;
  3351.                             // 按鍵Z：正常速度播放
  3352.                         case 'KeyZ':
  3353.                             $hs.tips(false);
  3354.                             oldPBR = player.playbackRate;
  3355.                             if (oldPBR != 1.0) {
  3356.                                 player._playbackRate_z = oldPBR;
  3357.                                 newPBR = 1.0;
  3358.                             } else if (player._playbackRate_z != 1.0) {
  3359.                                 newPBR = player._playbackRate_z || 1.0;
  3360.                                 player._playbackRate_z = 1.0;
  3361.                             } else {
  3362.                                 newPBR = 1.0
  3363.                                 player._playbackRate_z = 1.0;
  3364.                             }
  3365.                             $hs.setPlaybackRate(newPBR, 1)
  3366.                             return TERMINATE
  3367.                             break;
  3368.                             // 按鍵F：下一幀
  3369.                         case 'KeyF':
  3370.                             if (window.location.hostname === 'www.netflix.com') return /* netflix 的F鍵是FULLSCREEN的意思 */
  3371.                             $hs.tips(false);
  3372.                             if (!player.paused) player.pause()
  3373.                             player.currentTime += +(1 / playerConf.fps)
  3374.                             $hs.tips('Jump to: Next frame')
  3375.                             return TERMINATE
  3376.                             break;
  3377.                             // 按鍵D：上一幀
  3378.                         case 'KeyD':
  3379.                             $hs.tips(false);
  3380.                             if (!player.paused) player.pause()
  3381.                             player.currentTime -= +(1 / playerConf.fps)
  3382.                             $hs.tips('Jump to: Previous frame')
  3383.                             return TERMINATE
  3384.                             break;
  3385.                             // 按鍵E：亮度增加%
  3386.                         case 'KeyE':
  3387.                             $hs.tips(false);
  3388.                             nv = playerConf.setFilter('brightness', (v) => v + 0.1);
  3389.                             $hs.tips('Brightness: ' + dround(nv * 100) + '%')
  3390.                             return TERMINATE
  3391.                             break;
  3392.                             // 按鍵W：亮度減少%
  3393.                         case 'KeyW':
  3394.                             $hs.tips(false);
  3395.                             nv = playerConf.setFilter('brightness', (v) => v > 0.1 ? v - 0.1 : 0);
  3396.                             $hs.tips('Brightness: ' + dround(nv * 100) + '%')
  3397.                             return TERMINATE
  3398.                             break;
  3399.                             // 按鍵T：對比度增加%
  3400.                         case 'KeyT':
  3401.                             $hs.tips(false);
  3402.                             nv = playerConf.setFilter('contrast', (v) => v + 0.1);
  3403.                             $hs.tips('Contrast: ' + dround(nv * 100) + '%')
  3404.                             return TERMINATE
  3405.                             break;
  3406.                             // 按鍵R：對比度減少%
  3407.                         case 'KeyR':
  3408.                             $hs.tips(false);
  3409.                             nv = playerConf.setFilter('contrast', (v) => v > 0.1 ? v - 0.1 : 0);
  3410.                             $hs.tips('Contrast: ' + dround(nv * 100) + '%')
  3411.                             return TERMINATE
  3412.                             break;
  3413.                             // 按鍵U：飽和度增加%
  3414.                         case 'KeyU':
  3415.                             $hs.tips(false);
  3416.                             nv = playerConf.setFilter('saturate', (v) => v + 0.1);
  3417.                             $hs.tips('Saturate: ' + dround(nv * 100) + '%')
  3418.                             return TERMINATE
  3419.                             break;
  3420.                             // 按鍵Y：飽和度減少%
  3421.                         case 'KeyY':
  3422.                             $hs.tips(false);
  3423.                             nv = playerConf.setFilter('saturate', (v) => v > 0.1 ? v - 0.1 : 0);
  3424.                             $hs.tips('Saturate: ' + dround(nv * 100) + '%')
  3425.                             return TERMINATE
  3426.                             break;
  3427.                             // 按鍵O：色相增加 1 度
  3428.                         case 'KeyO':
  3429.                             $hs.tips(false);
  3430.                             nv = playerConf.setFilter('hue-rotate', (v) => v + 1);
  3431.                             $hs.tips('Hue: ' + nv + ' deg')
  3432.                             return TERMINATE
  3433.                             break;
  3434.                             // 按鍵I：色相減少 1 度
  3435.                         case 'KeyI':
  3436.                             $hs.tips(false);
  3437.                             nv = playerConf.setFilter('hue-rotate', (v) => v - 1);
  3438.                             $hs.tips('Hue: ' + nv + ' deg')
  3439.                             return TERMINATE
  3440.                             break;
  3441.                             // 按鍵K：模糊增加 0.1 px
  3442.                         case 'KeyK':
  3443.                             $hs.tips(false);
  3444.                             nv = playerConf.setFilter('blur', (v) => v + 0.1);
  3445.                             $hs.tips('Blur: ' + nv + ' px')
  3446.                             return TERMINATE
  3447.                             break;
  3448.                             // 按鍵J：模糊減少 0.1 px
  3449.                         case 'KeyJ':
  3450.                             $hs.tips(false);
  3451.                             nv = playerConf.setFilter('blur', (v) => v > 0.1 ? v - 0.1 : 0);
  3452.                             $hs.tips('Blur: ' + nv + ' px')
  3453.                             return TERMINATE
  3454.                             break;
  3455.                             // 按鍵Q：圖像復位
  3456.                         case 'KeyQ':
  3457.                             $hs.tips(false);
  3458.                             playerConf.filterReset();
  3459.                             $hs.tips('Video Filter Reset')
  3460.                             return TERMINATE
  3461.                             break;
  3462.                             // 按鍵S：畫面旋轉 90 度
  3463.                         case 'KeyS':
  3464.                             $hs.tips(false);
  3465.                             playerConf.rotate += 90
  3466.                             if (playerConf.rotate % 360 === 0) playerConf.rotate = 0;
  3467.                             if (!playerConf.videoHeight || !playerConf.videoWidth) {
  3468.                                 playerConf.videoWidth = playerConf.domElement.videoWidth;
  3469.                                 playerConf.videoHeight = playerConf.domElement.videoHeight;
  3470.                             }
  3471.                             if (playerConf.videoWidth > 0 && playerConf.videoHeight > 0) {
  3472.  
  3473.  
  3474.                                 if ((playerConf.rotate % 180) == 90) {
  3475.                                     playerConf.mFactor = playerConf.videoHeight / playerConf.videoWidth;
  3476.                                 } else {
  3477.                                     playerConf.mFactor = 1.0;
  3478.                                 }
  3479.  
  3480.  
  3481.                                 playerConf.cssTransform();
  3482.  
  3483.                                 $hs.tips('Rotation：' + playerConf.rotate + ' deg')
  3484.  
  3485.                             }
  3486.  
  3487.                             return TERMINATE
  3488.                             break;
  3489.                             // 按鍵迴車，進入FULLSCREEN
  3490.                         case 'Enter':
  3491.                             //t.callFullScreenBtn();
  3492.                             break;
  3493.                         case 'KeyN':
  3494.                             $hs.pictureInPicture(player);
  3495.                             return TERMINATE
  3496.                             break;
  3497.                         case 'KeyM':
  3498.                             //console.log('m!', player.volume,player._volume)
  3499.  
  3500.                             if (player.volume >= 0) {
  3501.  
  3502.                                 if (!player.volume || player.muted) {
  3503.  
  3504.                                     let newVol = player.volume || player._volume || 0.5;
  3505.                                     if (player.volume !== newVol) {
  3506.                                         player.volume = newVol;
  3507.                                     }
  3508.                                     player.muted = false;
  3509.                                     $hs.tips(false);
  3510.                                     $hs.tips('Mute: Off', undefined);
  3511.  
  3512.                                 } else {
  3513.  
  3514.                                     player._volume = player.volume;
  3515.                                     player._volume_p = player.volume;
  3516.                                     //player.volume = 0;
  3517.                                     player.muted = true;
  3518.                                     $hs.tips(false);
  3519.                                     $hs.tips('Mute: On', undefined);
  3520.  
  3521.                                 }
  3522.  
  3523.                             }
  3524.  
  3525.                             return TERMINATE
  3526.                             break;
  3527.                         default:
  3528.                             // 按1-4設置播放速度 49-52;97-100
  3529.                             numKey = +(event.key)
  3530.  
  3531.                             if (numKey >= 1 && numKey <= 4) {
  3532.                                 $hs.tips(false);
  3533.                                 $hs.setPlaybackRate(numKey, 1)
  3534.                                 return TERMINATE
  3535.                             }
  3536.                     }
  3537.  
  3538.                 }
  3539.             },
  3540.  
  3541.             handlerPlayerLockedMouseMove: function(e) {
  3542.                 //console.log(4545)
  3543.  
  3544.                 if(!$hs.mointoringVideo) return;
  3545.  
  3546.                 const player = $vQuery.player($hs.mointoringVideo);
  3547.  
  3548.                 if (!player) return;
  3549.  
  3550.  
  3551.                 $hs.mouseMoveCount += Math.sqrt(e.movementX * e.movementX + e.movementY * e.movementY);
  3552.  
  3553.                 delayCall('$$VideoClearMove', function() {
  3554.                     $hs.mouseMoveCount = $hs.mouseMoveCount * 0.4;
  3555.                 }, 100)
  3556.  
  3557.                 delayCall('$$VideoClearMove2', function() {
  3558.                     $hs.mouseMoveCount = $hs.mouseMoveCount * 0.1;
  3559.                 }, 400)
  3560.  
  3561.                 if ($hs.mouseMoveCount > player.mouseMoveMax) {
  3562.                     $hs.hcMouseShowWithMonitoring(player)
  3563.                 }
  3564.  
  3565.             },
  3566.  
  3567.             _hcMouseHidePre: function(player) {
  3568.                 if (player.paused === true) {
  3569.                     $hs.hcShowMouseAndRemoveMointoring(player);
  3570.                     return;
  3571.                 }
  3572.                 if ($hs.mouseEnteredElement) {
  3573.                     const elm = $hs.mouseEnteredElement;
  3574.                     switch (getComputedStyle(elm).getPropertyValue('cursor')) {
  3575.                         case 'grab':
  3576.                         case 'pointer':
  3577.                             return;
  3578.                     }
  3579.                     if (elm.hasAttribute('alt')) return;
  3580.                     if (elm.getAttribute('aria-hidden') == 'true') return;
  3581.                 }
  3582.                 Promise.resolve().then(() => {
  3583.                     if (!$hs.mouseDownAt) player.ownerDocument.querySelector('html').setAttribute('_h5p_hide_cursor', '');
  3584.                     player = null;
  3585.                 })
  3586.                 return true;
  3587.             },
  3588.  
  3589.             hcStartMointoring:(player)=>{
  3590.  
  3591.  
  3592.                 $hs.mouseMoveCount = 0;
  3593.  
  3594.                 Promise.resolve($hs._hcMouseHidePre(player)).then(r => {
  3595.                     if (r) {
  3596.  
  3597.                         if($hs.mointoringVideo===false) player.ownerDocument.addEventListener('mousemove', $hs.handlerPlayerLockedMouseMove, $mb.eh_capture_passive())
  3598.                         $hs.mointoringVideo = player.getAttribute('_h5ppid');
  3599.  
  3600.                     }
  3601.  
  3602.                     player = null;
  3603.  
  3604.                 })
  3605.  
  3606.             },
  3607.  
  3608.             hcMouseHideAndStartMointoring: function(player) {
  3609.  
  3610.                 //console.log(554, 'hcMouseHideAndStartMointoring')
  3611.                 delayCall('$$hcMouseMove')
  3612.  
  3613.                 $hs.hcStartMointoring(player)
  3614.  
  3615.  
  3616.             },
  3617.  
  3618.             hcDelayMouseHideAndStartMointoring: function(player) {
  3619.                 //console.log(554, 'hcDelayMouseHideAndStartMointoring')
  3620.                 delayCall('$$hcMouseMove', ()=> $hs.hcStartMointoring(player), 1240)
  3621.             },
  3622.  
  3623.             hcMouseShowWithMonitoring: function(player) {
  3624.                 //console.log(554, 'hcMouseShowWithMonitoring')
  3625.                 delayCall('$$hcMouseMove', function() {
  3626.                     $hs.mouseMoveCount = 0;
  3627.                     $hs._hcMouseHidePre(player)
  3628.                 }, 1240)
  3629.                 $hs.mouseMoveCount = 0;
  3630.                 player.ownerDocument.querySelector('html').removeAttribute('_h5p_hide_cursor')
  3631.             },
  3632.  
  3633.             hcShowMouseAndRemoveMointoring: function(player) {
  3634.                 //console.log(554, 'hcShowMouseAndRemoveMointoring')
  3635.                 delayCall('$$hcMouseMove')
  3636.                 if($hs.mointoringVideo) $hs.mointoringVideo = null;
  3637.                 $hs.mouseMoveCount = 0;
  3638.                 player.ownerDocument.querySelector('html').removeAttribute('_h5p_hide_cursor')
  3639.  
  3640.             },
  3641.  
  3642.  
  3643.  
  3644.             handlerElementFocus: function(event) {
  3645.  
  3646.                 function notAtVideo() {
  3647.                     if ($hs.focusHookVId) $hs.focusHookVId = ''
  3648.                 }
  3649.  
  3650.                 const hookVideo = $hs.focusHookVId ? $vQuery.player($hs.focusHookVId) : null
  3651.  
  3652.                 if (hookVideo && (event.target == hookVideo || event.target.contains(hookVideo))) {} else {
  3653.                     notAtVideo();
  3654.                 }
  3655.  
  3656.             },
  3657.  
  3658.             handlerFullscreenChanged: function(event) {
  3659.  
  3660.  
  3661.                 let videoElm = null,
  3662.                     videosQuery = null;
  3663.                 if (event && event.target) {
  3664.                     if (event.target.nodeName == "VIDEO") videoElm = event.target;
  3665.                     else if (videosQuery = event.target.querySelectorAll("VIDEO")) {
  3666.                         if (videosQuery.length === 1) videoElm = videosQuery[0]
  3667.                     }
  3668.                 }
  3669.  
  3670.                 if (videoElm) {
  3671.                     const player = videoElm;
  3672.                     const vpid = player.getAttribute('_h5ppid')
  3673.                     event.target.setAttribute('_h5p_fsElm_', vpid)
  3674.  
  3675.                     function hookTheActionedVideo() {
  3676.                         $hs.focusHookVId = vpid
  3677.                     }
  3678.                     hookTheActionedVideo();
  3679.                     window.setTimeout(hookTheActionedVideo, 300)
  3680.                     window.setTimeout(() => {
  3681.                         const chFull = $hs.toolCheckFullScreen(player.ownerDocument);
  3682.                         if (chFull) {
  3683.                             $hs.hcMouseHideAndStartMointoring(player);
  3684.                         } else {
  3685.                             $hs.hcShowMouseAndRemoveMointoring(player);
  3686.                         }
  3687.                     });
  3688.  
  3689.                     const playerConf = $hs.getPlayerConf(videoElm)
  3690.                     if (playerConf) {
  3691.                         delayCall("$$actionBoxFullscreen", function() {
  3692.                             playerConf.domActive &= ~DOM_ACTIVE_FULLSCREEN;
  3693.                         }, 137)
  3694.                         playerConf.domActive |= DOM_ACTIVE_FULLSCREEN;
  3695.                     }
  3696.  
  3697.                     $hs.swtichPlayerInstance()
  3698.  
  3699.                 } else {
  3700.                     $hs.focusHookVId = ''
  3701.                 }
  3702.             },
  3703.  
  3704.  
  3705.             isEditableElement:function(elm){
  3706.  
  3707.                 if(elm&& elm.nodeType==1 ){
  3708.  
  3709.                     return elm.nodeName=="TEXTAREA" || elm.nodeName=="INPUT" || elm.hasAttribute('contenteditable');
  3710.                 }
  3711.                 return false
  3712.             },
  3713.  
  3714.             /* 按鍵響應方法 */
  3715.             handlerRootKeyDownEvent: function(event) {
  3716.  
  3717.                 if ($hs.intVideoInitCount > 0) {} else {
  3718.                     // return notAtVideo();
  3719.                 }
  3720.  
  3721.                 // $hs.lastKeyDown = event.timeStamp
  3722.  
  3723.                 // DOM Standard - either .key or .code
  3724.                 // Here we adopt .code (physical layout)
  3725.  
  3726.                 let pCode = event.code;
  3727.                 if (typeof pCode != 'string') return;
  3728.                 let keyAsm = (event.shiftKey ? SHIFT : 0) | ((event.ctrlKey || event.metaKey) ? CTRL : 0) | (event.altKey ? ALT : 0);
  3729.                 let hookVideo = null;
  3730.  
  3731.                 if($hs.isEditableElement(document.activeElement)){
  3732.                     $hs.focusHookVId=null
  3733.                 } else if (document.fullscreenElement) {
  3734.                     let playingVideo = document.fullscreenElement.querySelector('VIDEO[_h5ppid]');
  3735.                     if(!playingVideo) return;
  3736.                     if (!keyAsm && pCode == 'Escape') {
  3737.                         window.setTimeout(() => {
  3738.                             if (document.fullscreenElement) {
  3739.                                 document.exitFullscreen();
  3740.                             }
  3741.                         }, 270);
  3742.                         return;
  3743.                     }
  3744.                     $hs.focusHookVId = playingVideo.getAttribute('_h5ppid');
  3745.                 }else{
  3746.                     const actionBoxRelation = $hs.getActionBoxRelationFromDOM(event.target)
  3747.                     if (actionBoxRelation) {
  3748.                         $hs.focusHookVId = actionBoxRelation.player.getAttribute('_h5ppid');
  3749.                     } else if ($hs.enteredActionBoxRelation && $hs.enteredActionBoxRelation.pContainer ){
  3750.                         $hs.focusHookVId=$hs.enteredActionBoxRelation.player.getAttribute('_h5ppid');
  3751.                     }
  3752.                 }
  3753.  
  3754.                 hookVideo = $hs.focusHookVId ? $vQuery.player($hs.focusHookVId) : null
  3755.  
  3756.                 if (!hookVideo || !hookVideo.parentNode) return; // no video tag
  3757.  
  3758.                 let videoElm = hookVideo
  3759.  
  3760.                 const playerConf = $hs.getPlayerConf(videoElm)
  3761.                 if (playerConf) {
  3762.                     delayCall("$$actionBoxKeyDown", function() {
  3763.                         playerConf.domActive &= ~DOM_ACTIVE_KEY_DOWN;
  3764.                     }, 137)
  3765.                     playerConf.domActive |= DOM_ACTIVE_KEY_DOWN;
  3766.                 }
  3767.  
  3768.                 $hs.swtichPlayerInstance()
  3769.  
  3770.                 let player = hookVideo;
  3771.  
  3772.                 let res = $hs.playerTrigger(player, event)
  3773.                 if (res == TERMINATE) {
  3774.                     event.stopPropagation()
  3775.                     event.preventDefault()
  3776.                     return false
  3777.                 }
  3778.  
  3779.             },
  3780.             /* 設置播放進度 */
  3781.             setPlayProgress: function(player, curTime) {
  3782.                 if (!player || !player.parentNode) return
  3783.                 if (!curTime || Number.isNaN(curTime)) return
  3784.                 player.currentTime = curTime
  3785.                 if (curTime > 3) {
  3786.                     $hs.tips(false);
  3787.                     $hs.tips(`Playback Jumps to ${$hs.toolFormatCT(curTime)}`)
  3788.                     if (player.paused) player.play();
  3789.                 }
  3790.             }
  3791.         }
  3792.  
  3793.         function makeFilter(arr, k) {
  3794.             let res = ""
  3795.             for (const e of arr) {
  3796.                 for (const d of e) {
  3797.                     res += " " + (1.0 * d * k).toFixed(9)
  3798.                 }
  3799.             }
  3800.             return res.trim()
  3801.         }
  3802.  
  3803.         function _add_filter(rootElm) {
  3804.             let rootView = null;
  3805.             if (rootElm && rootElm.nodeType > 0) {
  3806.                 while (rootElm.parentNode && rootElm.parentNode.nodeType === 1) rootElm = rootElm.parentNode;
  3807.                 rootView = rootElm.querySelector('body') || rootElm;
  3808.             } else {
  3809.                 return;
  3810.             }
  3811.  
  3812.             if (rootView && rootView.querySelector && !rootView.querySelector('#_h5player_section_')) {
  3813.  
  3814.                 let svgFilterElm = document.createElement('section')
  3815.                 svgFilterElm.style.position = 'fixed';
  3816.                 svgFilterElm.style.left = '-999px';
  3817.                 svgFilterElm.style.width = '1px';
  3818.                 svgFilterElm.style.top = '-999px';
  3819.                 svgFilterElm.style.height = '1px';
  3820.                 svgFilterElm.id = '_h5player_section_'
  3821.                 let svgXML = `
  3822.             <svg id='_h5p_image' version="1.1" xmlns="http://www.w3.org/2000/svg">
  3823.             <defs>
  3824.             <filter id="_h5p_sharpen1">
  3825.             <feConvolveMatrix filterRes="100 100" style="color-interpolation-filters:sRGB" order="3" kernelMatrix="` + `
  3826.             -0.3 -0.3 -0.3
  3827.             -0.3 3.4 -0.3
  3828.             -0.3 -0.3 -0.3`.replace(/[\n\r]+/g, '  ').trim() + `"  preserveAlpha="true"/>
  3829.             </filter>
  3830.             <filter id="_h5p_unsharpen1">
  3831.             <feConvolveMatrix style="color-interpolation-filters:sRGB;color-interpolation: sRGB;" order="5" kernelMatrix="` +
  3832.                     makeFilter([
  3833.                         [1, 4, 6, 4, 1],
  3834.                         [4, 16, 24, 16, 4],
  3835.                         [6, 24, -476, 24, 6],
  3836.                         [4, 16, 24, 16, 4],
  3837.                         [1, 4, 6, 4, 1]
  3838.                     ], -1 / 256) + `"  preserveAlpha="false"/>
  3839.             </filter>
  3840.             <filter id="_h5p_unsharpen3_05">
  3841.             <feConvolveMatrix style="color-interpolation-filters:sRGB;color-interpolation: sRGB;" order="3" kernelMatrix="` +
  3842.                     makeFilter(
  3843.                         [
  3844.                             [0.025, 0.05, 0.025],
  3845.                             [0.05, -1.1, 0.05],
  3846.                             [0.025, 0.05, 0.025]
  3847.                         ], -1 / .8) + `"  preserveAlpha="false"/>
  3848.             </filter>
  3849.             <filter id="_h5p_unsharpen3_10">
  3850.             <feConvolveMatrix style="color-interpolation-filters:sRGB;color-interpolation: sRGB;" order="3" kernelMatrix="` +
  3851.                     makeFilter(
  3852.                         [
  3853.                             [0.05, 0.1, 0.05],
  3854.                             [0.1, -1.4, 0.1],
  3855.                             [0.05, 0.1, 0.05]
  3856.                         ], -1 / .8) + `"  preserveAlpha="false"/>
  3857.             </filter>
  3858.             <filter id="_h5p_unsharpen5_05">
  3859.             <feConvolveMatrix style="color-interpolation-filters:sRGB;color-interpolation: sRGB;" order="5" kernelMatrix="` +
  3860.                     makeFilter(
  3861.                         [
  3862.                             [0.025, 0.1, 0.15, 0.1, 0.025],
  3863.                             [0.1, 0.4, 0.6, 0.4, 0.1],
  3864.                             [0.15, 0.6, -18.3, 0.6, 0.15],
  3865.                             [0.1, 0.4, 0.6, 0.4, 0.1],
  3866.                             [0.025, 0.1, 0.15, 0.1, 0.025]
  3867.                         ], -1 / 12.8) + `"  preserveAlpha="false"/>
  3868.             </filter>
  3869.             <filter id="_h5p_unsharpen5_10">
  3870.             <feConvolveMatrix style="color-interpolation-filters:sRGB;color-interpolation: sRGB;" order="5" kernelMatrix="` +
  3871.                     makeFilter(
  3872.                         [
  3873.                             [0.05, 0.2, 0.3, 0.2, 0.05],
  3874.                             [0.2, 0.8, 1.2, 0.8, 0.2],
  3875.                             [0.3, 1.2, -23.8, 1.2, 0.3],
  3876.                             [0.2, 0.8, 1.2, 0.8, 0.2],
  3877.                             [0.05, 0.2, 0.3, 0.2, 0.05]
  3878.                         ], -1 / 12.8) + `"  preserveAlpha="false"/>
  3879.             </filter>
  3880.             <filter id="_h5p_unsharpen9_05">
  3881.             <feConvolveMatrix style="color-interpolation-filters:sRGB;color-interpolation: sRGB;" order="9" kernelMatrix="` +
  3882.                     makeFilter(
  3883.                         [
  3884.                             [0.025, 0.2, 0.7, 1.4, 1.75, 1.4, 0.7, 0.2, 0.025],
  3885.                             [0.2, 1.6, 5.6, 11.2, 14, 11.2, 5.6, 1.6, 0.2],
  3886.                             [0.7, 5.6, 19.6, 39.2, 49, 39.2, 19.6, 5.6, 0.7],
  3887.                             [1.4, 11.2, 39.2, 78.4, 98, 78.4, 39.2, 11.2, 1.4],
  3888.                             [1.75, 14, 49, 98, -4792.7, 98, 49, 14, 1.75],
  3889.                             [1.4, 11.2, 39.2, 78.4, 98, 78.4, 39.2, 11.2, 1.4],
  3890.                             [0.7, 5.6, 19.6, 39.2, 49, 39.2, 19.6, 5.6, 0.7],
  3891.                             [0.2, 1.6, 5.6, 11.2, 14, 11.2, 5.6, 1.6, 0.2],
  3892.                             [0.025, 0.2, 0.7, 1.4, 1.75, 1.4, 0.7, 0.2, 0.025]
  3893.                         ], -1 / 3276.8) + `"  preserveAlpha="false"/>
  3894.             </filter>
  3895.             <filter id="_h5p_unsharpen9_10">
  3896.             <feConvolveMatrix style="color-interpolation-filters:sRGB;color-interpolation: sRGB;" order="9" kernelMatrix="` +
  3897.                     makeFilter(
  3898.                         [
  3899.                             [0.05, 0.4, 1.4, 2.8, 3.5, 2.8, 1.4, 0.4, 0.05],
  3900.                             [0.4, 3.2, 11.2, 22.4, 28, 22.4, 11.2, 3.2, 0.4],
  3901.                             [1.4, 11.2, 39.2, 78.4, 98, 78.4, 39.2, 11.2, 1.4],
  3902.                             [2.8, 22.4, 78.4, 156.8, 196, 156.8, 78.4, 22.4, 2.8],
  3903.                             [3.5, 28, 98, 196, -6308.6, 196, 98, 28, 3.5],
  3904.                             [2.8, 22.4, 78.4, 156.8, 196, 156.8, 78.4, 22.4, 2.8],
  3905.                             [1.4, 11.2, 39.2, 78.4, 98, 78.4, 39.2, 11.2, 1.4],
  3906.                             [0.4, 3.2, 11.2, 22.4, 28, 22.4, 11.2, 3.2, 0.4],
  3907.                             [0.05, 0.4, 1.4, 2.8, 3.5, 2.8, 1.4, 0.4, 0.05]
  3908.                         ], -1 / 3276.8) + `"  preserveAlpha="false"/>
  3909.                 </filter>
  3910.                 <filter id="_h5p_grey1">
  3911.                 <feColorMatrix values="0.3333 0.3333 0.3333 0 0
  3912.                 0.3333 0.3333 0.3333 0 0
  3913.                 0.3333 0.3333 0.3333 0 0
  3914.                 0      0      0      1 0"/>
  3915.                 <feColorMatrix type="saturate" values="0" />
  3916.                 </filter>
  3917.                 </defs>
  3918.                 </svg>
  3919.                 `;
  3920.  
  3921.                 svgFilterElm.innerHTML = svgXML.replace(/[\r\n\s]+/g, ' ').trim();
  3922.  
  3923.                 rootView.appendChild(svgFilterElm);
  3924.             }
  3925.  
  3926.         }
  3927.  
  3928.         /**
  3929.          * 某些網頁用了attachShadow closed mode，需要open才能獲取video標籤，例如百度雲盤
  3930.          * 解決參考：
  3931.          * https://developers.google.com/web/fundamentals/web-components/shadowdom?hl=zh-cn#closed
  3932.          * https://stackoverflow.com/questions/54954383/override-element-prototype-attachshadow-using-chrome-extension
  3933.          */
  3934.  
  3935.         const initForShadowRoot = async (shadowRoot) => {
  3936.             try {
  3937.                 if (shadowRoot && shadowRoot.nodeType > 0 && shadowRoot.mode == 'open' && 'querySelectorAll' in shadowRoot) {
  3938.                     if (!shadowRoot.host.hasAttribute('_h5p_shadowroot_')) {
  3939.                         shadowRoot.host.setAttribute('_h5p_shadowroot_', '')
  3940.  
  3941.                         $hs.bindDocEvents(shadowRoot);
  3942.                         captureVideoEvents(shadowRoot);
  3943.  
  3944.                     }
  3945.                 }
  3946.             } catch (e) {
  3947.                 console.log('h5Player: initForShadowRoot failed')
  3948.             }
  3949.         }
  3950.  
  3951.         function hackAttachShadow() { // attachShadow - DOM Standard
  3952.  
  3953.             let _prototype_ = window && window.HTMLElement ? window.HTMLElement.prototype : null;
  3954.             if (_prototype_ && typeof _prototype_.attachShadow == 'function') {
  3955.  
  3956.                 let _attachShadow = _prototype_.attachShadow
  3957.  
  3958.                 hackAttachShadow = null
  3959.                 _prototype_.attachShadow = function() {
  3960.                     let arg = [...arguments];
  3961.                     if (arg[0] && arg[0].mode) arg[0].mode = 'open';
  3962.                     let shadowRoot = _attachShadow.apply(this, arg);
  3963.                     initForShadowRoot(shadowRoot);
  3964.                     return shadowRoot
  3965.                 };
  3966.  
  3967.                 _prototype_.attachShadow.toString = () => _attachShadow.toString();
  3968.  
  3969.             }
  3970.  
  3971.         }
  3972.  
  3973.         function hackCreateShadowRoot() { // createShadowRoot - Deprecated
  3974.  
  3975.             let _prototype_ = window && window.HTMLElement ? window.HTMLElement.prototype : null;
  3976.             if (_prototype_ && typeof _prototype_.createShadowRoot == 'function') {
  3977.  
  3978.                 let _createShadowRoot = _prototype_.createShadowRoot;
  3979.  
  3980.                 hackCreateShadowRoot = null
  3981.                 _prototype_.createShadowRoot = function() {
  3982.                     const shadowRoot = _createShadowRoot.apply(this, arguments);
  3983.                     initForShadowRoot(shadowRoot);
  3984.                     return shadowRoot;
  3985.                 };
  3986.                 _prototype_.createShadowRoot.toString = () => _createShadowRoot.toString();
  3987.  
  3988.             }
  3989.         }
  3990.  
  3991.  
  3992.  
  3993.  
  3994.         /* 事件偵聽hack */
  3995.         function hackEventListener() {
  3996.             if (!window.Node) return;
  3997.             const _prototype = window.Node.prototype;
  3998.             let _addEventListener = _prototype.addEventListener;
  3999.             let _removeEventListener = _prototype.removeEventListener;
  4000.             if (typeof _addEventListener == 'function' && typeof _removeEventListener == 'function') {} else return;
  4001.             hackEventListener = null;
  4002.  
  4003.  
  4004.  
  4005.             let hackedEvtCount = 0;
  4006.  
  4007.             const options_passive_capture = {
  4008.                 passive: true,
  4009.                 capture: true
  4010.             }
  4011.             const options_passive_bubble = {
  4012.                 passive: true,
  4013.                 capture: false
  4014.             }
  4015.  
  4016.             let phListeners = Promise.resolve();
  4017.  
  4018.             let phActioners = Promise.resolve();
  4019.             let phActionersCount = 0;
  4020.  
  4021.  
  4022.  
  4023.             _prototype.addEventListener = function addEventListener() {
  4024.                 //console.log(3321,arguments[0])
  4025.                 const args = arguments
  4026.                 const type = args[0]
  4027.                 const listener = args[1]
  4028.  
  4029.                 if (!(this instanceof Node) || typeof type != 'string' || typeof listener != 'function') {
  4030.                     // if (!this || !(this instanceof EventTarget) || typeof type != 'string' || typeof listener != 'function') {
  4031.                     return _addEventListener.apply(this, args)
  4032.                     //unknown bug?
  4033.                 }
  4034.  
  4035.                 let bClickAction = false;
  4036.                 switch (type) {
  4037.                     case 'load':
  4038.                     case 'beforeunload':
  4039.                     case 'DOMContentLoaded':
  4040.                         return _addEventListener.apply(this, args);
  4041.                         break;
  4042.                     case 'touchstart':
  4043.                     case 'touchmove':
  4044.                     case 'wheel':
  4045.                     case 'mousewheel':
  4046.                     case 'timeupdate':
  4047.                         if ($mb.stable_isSupportPassiveEventListener()) {
  4048.                             if (!(args[2] && typeof args[2] == 'object')) {
  4049.                                 const fs = (listener + "");
  4050.                                 if (fs.indexOf('{ [native code] }') < 0 && fs.indexOf('.preventDefault()') < 0) {
  4051.                                     //make default passive if not set
  4052.                                     const options = args[2] === true ? options_passive_capture : options_passive_bubble
  4053.                                     args[2] = options
  4054.                                     if (args.length < 3) args.length = 3;
  4055.                                 }
  4056.                             }
  4057.                             if (args[2] && args[2].passive === true) {
  4058.                                 const nType = `__nListener|${type}__`;
  4059.                                 const nListener = listener[nType] || function() {
  4060.                                     let _listener = listener;
  4061.                                     let _this = this;
  4062.                                     let _arguments = arguments;
  4063.                                     let calling = () => {
  4064.                                         phActioners = phActioners.then(() => {
  4065.                                             _listener.apply(_this, _arguments);
  4066.                                             phActionersCount--;
  4067.                                             _listener = null;
  4068.                                             _this = null;
  4069.                                             _arguments = null;
  4070.                                             calling = null;
  4071.                                         })
  4072.                                     }
  4073.                                     Promise.resolve().then(() => {
  4074.                                         if (phActionersCount === 0) {
  4075.                                             phActionersCount++
  4076.                                             window.requestAnimationFrame(calling)
  4077.                                         } else {
  4078.                                             phActionersCount++
  4079.                                             calling();
  4080.                                         }
  4081.                                     })
  4082.                                 };
  4083.                                 listener[nType] = nListener;
  4084.                                 args[1] = nListener;
  4085.                                 args[2].passive = true;
  4086.                                 args[2] = args[2];
  4087.                             }
  4088.                         }
  4089.                         break;
  4090.                     case 'mouseout':
  4091.                     case 'mouseover':
  4092.                     case 'focusin':
  4093.                     case 'focusout':
  4094.                     case 'mouseenter':
  4095.                     case 'mouseleave':
  4096.                     case 'mousemove':
  4097.                         /*if (this.nodeType === 1 && this.nodeName != "BODY" && this.nodeName != "HTML") {
  4098.                             const nType = `__nListener|${type}__`
  4099.                             const nListener = listener[nType] || function() {
  4100.                                 window.requestAnimationFrame(() => listener.apply(this, arguments))
  4101.                             }
  4102.                             listener[nType] = nListener;
  4103.                             args[1] = nListener;
  4104.                         }*/
  4105.                         break;
  4106.                     case 'click':
  4107.                     case 'mousedown':
  4108.                     case 'mouseup':
  4109.                         bClickAction = true;
  4110.                         break;
  4111.                     default:
  4112.                         return _addEventListener.apply(this, args);
  4113.                 }
  4114.  
  4115.  
  4116.                 if (bClickAction) {
  4117.  
  4118.  
  4119.                     let res;
  4120.                     res = _addEventListener.apply(this, args)
  4121.  
  4122.                     phListeners = phListeners.then(() => {
  4123.  
  4124.                         let listeners = wmListeners.get(this);
  4125.                         if (!listeners) wmListeners.set(this, listeners = {});
  4126.  
  4127.                         let lh = new ListenerHandle(args[1], args[2])
  4128.  
  4129.                         listeners[type] = listeners[type] || new Listeners()
  4130.  
  4131.                         listeners[type].add(lh)
  4132.                         listeners[type]._count++;
  4133.  
  4134.                     })
  4135.  
  4136.                     return res
  4137.  
  4138.  
  4139.                 } else if (args[2] && args[2].passive) {
  4140.  
  4141.                     const nType = `__nListener|${type}__`
  4142.                     const nListener = listener[nType] || function() {
  4143.                         return Promise.resolve().then(() => listener.apply(this, arguments))
  4144.                     }
  4145.  
  4146.                     listener[nType] = nListener;
  4147.                     args[1] = nListener;
  4148.  
  4149.                 }
  4150.  
  4151.                 return _addEventListener.apply(this, args);
  4152.  
  4153.  
  4154.             }
  4155.             // hack removeEventListener
  4156.             _prototype.removeEventListener = function removeEventListener() {
  4157.  
  4158.                 let args = arguments
  4159.                 let type = args[0]
  4160.                 let listener = args[1]
  4161.  
  4162.  
  4163.                 if (!this || !(this instanceof Node) || typeof type != 'string' || typeof listener != 'function') {
  4164.                     return _removeEventListener.apply(this, args)
  4165.                     //unknown bug?
  4166.                 }
  4167.  
  4168.                 let bClickAction = false;
  4169.                 switch (type) {
  4170.                     case 'load':
  4171.                     case 'beforeunload':
  4172.                     case 'DOMContentLoaded':
  4173.                         return _removeEventListener.apply(this, args);
  4174.                         break;
  4175.                     case 'mousewheel':
  4176.                     case 'touchstart':
  4177.                     case 'wheel':
  4178.                     case 'timeupdate':
  4179.                         if ($mb.stable_isSupportPassiveEventListener()) {
  4180.                             if (!(args[2] && typeof args[2] == 'object')) {
  4181.                                 const fs = (listener + "");
  4182.                                 if (fs.indexOf('{ [native code] }') < 0 && fs.indexOf('.preventDefault()') < 0) {
  4183.                                     //make default passive if not set
  4184.                                     const options = args[2] === true ? options_passive_capture : options_passive_bubble
  4185.                                     args[2] = options
  4186.                                     if (args.length < 3) args.length = 3;
  4187.                                 }
  4188.                             }
  4189.                         }
  4190.                         break;
  4191.                     case 'mouseout':
  4192.                     case 'mouseover':
  4193.                     case 'focusin':
  4194.                     case 'focusout':
  4195.                     case 'mouseenter':
  4196.                     case 'mouseleave':
  4197.                     case 'mousemove':
  4198.  
  4199.                         break;
  4200.                     case 'click':
  4201.                     case 'mousedown':
  4202.                     case 'mouseup':
  4203.                         bClickAction = true;
  4204.                         break;
  4205.                     default:
  4206.                         return _removeEventListener.apply(this, args);
  4207.                 }
  4208.  
  4209.                 if (bClickAction) {
  4210.  
  4211.  
  4212.                     phListeners = phListeners.then(() => {
  4213.                         const listeners = wmListeners.get(this);
  4214.                         if (listeners) {
  4215.                             const lh_removal = new ListenerHandle(args[1], args[2])
  4216.  
  4217.                             listeners[type].remove(lh_removal)
  4218.                         }
  4219.                     })
  4220.                     return _removeEventListener.apply(this, args);
  4221.  
  4222.  
  4223.                 } else {
  4224.                     const nType = `__nListener|${type}__`
  4225.                     if (typeof listener[nType] == 'function') args[1] = listener[nType]
  4226.                     return _removeEventListener.apply(this, args);
  4227.                 }
  4228.  
  4229.  
  4230.  
  4231.  
  4232.             }
  4233.             _prototype.addEventListener.toString = () => _addEventListener.toString();
  4234.             _prototype.removeEventListener.toString = () => _removeEventListener.toString();
  4235.  
  4236.  
  4237.         }
  4238.  
  4239.  
  4240.         function initShadowRoots(rootDoc) {
  4241.             function onReady() {
  4242.                 var treeWalker = rootDoc.createTreeWalker(
  4243.                     rootDoc.documentElement,
  4244.                     NodeFilter.SHOW_ELEMENT, {
  4245.                         acceptNode: (node) => (node.shadowRoot ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP)
  4246.                     }
  4247.                 );
  4248.                 var nodeList = [];
  4249.                 while (treeWalker.nextNode()) nodeList.push(treeWalker.currentNode);
  4250.                 for (const node of nodeList) {
  4251.                     initForShadowRoot(node.shadowRoot)
  4252.                 }
  4253.             }
  4254.             if (rootDoc.readyState !== 'loading') {
  4255.                 onReady();
  4256.             } else {
  4257.                 rootDoc.addEventListener('DOMContentLoaded', onReady, false);
  4258.             }
  4259.         }
  4260.  
  4261.         function captureVideoEvents(rootDoc) {
  4262.  
  4263.         rootDocs.push(rootDoc)
  4264.  
  4265.             var g = function(evt) {
  4266.  
  4267.  
  4268.                 var domElement = evt.target || this || null
  4269.                 if (domElement && domElement.nodeType == 1 && domElement.nodeName == "VIDEO") {
  4270.                     var video = domElement
  4271.                     if (!domElement.getAttribute('_h5ppid')) handlerVideoFound(video);
  4272.                     if (domElement.getAttribute('_h5ppid')) {
  4273.                         switch (evt.type) {
  4274.                             case 'loadedmetadata':
  4275.                                 return $hs.handlerVideoLoadedMetaData.call(video, evt);
  4276.                                 //  case 'playing':
  4277.                                 //      return $hs.handlerVideoPlaying.call(video, evt);
  4278.                                 //  case 'pause':
  4279.                                 //      return $hs.handlerVideoPause.call(video, evt);
  4280.                                 //  case 'volumechange':
  4281.                                 //      return $hs.handlerVideoVolumeChange.call(video, evt);
  4282.                         }
  4283.                     }
  4284.                 }
  4285.  
  4286.  
  4287.             }
  4288.  
  4289.             // using capture phase
  4290.             rootDoc.addEventListener('loadedmetadata', g, $mb.eh_capture_passive());
  4291.  
  4292.         }
  4293.  
  4294.         function handlerVideoFound(video) {
  4295.  
  4296.             if (!video) return;
  4297.             if (video.getAttribute('_h5ppid')) return;
  4298.  
  4299.             const toSkip = (() => {
  4300.                 //skip GIF video
  4301.                 let alabel = video.getAttribute('aria-label')
  4302.                 if (alabel && typeof alabel == "string" && alabel.toUpperCase() == "GIF") return true;
  4303.  
  4304.                 //skip video with opacity
  4305.                 const videoOpacity = video.style.opacity + ''
  4306.                 if (videoOpacity.length > 0 && +videoOpacity < 0.99 && +videoOpacity >= 0) return true;
  4307.  
  4308.                 //Google Result Video Preview
  4309.                 let pElm = video;
  4310.                 while (pElm && pElm.nodeType == 1) {
  4311.                     if (pElm.nodeName == "A" && pElm.getAttribute('href')) return true;
  4312.                     pElm = pElm.parentNode
  4313.                 }
  4314.                 pElm = null;
  4315.             })();
  4316.  
  4317.             if (toSkip) return;
  4318.  
  4319.             consoleLog('handlerVideoFound', video)
  4320.  
  4321.             $hs.intVideoInitCount = ($hs.intVideoInitCount || 0) + 1;
  4322.             consoleLog(' - HTML5 Video is detected -', `Number of Videos: ${$hs.intVideoInitCount}`)
  4323.             if ($hs.intVideoInitCount === 1) $hs.fireGlobalInit();
  4324.  
  4325.             let vpid = 'h5p-', vRootDoc=null;
  4326.             for(let wi=rootDocs.length;wi--;){
  4327.                 if(rootDocs[wi].contains(video)){
  4328.                     vpid+=`${wi.toString(36)}-`;
  4329.                     vRootDoc=rootDocs[wi]
  4330.                     break;
  4331.                 }
  4332.             }
  4333.             vpid += `${$hs.intVideoInitCount.toString(36)}`;
  4334.  
  4335.             video.setAttribute('_h5ppid', vpid)
  4336.  
  4337.  
  4338.  
  4339.             playerConfs[vpid] = new PlayerConf();
  4340.             playerConfs[vpid].domElement = video;
  4341.             playerConfs[vpid].domActive = DOM_ACTIVE_FOUND;
  4342.  
  4343.             let rootNode = getRoot(video);
  4344.  
  4345.             $vQuery.setVideo(vpid,video);
  4346.  
  4347.             if (rootNode.host) $hs.getPlayerBlockElement(video); // shadowing
  4348.             let rootElm = domAppender(rootNode) || document.documentElement //48763
  4349.             _add_filter(rootElm) // either main document or shadow node
  4350.  
  4351.  
  4352.  
  4353.             video.addEventListener('playing', $hs.handlerVideoPlaying, $mb.eh_capture_passive());
  4354.             video.addEventListener('pause', $hs.handlerVideoPause, $mb.eh_capture_passive());
  4355.             video.addEventListener('volumechange', $hs.handlerVideoVolumeChange, $mb.eh_capture_passive());
  4356.  
  4357.  
  4358.  
  4359.             //observe not fire twice for the same element.
  4360.             if (!$hs.observer_cacheSizing) $hs.observer_cacheSizing = new ResizeObserver($hs.handlerSizing);
  4361.             $hs.observer_cacheSizing.observe(video)
  4362.  
  4363.  
  4364.  
  4365.         }
  4366.  
  4367.  
  4368.         hackAttachShadow()
  4369.         hackCreateShadowRoot()
  4370.         hackEventListener()
  4371.  
  4372.  
  4373.         window.addEventListener('message', $hs.handlerWinMessage, false);
  4374.         $hs.bindDocEvents(document);
  4375.         captureVideoEvents(document);
  4376.         initShadowRoots(document);
  4377.  
  4378.  
  4379.         let windowsLD = (function() {
  4380.             let ls_res = [];
  4381.             try {
  4382.                 ls_res = [!!window.localStorage, !!window.top.localStorage];
  4383.             } catch (e) {}
  4384.             try {
  4385.                 let winp = window;
  4386.                 let winc = 0;
  4387.                 while (winp !== window.top && winp && ++winc) winp = winp.parentNode;
  4388.                 ls_res.push(winc);
  4389.             } catch (e) {}
  4390.             return ls_res;
  4391.         })();
  4392.  
  4393.         consoleLogF('- h5Player Plugin Loaded -', ...windowsLD)
  4394.  
  4395.         function isInCrossOriginFrame() {
  4396.             let result = true;
  4397.             try {
  4398.                 if (window.top.localStorage || window.top.location.href) result = false;
  4399.             } catch (e) {}
  4400.             return result
  4401.         }
  4402.  
  4403.         if (isInCrossOriginFrame()) consoleLog('cross origin frame detected');
  4404.  
  4405.  
  4406.         const $bv = {
  4407.  
  4408.             boostVideoPerformanceActivate: function() {
  4409.                 if ($bz.boosted) return;
  4410.                 $bz.boosted = true;
  4411.             },
  4412.  
  4413.  
  4414.             boostVideoPerformanceDeactivate: function() {
  4415.                 if (!$bz.boosted) return;
  4416.                 $bz.boosted = false;
  4417.             }
  4418.  
  4419.         }
  4420.  
  4421.  
  4422.  
  4423.     })();
  4424.  
  4425. })(window.unsafeWindow, window);