☰

ABEMA Auto Adjust Playback Position

ABEMAで視聴している番組の遅延(タイムラグ)を減らします。

  1. // ==UserScript==
  2. // @name         ABEMA Auto Adjust Playback Position
  3. // @namespace    https://greasyfork.org/scripts/451815
  4. // @version      12
  5. // @description  ABEMAで視聴している番組の遅延(タイムラグ)を減らします。
  6. // @match        https://abema.tv/*
  7. // @grant        none
  8. // @license      MIT License
  9. // @noframes
  10. // ==/UserScript==
  11.  
  12. (() => {
  13.   'use strict';
  14.  
  15.   /* ---------- Settings ---------- */
  16.  
  17.   // 変更した値はブラウザのローカルストレージに保存するので
  18.   // スクリプトをバージョンアップするたびに書き換える必要はありません。
  19.   // （値が0のときは以前に変更した値もしくは初期値を使用します）
  20.  
  21.   // 倍速再生時の速度倍率
  22.   // 初期値：1.5
  23.   // 有効値：1.1 ～ 2.0
  24.   let playbackRate = 0;
  25.  
  26.   // 生放送でのバッファの下限（秒数）
  27.   // 初期値：5
  28.   // 有効値：1 ～ 10
  29.   let liveBuffer = 0;
  30.  
  31.   // 遅延を積極的に減らす（1:有効 / 2:無効）
  32.   // 初期値：1
  33.   // 有効値：1 ～ 2
  34.   let activelyAdjust = 0;
  35.  
  36.   /* ------------------------------ */
  37.  
  38.   const sid = 'AutoAdjustPlaybackPosition',
  39.     ls = JSON.parse(localStorage.getItem(sid) || '{}') || {},
  40.     buffer = {
  41.       changeableRate: true,
  42.       cm: false,
  43.       count: 0,
  44.       currentMax: 0,
  45.       currentMin: 0,
  46.       currentTime: 0,
  47.       large: false,
  48.       linear: 15,
  49.       /** @type {number[]} */
  50.       max: [],
  51.       /** @type {number[]} */
  52.       min: [],
  53.       originalLinear: 0,
  54.       originalLive: 0,
  55.       prev: 0,
  56.       similarLive: false,
  57.     },
  58.     data = {
  59.       version: 12,
  60.     },
  61.     interval = {
  62.       buffer: 0,
  63.       init: 0,
  64.       speed: 0,
  65.       splash: 0,
  66.     },
  67.     moConfig = { childList: true, subtree: true },
  68.     selector = {
  69.       footerText:
  70.         '.com-tv-LinearFooter__feed-super-text,.com-live-event-LiveEventTitle',
  71.       inner: '.c-application-DesktopAppContainer__content',
  72.       liveIcon:
  73.         '.com-a-LegacyIcon__red-icon-path[aria-label="生放送"],.com-live-event-LiveEventViewCounter__icon-wrapper',
  74.       main: 'main',
  75.       seekbar: '.com-vod-VideoControlBar__seekbar',
  76.       splash: '.com-a-Video__video,.com-live-event__LiveEventPlayerView',
  77.       video: 'video[src]:not([style*="display: none;"])',
  78.       videoContainer: '.com-a-Video__container',
  79.     };
  80.  
  81.   /**
  82.    * スタイルシートを追加
  83.    */
  84.   const addCSS = () => {
  85.     const css = `
  86.       #${sid}_Info {
  87.         align-items: center;
  88.         background-color: rgba(0, 0, 0, 0.4);
  89.         border-radius: 4px;
  90.         bottom: 105px;
  91.         color: #fff;
  92.         display: flex;
  93.         font-family: sans-serif;
  94.         justify-content: center;
  95.         left: 90px;
  96.         min-height: 30px;
  97.         min-width: 3em;
  98.         opacity: 0;
  99.         padding: 0.5ex 1ex;
  100.         position: fixed;
  101.         user-select: none;
  102.         visibility: hidden;
  103.         z-index: 2270;
  104.       }
  105.       #${sid}_Info.aapp_show {
  106.         opacity: 0.8;
  107.         visibility: visible;
  108.       }
  109.       #${sid}_Info:hover.aapp_show {
  110.         background-color: rgba(0, 0, 0, 1);
  111.         cursor: pointer;
  112.         opacity: 1;
  113.       }
  114.       #${sid}_Info:hover.aapp_show:after {
  115.         color: #cc9;
  116.         content: "クリックで等速再生";
  117.         padding-left: 1em;
  118.       }
  119.       #${sid}_Info.aapp_hidden {
  120.         opacity: 0;
  121.         transition: opacity 0.5s ease-out, visibility 0.5s ease-out;
  122.         visibility: hidden;
  123.       }
  124.     `,
  125.       style = document.createElement('style');
  126.     style.textContent = css;
  127.     document.head.appendChild(style);
  128.   };
  129.  
  130.   /**
  131.    * 動画の再生速度を変更する
  132.    * @param {number} t 変更する時間（秒）
  133.    * @param {number} r 速度の倍率
  134.    */
  135.   const changePlaybackSpeed = (t, r) => {
  136.     clearTimeout(interval.speed);
  137.     const vi = returnVideo();
  138.     if (vi && t && r) {
  139.       t = (t / r) * 2;
  140.       log('Start change playback speed', t.toFixed(2), r);
  141.       vi.playbackRate = r;
  142.       interval.speed = setTimeout(() => {
  143.         log('Stop change playback speed', t.toFixed(2), r);
  144.         vi.playbackRate = 1;
  145.         resetBufferObj();
  146.       }, t * 1000);
  147.     } else if (vi && vi.playbackRate !== 1) {
  148.       log('Reset playback speed');
  149.       vi.playbackRate = 1;
  150.       resetBufferObj();
  151.     } else {
  152.       log('can not be changed playback speed', t.toFixed(2), r);
  153.       resetBufferObj();
  154.     }
  155.   };
  156.  
  157.   /**
  158.    * 動画を構成している要素に変更があったとき
  159.    */
  160.   const checkChangeElements = () => {
  161.     const inner = document.querySelector(selector.inner);
  162.     if (inner) {
  163.       setTimeout(() => {
  164.         checkVideoBuffer();
  165.       }, 50);
  166.     }
  167.   };
  168.  
  169.   /**
  170.    * フッターに番組プログラムのテキストがあるか調べる
  171.    * @returns {boolean}
  172.    */
  173.   const checkExistsFooterText = () => {
  174.     const span = document.querySelector(selector.footerText);
  175.     return span ? true : false;
  176.   };
  177.  
  178.   /**
  179.    * 生放送かそうでないかを調べる
  180.    * @returns {boolean}
  181.    */
  182.   const cheeckLive = () => {
  183.     const content = returnContentType(),
  184.       seek = document.querySelector(selector.seekbar),
  185.       svg = document.querySelector(selector.liveIcon);
  186.     if ((content === 'tv' && svg) || (content !== 'tv' && !seek)) {
  187.       return true;
  188.     }
  189.     return false;
  190.   };
  191.  
  192.   /**
  193.    * キーボードのキーを押したとき
  194.    * @param {KeyboardEvent} e
  195.    */
  196.   const checkKeyDown = (e) => {
  197.     const isInput =
  198.       e.target instanceof HTMLInputElement ||
  199.       e.target instanceof HTMLTextAreaElement
  200.         ? true
  201.         : false;
  202.     if ((isInput && (e.altKey || e.ctrlKey)) || !isInput) {
  203.       if (e.key === ',' || e.key === '[') {
  204.         e.stopPropagation();
  205.         changePlaybackSpeed(10, 0.5);
  206.       } else if (e.key === '.' || e.key === ']') {
  207.         e.stopPropagation();
  208.         changePlaybackSpeed(30, 2);
  209.       } else if (e.key === '/' || e.key === '\\') {
  210.         e.stopPropagation();
  211.         changePlaybackSpeed(0, 1);
  212.       }
  213.     }
  214.   };
  215.  
  216.   /**
  217.    * スクリプトとストレージのバージョンを確認
  218.    */
  219.   const checkVersion = () => {
  220.     if (!('version' in ls)) {
  221.       if (liveBuffer === 0 && ls.liveBuffer === 3) {
  222.         ls.liveBuffer = 5;
  223.       }
  224.     }
  225.     ls.version = data.version;
  226.     saveLocalStorage();
  227.   };
  228.  
  229.   /**
  230.    * 動画のバッファを調べる
  231.    */
  232.   const checkVideoBuffer = () => {
  233.     clearInterval(interval.buffer);
  234.     interval.buffer = setInterval(() => {
  235.       const vi = returnVideo(),
  236.         content = returnContentType(),
  237.         tv = content === 'tv' ? true : false,
  238.         le = content === 'le' ? true : false,
  239.         live = cheeckLive();
  240.       if (
  241.         (tv && vi?.buffered?.length) ||
  242.         (le && vi?.buffered?.length && live)
  243.       ) {
  244.         const after = live ? ' [LIVE]' : '',
  245.           cTime = vi.currentTime,
  246.           dur = vi.duration > 20000000000 ? true : false,
  247.           eft = checkExistsFooterText(),
  248.           len = vi.buffered.length,
  249.           rate = vi.playbackRate,
  250.           slow = 0.8;
  251.         let b = 0,
  252.           cll = 0;
  253.         for (let i = 0; i < vi.buffered.length; i++) {
  254.           const end = vi.buffered.end(i);
  255.           if (end > vi.currentTime) {
  256.             b += Math.round((end - vi.currentTime) * 10) / 10;
  257.           }
  258.         }
  259.         const vc = document.querySelector(selector.videoContainer);
  260.         if (vc) {
  261.           for (const key of Object.keys(vc)) {
  262.             if (key.startsWith('__reactFiber$')) {
  263.               if (vc[key].return?.stateNode?.player?.getCurrentLiveLatency) {
  264.                 const latency =
  265.                   vc[key].return.stateNode.player.getCurrentLiveLatency();
  266.                 if (latency) cll = Math.round(latency * 10) / 10;
  267.               }
  268.             }
  269.           }
  270.         }
  271.         if (buffer.currentMax < b) buffer.currentMax = b;
  272.         if (buffer.currentMin > b || buffer.currentMin === 0) {
  273.           buffer.currentMin = b;
  274.           if (buffer.large) {
  275.             if (b < liveBuffer + 2 || (!live && b < buffer.linear - 3)) {
  276.               log('small buffer', buffer.currentMax, b);
  277.               changePlaybackSpeed(0, 1);
  278.             }
  279.           }
  280.         }
  281.         if (buffer.currentTime > cTime && !buffer.cm && tv) {
  282.           const ct = buffer.currentTime - cTime;
  283.           vi.currentTime += ct + 0.3;
  284.           log(
  285.             `${ct.toFixed(2)}秒巻き戻ったので元の位置へシークしました`,
  286.             b,
  287.             buffer.currentMin,
  288.             len,
  289.             'warn'
  290.           );
  291.         }
  292.         if (b > 0 && buffer.changeableRate && dur && eft) {
  293.           if (buffer.cm) {
  294.             log('***** CM out *****');
  295.             buffer.cm = false;
  296.           }
  297.           if (rate >= 1 && b < 1 && len === 1 && tv) {
  298.             //現在のバッファが1秒未満になったときスロー再生する
  299.             if (live) liveBuffer += 0.5;
  300.             else buffer.linear += 0.5;
  301.             log('## A', rate, b, live, buffer.linear, liveBuffer);
  302.             changePlaybackSpeed(1.2 - b, slow);
  303.           } else if (rate >= 1 && b < 2 && !live && len === 1) {
  304.             //生放送以外で現在のバッファが2秒未満になったときスロー再生する
  305.             buffer.linear += 0.5;
  306.             log('## B', rate, b, live, buffer.linear);
  307.             changePlaybackSpeed(3 - b, slow);
  308.           } else if (
  309.             rate > 1 &&
  310.             !live &&
  311.             !buffer.similarLive &&
  312.             ((!cll && b < 8) ||
  313.               (cll && (b < buffer.linear || cll < buffer.linear)))
  314.           ) {
  315.             //生放送以外で倍速再生中に下記の場合は等速再生に戻す
  316.             //cllが0：現在のバッファが8秒未満になったとき
  317.             //cllが0以外：現在のバッファもしくはcllがbuffer.linear未満になったとき
  318.             log('## C', rate, b, live, buffer.linear);
  319.             changePlaybackSpeed(0, 1);
  320.           } else if (
  321.             buffer.prev < b &&
  322.             buffer.currentMax - buffer.currentMin > 1
  323.           ) {
  324.             buffer.max.push(buffer.currentMax);
  325.             buffer.min.push(buffer.currentMin);
  326.             buffer.currentMax = 0;
  327.             buffer.currentMin = 0;
  328.             if (
  329.               //記録したバッファの値が参考にならないと判断した場合は破棄する
  330.               (buffer.max.length === 2 &&
  331.                 buffer.min.length === 2 &&
  332.                 (buffer.max[0] + 5 < buffer.max[1] ||
  333.                   buffer.min[0] + 5 < buffer.min[1])) ||
  334.               (buffer.max.length > 1 &&
  335.                 buffer.min.length > 1 &&
  336.                 (buffer.max.slice(-1)[0] < 0 || buffer.min.slice(-1)[0] < 0))
  337.             ) {
  338.               log('** shift', buffer.max.slice(-1)[0], buffer.min.slice(-1)[0]);
  339.               buffer.max.shift();
  340.               buffer.min.shift();
  341.             } else buffer.count += 1;
  342.             let time = 0;
  343.             const maxLast = [...buffer.max].slice(-10),
  344.               minLast = [...buffer.min].slice(-10),
  345.               maxBottom = maxLast.reduce((x, y) => Math.min(x, y)),
  346.               minBottom = minLast.reduce((x, y) => Math.min(x, y)),
  347.               maxDiff =
  348.                 Math.round(
  349.                   (maxLast.reduce((x, y) => Math.max(x, y)) - maxBottom) * 100
  350.                 ) / 100,
  351.               minDiff =
  352.                 Math.round(
  353.                   (minLast.reduce((x, y) => Math.max(x, y)) - minBottom) * 100
  354.                 ) / 100,
  355.               lb1 = liveBuffer <= 5.5 ? 4 : liveBuffer <= 8.5 ? 6 : 8,
  356.               lb2 = liveBuffer < 5 ? 5 : liveBuffer;
  357.             if (rate === 1) {
  358.               if (b > buffer.linear + 0.5 && cll > buffer.linear) {
  359.                 //現在のバッファとcllがbuffer.linearより多いとき
  360.                 //現在のバッファがbuffer.linearに近づくよう倍速再生する
  361.                 time = Math.round((b - buffer.linear) * 100) / 100;
  362.                 log('## D', time, b, maxDiff, minDiff, live, minBottom);
  363.                 changePlaybackSpeed(time, playbackRate);
  364.               } else if (
  365.                 //現在のバッファと最大バッファがbuffer.linearより多いとき
  366.                 //最大バッファがbuffer.linearに近づくよう倍速再生する
  367.                 maxLast.length >= 3 &&
  368.                 maxBottom > buffer.linear + 0.5 &&
  369.                 b > buffer.linear + 0.5 &&
  370.                 minBottom > 2
  371.               ) {
  372.                 time = Math.round((maxBottom - buffer.linear) * 100) / 100;
  373.                 if (minBottom > 19) {
  374.                   buffer.large = true;
  375.                   time = 999;
  376.                 }
  377.                 log('## E', time, b, maxDiff, minDiff, live, minBottom);
  378.                 changePlaybackSpeed(time, playbackRate);
  379.               } else if (
  380.                 //生放送＆最小バッファがliveBufferより多い＆バッファが安定し続けているとき
  381.                 //最小バッファがliveBufferに近づくよう倍速再生する
  382.                 live &&
  383.                 minLast.length >= 5 &&
  384.                 minBottom > liveBuffer + 0.5 &&
  385.                 maxDiff < 2.5 &&
  386.                 minDiff < 2.5
  387.               ) {
  388.                 time = Math.round((minBottom - liveBuffer) * 100) / 100;
  389.                 log('## F', time, b, maxDiff, minDiff);
  390.                 changePlaybackSpeed(time, playbackRate);
  391.               } else if (
  392.                 //生放送でバッファが安定しつづけているとき最小バッファを
  393.                 //liveBufferよりも減らすよう（下限は4秒）倍速再生する
  394.                 activelyAdjust === 1 &&
  395.                 live &&
  396.                 minLast.length >= 10 &&
  397.                 minBottom > lb1 + 0.5 &&
  398.                 maxDiff < 2.5 &&
  399.                 minDiff < 2.5
  400.               ) {
  401.                 time = Math.round((minBottom - lb1) * 100) / 100;
  402.                 log('## G', time, b, maxDiff, minDiff);
  403.                 changePlaybackSpeed(time, playbackRate);
  404.               } else if (
  405.                 //生放送以外で最小バッファが9秒に近づくよう倍速再生する
  406.                 activelyAdjust === 1 &&
  407.                 !live &&
  408.                 minLast.length >= 10 &&
  409.                 minBottom > 9.5
  410.               ) {
  411.                 time = Math.round((minBottom - 9) * 100) / 100;
  412.                 log('## H', time, b, maxDiff, minDiff);
  413.                 changePlaybackSpeed(time, playbackRate);
  414.               } else if (
  415.                 //生放送以外でバッファが生放送のように安定し続けているとき
  416.                 //最小バッファがliveBuffer（下限は5秒）に近づくよう倍速再生する
  417.                 activelyAdjust === 1 &&
  418.                 !live &&
  419.                 minLast.length >= 10 &&
  420.                 minBottom > lb2 + 0.5 &&
  421.                 maxDiff < 2.5 &&
  422.                 minDiff < 2.5
  423.               ) {
  424.                 buffer.similarLive = true;
  425.                 time = Math.round((minBottom - lb2) * 100) / 100;
  426.                 log('## I', time, b, maxDiff, minDiff);
  427.                 changePlaybackSpeed(time, playbackRate);
  428.               }
  429.             }
  430.             log(
  431.               buffer.count,
  432.               'max:[',
  433.               buffer.max.slice(-5).join('  '),
  434.               ']',
  435.               maxBottom,
  436.               maxDiff,
  437.               'min:[',
  438.               buffer.min.slice(-5).join('  '),
  439.               ']',
  440.               minBottom,
  441.               minDiff,
  442.               live,
  443.               buffer.linear,
  444.               len
  445.             );
  446.           }
  447.         } else if (!buffer.cm) {
  448.           log('***** CM in *****', dur);
  449.           buffer.cm = true;
  450.           buffer.linear = buffer.originalLinear;
  451.           buffer.count = 0;
  452.           buffer.currentMax = 0;
  453.           buffer.currentMin = 0;
  454.           buffer.currentTime = 0;
  455.           buffer.max = [];
  456.           buffer.min = [];
  457.           liveBuffer = buffer.originalLive;
  458.           if (rate !== 1) {
  459.             changePlaybackSpeed(0, 1);
  460.           }
  461.         }
  462.         if (!buffer.changeableRate && !eft) {
  463.           buffer.changeableRate = true;
  464.           log('changeableRate', buffer.changeableRate);
  465.         }
  466.         buffer.currentTime = cTime;
  467.         buffer.prev = b;
  468.         if (rate > 1) {
  469.           showInfo(`▶▶ ×${rate}${after}`);
  470.         } else if (rate > 0 && rate < 1) {
  471.           showInfo(`▶ ×${rate}${after}`);
  472.         }
  473.       } else resetBufferObj();
  474.     }, 200);
  475.   };
  476.  
  477.   /**
  478.    * 情報を表示する要素をクリックしたとき
  479.    */
  480.   const clickInfo = () => {
  481.     log('clickInfo');
  482.     if (buffer.changeableRate) {
  483.       changePlaybackSpeed(0, 1);
  484.       buffer.changeableRate = false;
  485.       log('changeableRate', buffer.changeableRate);
  486.     }
  487.   };
  488.  
  489.   /**
  490.    * 情報を表示する要素を作成
  491.    */
  492.   const createInfo = () => {
  493.     const div = document.createElement('div');
  494.     div.id = `${sid}_Info`;
  495.     div.innerHTML = '';
  496.     div.addEventListener('click', clickInfo);
  497.     document.body.appendChild(div);
  498.   };
  499.  
  500.   /**
  501.    * ページを開いたときに1度だけ実行
  502.    */
  503.   const init = () => {
  504.     log('init');
  505.     checkVersion();
  506.     setupSettings();
  507.     waitShowVideo();
  508.     addCSS();
  509.     createInfo();
  510.   };
  511.  
  512.   /**
  513.    * デバッグ用ログ
  514.    * @param {...any} a
  515.    */
  516.   const log = (...a) => {
  517.     if (ls.debug) {
  518.       try {
  519.         if (/^debug$|^error$|^info$|^warn$/.test(a[a.length - 1])) {
  520.           const b = a.pop();
  521.           console[b](sid, a.join('  '));
  522.           showInfo(a[0]);
  523.         } else console.log(sid, a.join('  '));
  524.       } catch (e) {
  525.         if (e instanceof Error) console.error(e.message, ...a);
  526.         else if (typeof e === 'string') console.error(e, ...a);
  527.         else console.error('log error', ...a);
  528.       }
  529.     }
  530.   };
  531.  
  532.   /**
  533.    * bufferオブジェクトをリセット
  534.    */
  535.   const resetBufferObj = () => {
  536.     buffer.count = 0;
  537.     buffer.currentMax = 0;
  538.     buffer.currentMin = 0;
  539.     buffer.currentTime = 0;
  540.     buffer.large = false;
  541.     buffer.max = [];
  542.     buffer.min = [];
  543.     buffer.prev = 0;
  544.     buffer.similarLive = false;
  545.   };
  546.  
  547.   /**
  548.    * どのコンテンツを表示しているかを返す
  549.    * @returns {string} tv:テレビ, ts:見逃し視聴, le:ライブイベント, vi:ビデオ, tt:番組表
  550.    */
  551.   const returnContentType = () => {
  552.     const url = location.href,
  553.       type = /^https:\/\/abema\.tv\/now-on-air\/.+$/.test(url)
  554.         ? 'tv'
  555.         : /^https:\/\/abema\.tv\/channels\/.+$/.test(url)
  556.         ? 'ts'
  557.         : /^https:\/\/abema\.tv\/live-event\/.+$/.test(url)
  558.         ? 'le'
  559.         : /^https:\/\/abema\.tv\/video\/episode\/.+$/.test(url)
  560.         ? 'vi'
  561.         : /^https:\/\/abema\.tv\/timetable/.test(url)
  562.         ? 'tt'
  563.         : '';
  564.     return type;
  565.   };
  566.  
  567.   /**
  568.    * video要素を返す
  569.    * @returns {HTMLVideoElement|null}
  570.    */
  571.   const returnVideo = () => {
  572.     /** @type {HTMLVideoElement|null} */
  573.     const vi = document.querySelector(selector.video);
  574.     return vi ? vi : null;
  575.   };
  576.  
  577.   /**
  578.    * ローカルストレージに設定を保存する
  579.    */
  580.   const saveLocalStorage = () => localStorage.setItem(sid, JSON.stringify(ls));
  581.  
  582.   /**
  583.    * 設定の値を用意する
  584.    */
  585.   const setupSettings = () => {
  586.     /**
  587.      * Settings欄で設定した変数の値が数字以外なら0にする
  588.      * @param {number} a Settings欄の変数
  589.      * @returns {number}
  590.      */
  591.     const num = (a) => (Number.isFinite(Number(a)) ? Number(a) : 0);
  592.     let rate = num(playbackRate),
  593.       buff = num(liveBuffer),
  594.       act = num(activelyAdjust);
  595.     rate = rate > 2 ? 2 : rate < 1.1 && rate !== 0 ? 1.1 : rate;
  596.     buff = buff > 10 ? 10 : buff < 1 && buff !== 0 ? 1 : buff;
  597.     act = act > 2 ? 2 : act < 1 && act !== 0 ? 1 : act;
  598.     playbackRate = ls.playbackRate ? ls.playbackRate : rate ? rate : 1.5;
  599.     liveBuffer = ls.liveBuffer ? ls.liveBuffer : buff ? buff : 5;
  600.     activelyAdjust = ls.activelyAdjust ? ls.activelyAdjust : act ? act : 1;
  601.     if (rate && ls.playbackRate !== rate) {
  602.       playbackRate = rate;
  603.       ls.playbackRate = rate;
  604.       saveLocalStorage();
  605.     }
  606.     if (buff && ls.liveBuffer !== buff) {
  607.       liveBuffer = buff;
  608.       ls.liveBuffer = buff;
  609.       saveLocalStorage();
  610.     }
  611.     if (act && ls.activelyAdjust !== act) {
  612.       activelyAdjust = act;
  613.       ls.activelyAdjust = act;
  614.       saveLocalStorage();
  615.     }
  616.     buffer.originalLinear = buffer.linear;
  617.     buffer.originalLive = liveBuffer;
  618.   };
  619.  
  620.   /**
  621.    * 情報を表示
  622.    * @param {string} s 表示する文字列
  623.    */
  624.   const showInfo = (s) => {
  625.     const eInfo = document.getElementById(`${sid}_Info`);
  626.     if (eInfo) {
  627.       eInfo.textContent = s ? s : '';
  628.       eInfo.classList.remove('aapp_hidden');
  629.       eInfo.classList.add('aapp_show');
  630.       clearTimeout(interval.info);
  631.       interval.info = setTimeout(() => {
  632.         eInfo.classList.remove('aapp_show');
  633.         eInfo.classList.add('aapp_hidden');
  634.       }, 1000);
  635.     }
  636.   };
  637.  
  638.   /**
  639.    * 指定時間だけ待つ
  640.    * @param {number} msec
  641.    */
  642.   const sleep = (msec) => new Promise((resolve) => setTimeout(resolve, msec));
  643.  
  644.   /**
  645.    * ページを開いて動画が表示されたら1度だけ実行
  646.    */
  647.   const startFirstObserve = () => {
  648.     log('startFirstObserve');
  649.     document.addEventListener('keydown', checkKeyDown, true);
  650.     const main = document.querySelector(selector.main);
  651.     if (main) observerC.observe(main, moConfig);
  652.     else log('startFirstObserve: Not found element.', 'error');
  653.   };
  654.  
  655.   /**
  656.    * ページを開いて動画が表示されるのを待つ
  657.    */
  658.   const waitShowVideo = async () => {
  659.     log('waitShowVideo');
  660.     const splash = () => {
  661.       const sp = document.querySelector(selector.splash);
  662.       if (!sp) {
  663.         log('waitShowVideo: Not found element.', 'error');
  664.         return true;
  665.       }
  666.       const cs = getComputedStyle(sp);
  667.       if (cs?.visibility === 'visible') return true;
  668.       return false;
  669.     };
  670.     await sleep(400);
  671.     clearInterval(interval.splash);
  672.     interval.splash = setInterval(() => {
  673.       const vi = returnVideo();
  674.       if (vi && !isNaN(vi.duration) && splash()) {
  675.         clearInterval(interval.splash);
  676.         startFirstObserve();
  677.       }
  678.     }, 250);
  679.   };
  680.  
  681.   const observerC = new MutationObserver(checkChangeElements);
  682.   clearInterval(interval.init);
  683.   interval.init = setInterval(() => {
  684.     if (
  685.       /^https:\/\/abema\.tv\/(now-on-air|live-event)\/[\w-]+\/?$/.test(
  686.         location.href
  687.       )
  688.     ) {
  689.       clearInterval(interval.init);
  690.       init();
  691.     }
  692.   }, 1000);
  693. })();