[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 need to be wrapped in an IIFE because it need 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  ;// CONCATENATED MODULE: ./node_modules/@wordpress/priority-queue/build-module/request-idle-callback.js
 306  /**
 307   * External dependencies
 308   */
 309  
 310  
 311  /**
 312   * @typedef {( timeOrDeadline: IdleDeadline | number ) => void} Callback
 313   */
 314  
 315  /**
 316   * @return {(callback: Callback) => void} RequestIdleCallback
 317   */
 318  function createRequestIdleCallback() {
 319    if (typeof window === 'undefined') {
 320      return callback => {
 321        setTimeout(() => callback(Date.now()), 0);
 322      };
 323    }
 324    return window.requestIdleCallback;
 325  }
 326  /* harmony default export */ const request_idle_callback = (createRequestIdleCallback());
 327  
 328  ;// CONCATENATED MODULE: ./node_modules/@wordpress/priority-queue/build-module/index.js
 329  /**
 330   * Internal dependencies
 331   */
 332  
 333  
 334  /**
 335   * Enqueued callback to invoke once idle time permits.
 336   *
 337   * @typedef {()=>void} WPPriorityQueueCallback
 338   */
 339  
 340  /**
 341   * An object used to associate callbacks in a particular context grouping.
 342   *
 343   * @typedef {{}} WPPriorityQueueContext
 344   */
 345  
 346  /**
 347   * Function to add callback to priority queue.
 348   *
 349   * @typedef {(element:WPPriorityQueueContext,item:WPPriorityQueueCallback)=>void} WPPriorityQueueAdd
 350   */
 351  
 352  /**
 353   * Function to flush callbacks from priority queue.
 354   *
 355   * @typedef {(element:WPPriorityQueueContext)=>boolean} WPPriorityQueueFlush
 356   */
 357  
 358  /**
 359   * Reset the queue.
 360   *
 361   * @typedef {()=>void} WPPriorityQueueReset
 362   */
 363  
 364  /**
 365   * Priority queue instance.
 366   *
 367   * @typedef {Object} WPPriorityQueue
 368   *
 369   * @property {WPPriorityQueueAdd}   add    Add callback to queue for context.
 370   * @property {WPPriorityQueueFlush} flush  Flush queue for context.
 371   * @property {WPPriorityQueueFlush} cancel Clear queue for context.
 372   * @property {WPPriorityQueueReset} reset  Reset queue.
 373   */
 374  
 375  /**
 376   * Creates a context-aware queue that only executes
 377   * the last task of a given context.
 378   *
 379   * @example
 380   *```js
 381   * import { createQueue } from '@wordpress/priority-queue';
 382   *
 383   * const queue = createQueue();
 384   *
 385   * // Context objects.
 386   * const ctx1 = {};
 387   * const ctx2 = {};
 388   *
 389   * // For a given context in the queue, only the last callback is executed.
 390   * queue.add( ctx1, () => console.log( 'This will be printed first' ) );
 391   * queue.add( ctx2, () => console.log( 'This won\'t be printed' ) );
 392   * queue.add( ctx2, () => console.log( 'This will be printed second' ) );
 393   *```
 394   *
 395   * @return {WPPriorityQueue} Queue object with `add`, `flush` and `reset` methods.
 396   */
 397  const createQueue = () => {
 398    /** @type {Map<WPPriorityQueueContext, WPPriorityQueueCallback>} */
 399    const waitingList = new Map();
 400    let isRunning = false;
 401  
 402    /**
 403     * Callback to process as much queue as time permits.
 404     *
 405     * Map Iteration follows the original insertion order. This means that here
 406     * we can iterate the queue and know that the first contexts which were
 407     * added will be run first. On the other hand, if anyone adds a new callback
 408     * for an existing context it will supplant the previously-set callback for
 409     * that context because we reassigned that map key's value.
 410     *
 411     * In the case that a callback adds a new callback to its own context then
 412     * the callback it adds will appear at the end of the iteration and will be
 413     * run only after all other existing contexts have finished executing.
 414     *
 415     * @param {IdleDeadline|number} deadline Idle callback deadline object, or
 416     *                                       animation frame timestamp.
 417     */
 418    const runWaitingList = deadline => {
 419      for (const [nextElement, callback] of waitingList) {
 420        waitingList.delete(nextElement);
 421        callback();
 422        if ('number' === typeof deadline || deadline.timeRemaining() <= 0) {
 423          break;
 424        }
 425      }
 426      if (waitingList.size === 0) {
 427        isRunning = false;
 428        return;
 429      }
 430      request_idle_callback(runWaitingList);
 431    };
 432  
 433    /**
 434     * Add a callback to the queue for a given context.
 435     *
 436     * If errors with undefined callbacks are encountered double check that
 437     * all of your useSelect calls have the right dependencies set correctly
 438     * in their second parameter. Missing dependencies can cause unexpected
 439     * loops and race conditions in the queue.
 440     *
 441     * @type {WPPriorityQueueAdd}
 442     *
 443     * @param {WPPriorityQueueContext}  element Context object.
 444     * @param {WPPriorityQueueCallback} item    Callback function.
 445     */
 446    const add = (element, item) => {
 447      waitingList.set(element, item);
 448      if (!isRunning) {
 449        isRunning = true;
 450        request_idle_callback(runWaitingList);
 451      }
 452    };
 453  
 454    /**
 455     * Flushes queue for a given context, returning true if the flush was
 456     * performed, or false if there is no queue for the given context.
 457     *
 458     * @type {WPPriorityQueueFlush}
 459     *
 460     * @param {WPPriorityQueueContext} element Context object.
 461     *
 462     * @return {boolean} Whether flush was performed.
 463     */
 464    const flush = element => {
 465      const callback = waitingList.get(element);
 466      if (undefined === callback) {
 467        return false;
 468      }
 469      waitingList.delete(element);
 470      callback();
 471      return true;
 472    };
 473  
 474    /**
 475     * Clears the queue for a given context, cancelling the callbacks without
 476     * executing them. Returns `true` if there were scheduled callbacks to cancel,
 477     * or `false` if there was is no queue for the given context.
 478     *
 479     * @type {WPPriorityQueueFlush}
 480     *
 481     * @param {WPPriorityQueueContext} element Context object.
 482     *
 483     * @return {boolean} Whether any callbacks got cancelled.
 484     */
 485    const cancel = element => {
 486      return waitingList.delete(element);
 487    };
 488  
 489    /**
 490     * Reset the queue without running the pending callbacks.
 491     *
 492     * @type {WPPriorityQueueReset}
 493     */
 494    const reset = () => {
 495      waitingList.clear();
 496      isRunning = false;
 497    };
 498    return {
 499      add,
 500      flush,
 501      cancel,
 502      reset
 503    };
 504  };
 505  
 506  })();
 507  
 508  (window.wp = window.wp || {}).priorityQueue = __webpack_exports__;
 509  /******/ })()
 510  ;