Diff: STRATO-apps/wordpress_03/app/wp-includes/js/dist/priority-queue.js
Keine Baseline-Datei – Diff nur gegen leer.
1
-
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
+
;