1/******/ (() => { // webpackBootstrap
  2/******/ 	var __webpack_modules__ = ({
  3
  4/***/ 5033:
  5/***/ ((module, exports, __webpack_require__) => {
  6
  7var __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/************************************************************************/
291var __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
304var requestidlecallback = __webpack_require__(5033);
305;// ./node_modules/@wordpress/priority-queue/build-module/request-idle-callback.js
306
307function createRequestIdleCallback() {
308  if (typeof window === "undefined") {
309    return (callback) => {
310      setTimeout(() => callback(Date.now()), 0);
311    };
312  }
313  return window.requestIdleCallback;
314}
315var request_idle_callback_default = createRequestIdleCallback();
316
317
318;// ./node_modules/@wordpress/priority-queue/build-module/index.js
319
320const 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;