[Summary view] [Print] [Text view]

   1  /******/ (() => { // webpackBootstrap
   2  /******/     var __webpack_modules__ = ({
   3  
   4  /***/ 5033:
   5  /***/ ((module, exports, __webpack_require__) => {
   6  
   7  var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;(function (factory) {
   8      if (true) {
   9          !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
  10          __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
  11          (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
  12          __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  13      } else {}
  14  }(function(){
  15      'use strict';
  16      var scheduleStart, throttleDelay, lazytimer, lazyraf;
  17      var root = typeof window != 'undefined' ?
  18          window :
  19          typeof __webpack_require__.g != undefined ?
  20              __webpack_require__.g :
  21              this || {};
  22      var requestAnimationFrame = root.cancelRequestAnimationFrame && root.requestAnimationFrame || setTimeout;
  23      var cancelRequestAnimationFrame = root.cancelRequestAnimationFrame || clearTimeout;
  24      var tasks = [];
  25      var runAttempts = 0;
  26      var isRunning = false;
  27      var remainingTime = 7;
  28      var minThrottle = 35;
  29      var throttle = 125;
  30      var index = 0;
  31      var taskStart = 0;
  32      var tasklength = 0;
  33      var IdleDeadline = {
  34          get didTimeout(){
  35              return false;
  36          },
  37          timeRemaining: function(){
  38              var timeRemaining = remainingTime - (Date.now() - taskStart);
  39              return timeRemaining < 0 ? 0 : timeRemaining;
  40          },
  41      };
  42      var setInactive = debounce(function(){
  43          remainingTime = 22;
  44          throttle = 66;
  45          minThrottle = 0;
  46      });
  47  
  48  	function debounce(fn){
  49          var id, timestamp;
  50          var wait = 99;
  51          var check = function(){
  52              var last = (Date.now()) - timestamp;
  53  
  54              if (last < wait) {
  55                  id = setTimeout(check, wait - last);
  56              } else {
  57                  id = null;
  58                  fn();
  59              }
  60          };
  61          return function(){
  62              timestamp = Date.now();
  63              if(!id){
  64                  id = setTimeout(check, wait);
  65              }
  66          };
  67      }
  68  
  69  	function abortRunning(){
  70          if(isRunning){
  71              if(lazyraf){
  72                  cancelRequestAnimationFrame(lazyraf);
  73              }
  74              if(lazytimer){
  75                  clearTimeout(lazytimer);
  76              }
  77              isRunning = false;
  78          }
  79      }
  80  
  81  	function onInputorMutation(){
  82          if(throttle != 125){
  83              remainingTime = 7;
  84              throttle = 125;
  85              minThrottle = 35;
  86  
  87              if(isRunning) {
  88                  abortRunning();
  89                  scheduleLazy();
  90              }
  91          }
  92          setInactive();
  93      }
  94  
  95  	function scheduleAfterRaf() {
  96          lazyraf = null;
  97          lazytimer = setTimeout(runTasks, 0);
  98      }
  99  
 100  	function scheduleRaf(){
 101          lazytimer = null;
 102          requestAnimationFrame(scheduleAfterRaf);
 103      }
 104  
 105  	function scheduleLazy(){
 106  
 107          if(isRunning){return;}
 108          throttleDelay = throttle - (Date.now() - taskStart);
 109  
 110          scheduleStart = Date.now();
 111  
 112          isRunning = true;
 113  
 114          if(minThrottle && throttleDelay < minThrottle){
 115              throttleDelay = minThrottle;
 116          }
 117  
 118          if(throttleDelay > 9){
 119              lazytimer = setTimeout(scheduleRaf, throttleDelay);
 120          } else {
 121              throttleDelay = 0;
 122              scheduleRaf();
 123          }
 124      }
 125  
 126  	function runTasks(){
 127          var task, i, len;
 128          var timeThreshold = remainingTime > 9 ?
 129              9 :
 130              1
 131          ;
 132  
 133          taskStart = Date.now();
 134          isRunning = false;
 135  
 136          lazytimer = null;
 137  
 138          if(runAttempts > 2 || taskStart - throttleDelay - 50 < scheduleStart){
 139              for(i = 0, len = tasks.length; i < len && IdleDeadline.timeRemaining() > timeThreshold; i++){
 140                  task = tasks.shift();
 141                  tasklength++;
 142                  if(task){
 143                      task(IdleDeadline);
 144                  }
 145              }
 146          }
 147  
 148          if(tasks.length){
 149              scheduleLazy();
 150          } else {
 151              runAttempts = 0;
 152          }
 153      }
 154  
 155  	function requestIdleCallbackShim(task){
 156          index++;
 157          tasks.push(task);
 158          scheduleLazy();
 159          return index;
 160      }
 161  
 162  	function cancelIdleCallbackShim(id){
 163          var index = id - 1 - tasklength;
 164          if(tasks[index]){
 165              tasks[index] = null;
 166          }
 167      }
 168  
 169      if(!root.requestIdleCallback || !root.cancelIdleCallback){
 170          root.requestIdleCallback = requestIdleCallbackShim;
 171          root.cancelIdleCallback = cancelIdleCallbackShim;
 172  
 173          if(root.document && document.addEventListener){
 174              root.addEventListener('scroll', onInputorMutation, true);
 175              root.addEventListener('resize', onInputorMutation);
 176  
 177              document.addEventListener('focus', onInputorMutation, true);
 178              document.addEventListener('mouseover', onInputorMutation, true);
 179              ['click', 'keypress', 'touchstart', 'mousedown'].forEach(function(name){
 180                  document.addEventListener(name, onInputorMutation, {capture: true, passive: true});
 181              });
 182  
 183              if(root.MutationObserver){
 184                  new MutationObserver( onInputorMutation ).observe( document.documentElement, {childList: true, subtree: true, attributes: true} );
 185              }
 186          }
 187      } else {
 188          try{
 189              root.requestIdleCallback(function(){}, {timeout: 0});
 190          } catch(e){
 191              (function(rIC){
 192                  var timeRemainingProto, timeRemaining;
 193                  root.requestIdleCallback = function(fn, timeout){
 194                      if(timeout && typeof timeout.timeout == 'number'){
 195                          return rIC(fn, timeout.timeout);
 196                      }
 197                      return rIC(fn);
 198                  };
 199                  if(root.IdleCallbackDeadline && (timeRemainingProto = IdleCallbackDeadline.prototype)){
 200                      timeRemaining = Object.getOwnPropertyDescriptor(timeRemainingProto, 'timeRemaining');
 201                      if(!timeRemaining || !timeRemaining.configurable || !timeRemaining.get){return;}
 202                      Object.defineProperty(timeRemainingProto, 'timeRemaining', {
 203                          value:  function(){
 204                              return timeRemaining.get.call(this);
 205                          },
 206                          enumerable: true,
 207                          configurable: true,
 208                      });
 209                  }
 210              })(root.requestIdleCallback)
 211          }
 212      }
 213  
 214      return {
 215          request: requestIdleCallbackShim,
 216          cancel: cancelIdleCallbackShim,
 217      };
 218  }));
 219  
 220  
 221  /***/ })
 222  
 223  /******/     });
 224  /************************************************************************/
 225  /******/     // The module cache
 226  /******/     var __webpack_module_cache__ = {};
 227  /******/     
 228  /******/     // The require function
 229  /******/ 	function __webpack_require__(moduleId) {
 230  /******/         // Check if module is in cache
 231  /******/         var cachedModule = __webpack_module_cache__[moduleId];
 232  /******/         if (cachedModule !== undefined) {
 233  /******/             return cachedModule.exports;
 234  /******/         }
 235  /******/         // Create a new module (and put it into the cache)
 236  /******/         var module = __webpack_module_cache__[moduleId] = {
 237  /******/             // no module.id needed
 238  /******/             // no module.loaded needed
 239  /******/             exports: {}
 240  /******/         };
 241  /******/     
 242  /******/         // Execute the module function
 243  /******/         __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
 244  /******/     
 245  /******/         // Return the exports of the module
 246  /******/         return module.exports;
 247  /******/     }
 248  /******/     
 249  /************************************************************************/
 250  /******/     /* webpack/runtime/define property getters */
 251  /******/     (() => {
 252  /******/         // define getter functions for harmony exports
 253  /******/         __webpack_require__.d = (exports, definition) => {
 254  /******/             for(var key in definition) {
 255  /******/                 if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
 256  /******/                     Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
 257  /******/                 }
 258  /******/             }
 259  /******/         };
 260  /******/     })();
 261  /******/     
 262  /******/     /* webpack/runtime/global */
 263  /******/     (() => {
 264  /******/         __webpack_require__.g = (function() {
 265  /******/             if (typeof globalThis === 'object') return globalThis;
 266  /******/             try {
 267  /******/                 return this || new Function('return this')();
 268  /******/             } catch (e) {
 269  /******/                 if (typeof window === 'object') return window;
 270  /******/             }
 271  /******/         })();
 272  /******/     })();
 273  /******/     
 274  /******/     /* webpack/runtime/hasOwnProperty shorthand */
 275  /******/     (() => {
 276  /******/         __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
 277  /******/     })();
 278  /******/     
 279  /******/     /* webpack/runtime/make namespace object */
 280  /******/     (() => {
 281  /******/         // define __esModule on exports
 282  /******/         __webpack_require__.r = (exports) => {
 283  /******/             if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
 284  /******/                 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 285  /******/             }
 286  /******/             Object.defineProperty(exports, '__esModule', { value: true });
 287  /******/         };
 288  /******/     })();
 289  /******/     
 290  /************************************************************************/
 291  var __webpack_exports__ = {};
 292  // This entry needs to be wrapped in an IIFE because it needs to be in strict mode.
 293  (() => {
 294  "use strict";
 295  // ESM COMPAT FLAG
 296  __webpack_require__.r(__webpack_exports__);
 297  
 298  // EXPORTS
 299  __webpack_require__.d(__webpack_exports__, {
 300    createQueue: () => (/* binding */ createQueue)
 301  });
 302  
 303  // EXTERNAL MODULE: ./node_modules/requestidlecallback/index.js
 304  var requestidlecallback = __webpack_require__(5033);
 305  ;// ./node_modules/@wordpress/priority-queue/build-module/request-idle-callback.js
 306  
 307  function createRequestIdleCallback() {
 308    if (typeof window === "undefined") {
 309      return (callback) => {
 310        setTimeout(() => callback(Date.now()), 0);
 311      };
 312    }
 313    return window.requestIdleCallback;
 314  }
 315  var request_idle_callback_default = createRequestIdleCallback();
 316  
 317  
 318  ;// ./node_modules/@wordpress/priority-queue/build-module/index.js
 319  
 320  const createQueue = () => {
 321    const waitingList = /* @__PURE__ */ new Map();
 322    let isRunning = false;
 323    const runWaitingList = (deadline) => {
 324      for (const [nextElement, callback] of waitingList) {
 325        waitingList.delete(nextElement);
 326        callback();
 327        if ("number" === typeof deadline || deadline.timeRemaining() <= 0) {
 328          break;
 329        }
 330      }
 331      if (waitingList.size === 0) {
 332        isRunning = false;
 333        return;
 334      }
 335      request_idle_callback_default(runWaitingList);
 336    };
 337    const add = (element, item) => {
 338      waitingList.set(element, item);
 339      if (!isRunning) {
 340        isRunning = true;
 341        request_idle_callback_default(runWaitingList);
 342      }
 343    };
 344    const flush = (element) => {
 345      const callback = waitingList.get(element);
 346      if (void 0 === callback) {
 347        return false;
 348      }
 349      waitingList.delete(element);
 350      callback();
 351      return true;
 352    };
 353    const cancel = (element) => {
 354      return waitingList.delete(element);
 355    };
 356    const reset = () => {
 357      waitingList.clear();
 358      isRunning = false;
 359    };
 360    return {
 361      add,
 362      flush,
 363      cancel,
 364      reset
 365    };
 366  };
 367  
 368  
 369  })();
 370  
 371  (window.wp = window.wp || {}).priorityQueue = __webpack_exports__;
 372  /******/ })()
 373  ;