Update dependencies and clean up project structure. Add cloud.google.com/go/compute/metadata as an indirect requirement in go.mod. Remove unused files and update package.json for Vite and React plugins. Refactor Makefile for improved build process.
This commit is contained in:
1068
web/node_modules/scheduler/cjs/scheduler-unstable_mock.development.js
generated
vendored
1068
web/node_modules/scheduler/cjs/scheduler-unstable_mock.development.js
generated
vendored
File diff suppressed because it is too large
Load Diff
406
web/node_modules/scheduler/cjs/scheduler-unstable_mock.production.js
generated
vendored
406
web/node_modules/scheduler/cjs/scheduler-unstable_mock.production.js
generated
vendored
@@ -1,406 +0,0 @@
|
||||
/**
|
||||
* @license React
|
||||
* scheduler-unstable_mock.production.js
|
||||
*
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
function push(heap, node) {
|
||||
var index = heap.length;
|
||||
heap.push(node);
|
||||
a: for (; 0 < index; ) {
|
||||
var parentIndex = (index - 1) >>> 1,
|
||||
parent = heap[parentIndex];
|
||||
if (0 < compare(parent, node))
|
||||
(heap[parentIndex] = node), (heap[index] = parent), (index = parentIndex);
|
||||
else break a;
|
||||
}
|
||||
}
|
||||
function peek(heap) {
|
||||
return 0 === heap.length ? null : heap[0];
|
||||
}
|
||||
function pop(heap) {
|
||||
if (0 === heap.length) return null;
|
||||
var first = heap[0],
|
||||
last = heap.pop();
|
||||
if (last !== first) {
|
||||
heap[0] = last;
|
||||
a: for (
|
||||
var index = 0, length = heap.length, halfLength = length >>> 1;
|
||||
index < halfLength;
|
||||
|
||||
) {
|
||||
var leftIndex = 2 * (index + 1) - 1,
|
||||
left = heap[leftIndex],
|
||||
rightIndex = leftIndex + 1,
|
||||
right = heap[rightIndex];
|
||||
if (0 > compare(left, last))
|
||||
rightIndex < length && 0 > compare(right, left)
|
||||
? ((heap[index] = right),
|
||||
(heap[rightIndex] = last),
|
||||
(index = rightIndex))
|
||||
: ((heap[index] = left),
|
||||
(heap[leftIndex] = last),
|
||||
(index = leftIndex));
|
||||
else if (rightIndex < length && 0 > compare(right, last))
|
||||
(heap[index] = right), (heap[rightIndex] = last), (index = rightIndex);
|
||||
else break a;
|
||||
}
|
||||
}
|
||||
return first;
|
||||
}
|
||||
function compare(a, b) {
|
||||
var diff = a.sortIndex - b.sortIndex;
|
||||
return 0 !== diff ? diff : a.id - b.id;
|
||||
}
|
||||
var taskQueue = [],
|
||||
timerQueue = [],
|
||||
taskIdCounter = 1,
|
||||
currentTask = null,
|
||||
currentPriorityLevel = 3,
|
||||
isPerformingWork = !1,
|
||||
isHostCallbackScheduled = !1,
|
||||
isHostTimeoutScheduled = !1,
|
||||
currentMockTime = 0,
|
||||
scheduledCallback = null,
|
||||
scheduledTimeout = null,
|
||||
timeoutTime = -1,
|
||||
yieldedValues = null,
|
||||
expectedNumberOfYields = -1,
|
||||
didStop = !1,
|
||||
isFlushing = !1,
|
||||
needsPaint = !1,
|
||||
shouldYieldForPaint = !1,
|
||||
disableYieldValue = !1;
|
||||
function advanceTimers(currentTime) {
|
||||
for (var timer = peek(timerQueue); null !== timer; ) {
|
||||
if (null === timer.callback) pop(timerQueue);
|
||||
else if (timer.startTime <= currentTime)
|
||||
pop(timerQueue),
|
||||
(timer.sortIndex = timer.expirationTime),
|
||||
push(taskQueue, timer);
|
||||
else break;
|
||||
timer = peek(timerQueue);
|
||||
}
|
||||
}
|
||||
function handleTimeout(currentTime) {
|
||||
isHostTimeoutScheduled = !1;
|
||||
advanceTimers(currentTime);
|
||||
if (!isHostCallbackScheduled)
|
||||
if (null !== peek(taskQueue))
|
||||
(isHostCallbackScheduled = !0), (scheduledCallback = flushWork);
|
||||
else {
|
||||
var firstTimer = peek(timerQueue);
|
||||
null !== firstTimer &&
|
||||
((currentTime = firstTimer.startTime - currentTime),
|
||||
(scheduledTimeout = handleTimeout),
|
||||
(timeoutTime = currentMockTime + currentTime));
|
||||
}
|
||||
}
|
||||
function flushWork(hasTimeRemaining, initialTime) {
|
||||
isHostCallbackScheduled = !1;
|
||||
isHostTimeoutScheduled &&
|
||||
((isHostTimeoutScheduled = !1),
|
||||
(scheduledTimeout = null),
|
||||
(timeoutTime = -1));
|
||||
isPerformingWork = !0;
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
try {
|
||||
a: {
|
||||
advanceTimers(initialTime);
|
||||
for (
|
||||
currentTask = peek(taskQueue);
|
||||
null !== currentTask &&
|
||||
(!(currentTask.expirationTime > initialTime) ||
|
||||
(hasTimeRemaining && !shouldYieldToHost()));
|
||||
|
||||
) {
|
||||
var callback = currentTask.callback;
|
||||
if ("function" === typeof callback) {
|
||||
currentTask.callback = null;
|
||||
currentPriorityLevel = currentTask.priorityLevel;
|
||||
var continuationCallback = callback(
|
||||
currentTask.expirationTime <= initialTime
|
||||
);
|
||||
initialTime = currentMockTime;
|
||||
if ("function" === typeof continuationCallback) {
|
||||
if (
|
||||
((currentTask.callback = continuationCallback),
|
||||
advanceTimers(initialTime),
|
||||
shouldYieldForPaint)
|
||||
) {
|
||||
var JSCompiler_inline_result = (needsPaint = !0);
|
||||
break a;
|
||||
}
|
||||
} else
|
||||
currentTask === peek(taskQueue) && pop(taskQueue),
|
||||
advanceTimers(initialTime);
|
||||
} else pop(taskQueue);
|
||||
currentTask = peek(taskQueue);
|
||||
}
|
||||
if (null !== currentTask) JSCompiler_inline_result = !0;
|
||||
else {
|
||||
var firstTimer = peek(timerQueue);
|
||||
if (null !== firstTimer) {
|
||||
var ms = firstTimer.startTime - initialTime;
|
||||
scheduledTimeout = handleTimeout;
|
||||
timeoutTime = currentMockTime + ms;
|
||||
}
|
||||
JSCompiler_inline_result = !1;
|
||||
}
|
||||
}
|
||||
return JSCompiler_inline_result;
|
||||
} finally {
|
||||
(currentTask = null),
|
||||
(currentPriorityLevel = previousPriorityLevel),
|
||||
(isPerformingWork = !1);
|
||||
}
|
||||
}
|
||||
function shouldYieldToHost() {
|
||||
return (0 === expectedNumberOfYields && null === yieldedValues) ||
|
||||
(-1 !== expectedNumberOfYields &&
|
||||
null !== yieldedValues &&
|
||||
yieldedValues.length >= expectedNumberOfYields) ||
|
||||
(shouldYieldForPaint && needsPaint)
|
||||
? (didStop = !0)
|
||||
: !1;
|
||||
}
|
||||
function unstable_flushAllWithoutAsserting() {
|
||||
if (isFlushing) throw Error("Already flushing work.");
|
||||
if (null !== scheduledCallback) {
|
||||
var cb = scheduledCallback;
|
||||
isFlushing = !0;
|
||||
try {
|
||||
var hasMoreWork = !0;
|
||||
do hasMoreWork = cb(!0, currentMockTime);
|
||||
while (hasMoreWork);
|
||||
hasMoreWork || (scheduledCallback = null);
|
||||
return !0;
|
||||
} finally {
|
||||
isFlushing = !1;
|
||||
}
|
||||
} else return !1;
|
||||
}
|
||||
exports.log = function (value) {
|
||||
"disabledLog" === console.log.name ||
|
||||
disableYieldValue ||
|
||||
(null === yieldedValues
|
||||
? (yieldedValues = [value])
|
||||
: yieldedValues.push(value));
|
||||
};
|
||||
exports.reset = function () {
|
||||
if (isFlushing) throw Error("Cannot reset while already flushing work.");
|
||||
currentMockTime = 0;
|
||||
scheduledTimeout = scheduledCallback = null;
|
||||
timeoutTime = -1;
|
||||
yieldedValues = null;
|
||||
expectedNumberOfYields = -1;
|
||||
needsPaint = isFlushing = didStop = !1;
|
||||
};
|
||||
exports.unstable_IdlePriority = 5;
|
||||
exports.unstable_ImmediatePriority = 1;
|
||||
exports.unstable_LowPriority = 4;
|
||||
exports.unstable_NormalPriority = 3;
|
||||
exports.unstable_Profiling = null;
|
||||
exports.unstable_UserBlockingPriority = 2;
|
||||
exports.unstable_advanceTime = function (ms) {
|
||||
"disabledLog" === console.log.name ||
|
||||
disableYieldValue ||
|
||||
((currentMockTime += ms),
|
||||
null !== scheduledTimeout &&
|
||||
timeoutTime <= currentMockTime &&
|
||||
(scheduledTimeout(currentMockTime),
|
||||
(timeoutTime = -1),
|
||||
(scheduledTimeout = null)));
|
||||
};
|
||||
exports.unstable_cancelCallback = function (task) {
|
||||
task.callback = null;
|
||||
};
|
||||
exports.unstable_clearLog = function () {
|
||||
if (null === yieldedValues) return [];
|
||||
var values = yieldedValues;
|
||||
yieldedValues = null;
|
||||
return values;
|
||||
};
|
||||
exports.unstable_flushAll = function () {
|
||||
if (null !== yieldedValues)
|
||||
throw Error(
|
||||
"Log is not empty. Assert on the log of yielded values before flushing additional work."
|
||||
);
|
||||
unstable_flushAllWithoutAsserting();
|
||||
if (null !== yieldedValues)
|
||||
throw Error(
|
||||
"While flushing work, something yielded a value. Use an assertion helper to assert on the log of yielded values, e.g. expect(Scheduler).toFlushAndYield([...])"
|
||||
);
|
||||
};
|
||||
exports.unstable_flushAllWithoutAsserting = unstable_flushAllWithoutAsserting;
|
||||
exports.unstable_flushExpired = function () {
|
||||
if (isFlushing) throw Error("Already flushing work.");
|
||||
if (null !== scheduledCallback) {
|
||||
isFlushing = !0;
|
||||
try {
|
||||
scheduledCallback(!1, currentMockTime) || (scheduledCallback = null);
|
||||
} finally {
|
||||
isFlushing = !1;
|
||||
}
|
||||
}
|
||||
};
|
||||
exports.unstable_flushNumberOfYields = function (count) {
|
||||
if (isFlushing) throw Error("Already flushing work.");
|
||||
if (null !== scheduledCallback) {
|
||||
var cb = scheduledCallback;
|
||||
expectedNumberOfYields = count;
|
||||
isFlushing = !0;
|
||||
try {
|
||||
count = !0;
|
||||
do count = cb(!0, currentMockTime);
|
||||
while (count && !didStop);
|
||||
count || (scheduledCallback = null);
|
||||
} finally {
|
||||
(expectedNumberOfYields = -1), (isFlushing = didStop = !1);
|
||||
}
|
||||
}
|
||||
};
|
||||
exports.unstable_flushUntilNextPaint = function () {
|
||||
if (isFlushing) throw Error("Already flushing work.");
|
||||
if (null !== scheduledCallback) {
|
||||
var cb = scheduledCallback;
|
||||
shouldYieldForPaint = !0;
|
||||
needsPaint = !1;
|
||||
isFlushing = !0;
|
||||
try {
|
||||
var hasMoreWork = !0;
|
||||
do hasMoreWork = cb(!0, currentMockTime);
|
||||
while (hasMoreWork && !didStop);
|
||||
hasMoreWork || (scheduledCallback = null);
|
||||
} finally {
|
||||
isFlushing = didStop = shouldYieldForPaint = !1;
|
||||
}
|
||||
}
|
||||
return !1;
|
||||
};
|
||||
exports.unstable_forceFrameRate = function () {};
|
||||
exports.unstable_getCurrentPriorityLevel = function () {
|
||||
return currentPriorityLevel;
|
||||
};
|
||||
exports.unstable_hasPendingWork = function () {
|
||||
return null !== scheduledCallback;
|
||||
};
|
||||
exports.unstable_next = function (eventHandler) {
|
||||
switch (currentPriorityLevel) {
|
||||
case 1:
|
||||
case 2:
|
||||
case 3:
|
||||
var priorityLevel = 3;
|
||||
break;
|
||||
default:
|
||||
priorityLevel = currentPriorityLevel;
|
||||
}
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = priorityLevel;
|
||||
try {
|
||||
return eventHandler();
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
exports.unstable_now = function () {
|
||||
return currentMockTime;
|
||||
};
|
||||
exports.unstable_requestPaint = function () {
|
||||
needsPaint = !0;
|
||||
};
|
||||
exports.unstable_runWithPriority = function (priorityLevel, eventHandler) {
|
||||
switch (priorityLevel) {
|
||||
case 1:
|
||||
case 2:
|
||||
case 3:
|
||||
case 4:
|
||||
case 5:
|
||||
break;
|
||||
default:
|
||||
priorityLevel = 3;
|
||||
}
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = priorityLevel;
|
||||
try {
|
||||
return eventHandler();
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
exports.unstable_scheduleCallback = function (
|
||||
priorityLevel,
|
||||
callback,
|
||||
options
|
||||
) {
|
||||
var currentTime = currentMockTime;
|
||||
"object" === typeof options && null !== options
|
||||
? ((options = options.delay),
|
||||
(options =
|
||||
"number" === typeof options && 0 < options
|
||||
? currentTime + options
|
||||
: currentTime))
|
||||
: (options = currentTime);
|
||||
switch (priorityLevel) {
|
||||
case 1:
|
||||
var timeout = -1;
|
||||
break;
|
||||
case 2:
|
||||
timeout = 250;
|
||||
break;
|
||||
case 5:
|
||||
timeout = 1073741823;
|
||||
break;
|
||||
case 4:
|
||||
timeout = 1e4;
|
||||
break;
|
||||
default:
|
||||
timeout = 5e3;
|
||||
}
|
||||
timeout = options + timeout;
|
||||
priorityLevel = {
|
||||
id: taskIdCounter++,
|
||||
callback: callback,
|
||||
priorityLevel: priorityLevel,
|
||||
startTime: options,
|
||||
expirationTime: timeout,
|
||||
sortIndex: -1
|
||||
};
|
||||
options > currentTime
|
||||
? ((priorityLevel.sortIndex = options),
|
||||
push(timerQueue, priorityLevel),
|
||||
null === peek(taskQueue) &&
|
||||
priorityLevel === peek(timerQueue) &&
|
||||
(isHostTimeoutScheduled
|
||||
? ((scheduledTimeout = null), (timeoutTime = -1))
|
||||
: (isHostTimeoutScheduled = !0),
|
||||
(scheduledTimeout = handleTimeout),
|
||||
(timeoutTime = currentMockTime + (options - currentTime))))
|
||||
: ((priorityLevel.sortIndex = timeout),
|
||||
push(taskQueue, priorityLevel),
|
||||
isHostCallbackScheduled ||
|
||||
isPerformingWork ||
|
||||
((isHostCallbackScheduled = !0), (scheduledCallback = flushWork)));
|
||||
return priorityLevel;
|
||||
};
|
||||
exports.unstable_setDisableYieldValue = function (newValue) {
|
||||
disableYieldValue = newValue;
|
||||
};
|
||||
exports.unstable_shouldYield = shouldYieldToHost;
|
||||
exports.unstable_wrapCallback = function (callback) {
|
||||
var parentPriorityLevel = currentPriorityLevel;
|
||||
return function () {
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = parentPriorityLevel;
|
||||
try {
|
||||
return callback.apply(this, arguments);
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
};
|
||||
20
web/node_modules/scheduler/cjs/scheduler-unstable_mock.production.min.js
generated
vendored
Normal file
20
web/node_modules/scheduler/cjs/scheduler-unstable_mock.production.min.js
generated
vendored
Normal file
@@ -0,0 +1,20 @@
|
||||
/**
|
||||
* @license React
|
||||
* scheduler-unstable_mock.production.min.js
|
||||
*
|
||||
* Copyright (c) Facebook, Inc. and its affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
'use strict';function f(a,b){var c=a.length;a.push(b);a:for(;0<c;){var d=c-1>>>1,e=a[d];if(0<g(e,b))a[d]=b,a[c]=e,c=d;else break a}}function h(a){return 0===a.length?null:a[0]}function k(a){if(0===a.length)return null;var b=a[0],c=a.pop();if(c!==b){a[0]=c;a:for(var d=0,e=a.length,D=e>>>1;d<D;){var u=2*(d+1)-1,z=a[u],v=u+1,E=a[v];if(0>g(z,c))v<e&&0>g(E,z)?(a[d]=E,a[v]=c,d=v):(a[d]=z,a[u]=c,d=u);else if(v<e&&0>g(E,c))a[d]=E,a[v]=c,d=v;else break a}}return b}
|
||||
function g(a,b){var c=a.sortIndex-b.sortIndex;return 0!==c?c:a.id-b.id}var l=[],m=[],n=1,p=null,q=3,r=!1,t=!1,w=!1,x=0,y=null,A=null,B=-1,C=null,F=-1,G=!1,H=!1,I=!1,J=!1,K=!1;function L(a){for(var b=h(m);null!==b;){if(null===b.callback)k(m);else if(b.startTime<=a)k(m),b.sortIndex=b.expirationTime,f(l,b);else break;b=h(m)}}function M(a){w=!1;L(a);if(!t)if(null!==h(l))t=!0,y=N;else{var b=h(m);null!==b&&(a=b.startTime-a,A=M,B=x+a)}}
|
||||
function N(a,b){t=!1;w&&(w=!1,A=null,B=-1);r=!0;var c=q;try{L(b);for(p=h(l);null!==p&&(!(p.expirationTime>b)||a&&!O());){var d=p.callback;if("function"===typeof d){p.callback=null;q=p.priorityLevel;var e=d(p.expirationTime<=b);b=x;"function"===typeof e?p.callback=e:p===h(l)&&k(l);L(b)}else k(l);p=h(l)}if(null!==p)var D=!0;else{var u=h(m);if(null!==u){var z=u.startTime-b;A=M;B=x+z}D=!1}return D}finally{p=null,q=c,r=!1}}
|
||||
function O(){return 0===F&&null===C||-1!==F&&null!==C&&C.length>=F||J&&I?G=!0:!1}function P(){if(H)throw Error("Already flushing work.");if(null!==y){var a=y;H=!0;try{var b=!0;do b=a(!0,x);while(b);b||(y=null);return!0}finally{H=!1}}else return!1}exports.reset=function(){if(H)throw Error("Cannot reset while already flushing work.");x=0;A=y=null;B=-1;C=null;F=-1;I=H=G=!1};exports.unstable_IdlePriority=5;exports.unstable_ImmediatePriority=1;exports.unstable_LowPriority=4;
|
||||
exports.unstable_NormalPriority=3;exports.unstable_Profiling=null;exports.unstable_UserBlockingPriority=2;exports.unstable_advanceTime=function(a){"disabledLog"===console.log.name||K||(x+=a,null!==A&&B<=x&&(A(x),B=-1,A=null))};exports.unstable_cancelCallback=function(a){a.callback=null};exports.unstable_clearYields=function(){if(null===C)return[];var a=C;C=null;return a};exports.unstable_continueExecution=function(){t||r||(t=!0,y=N)};
|
||||
exports.unstable_flushAll=function(){if(null!==C)throw Error("Log is not empty. Assert on the log of yielded values before flushing additional work.");P();if(null!==C)throw Error("While flushing work, something yielded a value. Use an assertion helper to assert on the log of yielded values, e.g. expect(Scheduler).toFlushAndYield([...])");};exports.unstable_flushAllWithoutAsserting=P;
|
||||
exports.unstable_flushExpired=function(){if(H)throw Error("Already flushing work.");if(null!==y){H=!0;try{y(!1,x)||(y=null)}finally{H=!1}}};exports.unstable_flushNumberOfYields=function(a){if(H)throw Error("Already flushing work.");if(null!==y){var b=y;F=a;H=!0;try{a=!0;do a=b(!0,x);while(a&&!G);a||(y=null)}finally{F=-1,H=G=!1}}};
|
||||
exports.unstable_flushUntilNextPaint=function(){if(H)throw Error("Already flushing work.");if(null!==y){var a=y;J=!0;I=!1;H=!0;try{var b=!0;do b=a(!0,x);while(b&&!G);b||(y=null)}finally{H=G=J=!1}}};exports.unstable_forceFrameRate=function(){};exports.unstable_getCurrentPriorityLevel=function(){return q};exports.unstable_getFirstCallbackNode=function(){return h(l)};exports.unstable_next=function(a){switch(q){case 1:case 2:case 3:var b=3;break;default:b=q}var c=q;q=b;try{return a()}finally{q=c}};
|
||||
exports.unstable_now=function(){return x};exports.unstable_pauseExecution=function(){};exports.unstable_requestPaint=function(){I=!0};exports.unstable_runWithPriority=function(a,b){switch(a){case 1:case 2:case 3:case 4:case 5:break;default:a=3}var c=q;q=a;try{return b()}finally{q=c}};
|
||||
exports.unstable_scheduleCallback=function(a,b,c){var d=x;"object"===typeof c&&null!==c?(c=c.delay,c="number"===typeof c&&0<c?d+c:d):c=d;switch(a){case 1:var e=-1;break;case 2:e=250;break;case 5:e=1073741823;break;case 4:e=1E4;break;default:e=5E3}e=c+e;a={id:n++,callback:b,priorityLevel:a,startTime:c,expirationTime:e,sortIndex:-1};c>d?(a.sortIndex=c,f(m,a),null===h(l)&&a===h(m)&&(w?(A=null,B=-1):w=!0,A=M,B=x+(c-d))):(a.sortIndex=e,f(l,a),t||r||(t=!0,y=N));return a};
|
||||
exports.unstable_setDisableYieldValue=function(a){K=a};exports.unstable_shouldYield=O;exports.unstable_wrapCallback=function(a){var b=q;return function(){var c=q;q=b;try{return a.apply(this,arguments)}finally{q=c}}};exports.unstable_yieldValue=function(a){"disabledLog"===console.log.name||K||(null===C?C=[a]:C.push(a))};
|
||||
335
web/node_modules/scheduler/cjs/scheduler-unstable_post_task.development.js
generated
vendored
335
web/node_modules/scheduler/cjs/scheduler-unstable_post_task.development.js
generated
vendored
@@ -2,149 +2,206 @@
|
||||
* @license React
|
||||
* scheduler-unstable_post_task.development.js
|
||||
*
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
* Copyright (c) Facebook, Inc. and its affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
"production" !== process.env.NODE_ENV &&
|
||||
(function () {
|
||||
function runTask(priorityLevel, postTaskPriority, node, callback) {
|
||||
deadline = getCurrentTime() + 5;
|
||||
try {
|
||||
currentPriorityLevel_DEPRECATED = priorityLevel;
|
||||
var result = callback(!1);
|
||||
if ("function" === typeof result) {
|
||||
var continuationOptions = { signal: node._controller.signal },
|
||||
nextTask = runTask.bind(
|
||||
null,
|
||||
priorityLevel,
|
||||
postTaskPriority,
|
||||
node,
|
||||
result
|
||||
);
|
||||
void 0 !== scheduler.yield
|
||||
? scheduler
|
||||
.yield(continuationOptions)
|
||||
.then(nextTask)
|
||||
.catch(handleAbortError)
|
||||
: scheduler
|
||||
.postTask(nextTask, continuationOptions)
|
||||
.catch(handleAbortError);
|
||||
}
|
||||
} catch (error) {
|
||||
setTimeout(function () {
|
||||
throw error;
|
||||
});
|
||||
} finally {
|
||||
currentPriorityLevel_DEPRECATED = 3;
|
||||
}
|
||||
'use strict';
|
||||
|
||||
if (process.env.NODE_ENV !== "production") {
|
||||
(function() {
|
||||
'use strict';
|
||||
|
||||
// TODO: Use symbols?
|
||||
var ImmediatePriority = 1;
|
||||
var UserBlockingPriority = 2;
|
||||
var NormalPriority = 3;
|
||||
var LowPriority = 4;
|
||||
var IdlePriority = 5;
|
||||
|
||||
var perf = window.performance;
|
||||
var setTimeout = window.setTimeout; // Use experimental Chrome Scheduler postTask API.
|
||||
|
||||
var scheduler = global.scheduler;
|
||||
var getCurrentTime = perf.now.bind(perf);
|
||||
var unstable_now = getCurrentTime; // Scheduler periodically yields in case there is other work on the main
|
||||
// thread, like user events. By default, it yields multiple times per frame.
|
||||
// It does not attempt to align with frame boundaries, since most tasks don't
|
||||
// need to be frame aligned; for those that do, use requestAnimationFrame.
|
||||
|
||||
var yieldInterval = 5;
|
||||
var deadline = 0;
|
||||
var currentPriorityLevel_DEPRECATED = NormalPriority; // `isInputPending` is not available. Since we have no way of knowing if
|
||||
// there's pending input, always yield at the end of the frame.
|
||||
|
||||
function unstable_shouldYield() {
|
||||
return getCurrentTime() >= deadline;
|
||||
}
|
||||
function unstable_requestPaint() {// Since we yield every frame regardless, `requestPaint` has no effect.
|
||||
}
|
||||
function unstable_scheduleCallback(priorityLevel, callback, options) {
|
||||
var postTaskPriority;
|
||||
|
||||
switch (priorityLevel) {
|
||||
case ImmediatePriority:
|
||||
case UserBlockingPriority:
|
||||
postTaskPriority = 'user-blocking';
|
||||
break;
|
||||
|
||||
case LowPriority:
|
||||
case NormalPriority:
|
||||
postTaskPriority = 'user-visible';
|
||||
break;
|
||||
|
||||
case IdlePriority:
|
||||
postTaskPriority = 'background';
|
||||
break;
|
||||
|
||||
default:
|
||||
postTaskPriority = 'user-visible';
|
||||
break;
|
||||
}
|
||||
|
||||
var controller = new TaskController();
|
||||
var postTaskOptions = {
|
||||
priority: postTaskPriority,
|
||||
delay: typeof options === 'object' && options !== null ? options.delay : 0,
|
||||
signal: controller.signal
|
||||
};
|
||||
var node = {
|
||||
_controller: controller
|
||||
};
|
||||
scheduler.postTask(runTask.bind(null, priorityLevel, postTaskPriority, node, callback), postTaskOptions).catch(handleAbortError);
|
||||
return node;
|
||||
}
|
||||
|
||||
function runTask(priorityLevel, postTaskPriority, node, callback) {
|
||||
deadline = getCurrentTime() + yieldInterval;
|
||||
|
||||
try {
|
||||
currentPriorityLevel_DEPRECATED = priorityLevel;
|
||||
var _didTimeout_DEPRECATED = false;
|
||||
var result = callback(_didTimeout_DEPRECATED);
|
||||
|
||||
if (typeof result === 'function') {
|
||||
// Assume this is a continuation
|
||||
var continuation = result;
|
||||
var continuationController = new TaskController();
|
||||
var continuationOptions = {
|
||||
priority: postTaskPriority,
|
||||
signal: continuationController.signal
|
||||
}; // Update the original callback node's controller, since even though we're
|
||||
// posting a new task, conceptually it's the same one.
|
||||
|
||||
node._controller = continuationController;
|
||||
scheduler.postTask(runTask.bind(null, priorityLevel, postTaskPriority, node, continuation), continuationOptions).catch(handleAbortError);
|
||||
}
|
||||
function handleAbortError() {}
|
||||
var perf = window.performance,
|
||||
setTimeout = window.setTimeout,
|
||||
scheduler = global.scheduler,
|
||||
getCurrentTime = perf.now.bind(perf),
|
||||
deadline = 0,
|
||||
currentPriorityLevel_DEPRECATED = 3;
|
||||
exports.unstable_IdlePriority = 5;
|
||||
exports.unstable_ImmediatePriority = 1;
|
||||
exports.unstable_LowPriority = 4;
|
||||
exports.unstable_NormalPriority = 3;
|
||||
exports.unstable_Profiling = null;
|
||||
exports.unstable_UserBlockingPriority = 2;
|
||||
exports.unstable_cancelCallback = function (node) {
|
||||
node._controller.abort();
|
||||
};
|
||||
exports.unstable_forceFrameRate = function () {};
|
||||
exports.unstable_getCurrentPriorityLevel = function () {
|
||||
return currentPriorityLevel_DEPRECATED;
|
||||
};
|
||||
exports.unstable_next = function (callback) {
|
||||
switch (currentPriorityLevel_DEPRECATED) {
|
||||
case 1:
|
||||
case 2:
|
||||
case 3:
|
||||
var priorityLevel = 3;
|
||||
break;
|
||||
default:
|
||||
priorityLevel = currentPriorityLevel_DEPRECATED;
|
||||
}
|
||||
var previousPriorityLevel = currentPriorityLevel_DEPRECATED;
|
||||
currentPriorityLevel_DEPRECATED = priorityLevel;
|
||||
try {
|
||||
return callback();
|
||||
} finally {
|
||||
currentPriorityLevel_DEPRECATED = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
exports.unstable_now = getCurrentTime;
|
||||
exports.unstable_requestPaint = function () {};
|
||||
exports.unstable_runWithPriority = function (priorityLevel, callback) {
|
||||
var previousPriorityLevel = currentPriorityLevel_DEPRECATED;
|
||||
currentPriorityLevel_DEPRECATED = priorityLevel;
|
||||
try {
|
||||
return callback();
|
||||
} finally {
|
||||
currentPriorityLevel_DEPRECATED = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
exports.unstable_scheduleCallback = function (
|
||||
priorityLevel,
|
||||
callback,
|
||||
options
|
||||
) {
|
||||
switch (priorityLevel) {
|
||||
case 1:
|
||||
case 2:
|
||||
var postTaskPriority = "user-blocking";
|
||||
break;
|
||||
case 4:
|
||||
case 3:
|
||||
postTaskPriority = "user-visible";
|
||||
break;
|
||||
case 5:
|
||||
postTaskPriority = "background";
|
||||
break;
|
||||
default:
|
||||
postTaskPriority = "user-visible";
|
||||
}
|
||||
var controller = new TaskController({ priority: postTaskPriority });
|
||||
options = {
|
||||
delay:
|
||||
"object" === typeof options && null !== options ? options.delay : 0,
|
||||
signal: controller.signal
|
||||
};
|
||||
controller = { _controller: controller };
|
||||
scheduler
|
||||
.postTask(
|
||||
runTask.bind(
|
||||
null,
|
||||
priorityLevel,
|
||||
postTaskPriority,
|
||||
controller,
|
||||
callback
|
||||
),
|
||||
options
|
||||
)
|
||||
.catch(handleAbortError);
|
||||
return controller;
|
||||
};
|
||||
exports.unstable_shouldYield = function () {
|
||||
return getCurrentTime() >= deadline;
|
||||
};
|
||||
exports.unstable_wrapCallback = function (callback) {
|
||||
var parentPriorityLevel = currentPriorityLevel_DEPRECATED;
|
||||
return function () {
|
||||
var previousPriorityLevel = currentPriorityLevel_DEPRECATED;
|
||||
currentPriorityLevel_DEPRECATED = parentPriorityLevel;
|
||||
try {
|
||||
return callback();
|
||||
} finally {
|
||||
currentPriorityLevel_DEPRECATED = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
};
|
||||
} catch (error) {
|
||||
// We're inside a `postTask` promise. If we don't handle this error, then it
|
||||
// will trigger an "Unhandled promise rejection" error. We don't want that,
|
||||
// but we do want the default error reporting behavior that normal
|
||||
// (non-Promise) tasks get for unhandled errors.
|
||||
//
|
||||
// So we'll re-throw the error inside a regular browser task.
|
||||
setTimeout(function () {
|
||||
throw error;
|
||||
});
|
||||
} finally {
|
||||
currentPriorityLevel_DEPRECATED = NormalPriority;
|
||||
}
|
||||
}
|
||||
|
||||
function handleAbortError(error) {// Abort errors are an implementation detail. We don't expose the
|
||||
// TaskController to the user, nor do we expose the promise that is returned
|
||||
// from `postTask`. So we should suppress them, since there's no way for the
|
||||
// user to handle them.
|
||||
}
|
||||
|
||||
function unstable_cancelCallback(node) {
|
||||
var controller = node._controller;
|
||||
controller.abort();
|
||||
}
|
||||
function unstable_runWithPriority(priorityLevel, callback) {
|
||||
var previousPriorityLevel = currentPriorityLevel_DEPRECATED;
|
||||
currentPriorityLevel_DEPRECATED = priorityLevel;
|
||||
|
||||
try {
|
||||
return callback();
|
||||
} finally {
|
||||
currentPriorityLevel_DEPRECATED = previousPriorityLevel;
|
||||
}
|
||||
}
|
||||
function unstable_getCurrentPriorityLevel() {
|
||||
return currentPriorityLevel_DEPRECATED;
|
||||
}
|
||||
function unstable_next(callback) {
|
||||
var priorityLevel;
|
||||
|
||||
switch (currentPriorityLevel_DEPRECATED) {
|
||||
case ImmediatePriority:
|
||||
case UserBlockingPriority:
|
||||
case NormalPriority:
|
||||
// Shift down to normal priority
|
||||
priorityLevel = NormalPriority;
|
||||
break;
|
||||
|
||||
default:
|
||||
// Anything lower than normal priority should remain at the current level.
|
||||
priorityLevel = currentPriorityLevel_DEPRECATED;
|
||||
break;
|
||||
}
|
||||
|
||||
var previousPriorityLevel = currentPriorityLevel_DEPRECATED;
|
||||
currentPriorityLevel_DEPRECATED = priorityLevel;
|
||||
|
||||
try {
|
||||
return callback();
|
||||
} finally {
|
||||
currentPriorityLevel_DEPRECATED = previousPriorityLevel;
|
||||
}
|
||||
}
|
||||
function unstable_wrapCallback(callback) {
|
||||
var parentPriorityLevel = currentPriorityLevel_DEPRECATED;
|
||||
return function () {
|
||||
var previousPriorityLevel = currentPriorityLevel_DEPRECATED;
|
||||
currentPriorityLevel_DEPRECATED = parentPriorityLevel;
|
||||
|
||||
try {
|
||||
return callback();
|
||||
} finally {
|
||||
currentPriorityLevel_DEPRECATED = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
}
|
||||
function unstable_forceFrameRate() {}
|
||||
function unstable_pauseExecution() {}
|
||||
function unstable_continueExecution() {}
|
||||
function unstable_getFirstCallbackNode() {
|
||||
return null;
|
||||
} // Currently no profiling build
|
||||
|
||||
var unstable_Profiling = null;
|
||||
|
||||
exports.unstable_IdlePriority = IdlePriority;
|
||||
exports.unstable_ImmediatePriority = ImmediatePriority;
|
||||
exports.unstable_LowPriority = LowPriority;
|
||||
exports.unstable_NormalPriority = NormalPriority;
|
||||
exports.unstable_Profiling = unstable_Profiling;
|
||||
exports.unstable_UserBlockingPriority = UserBlockingPriority;
|
||||
exports.unstable_cancelCallback = unstable_cancelCallback;
|
||||
exports.unstable_continueExecution = unstable_continueExecution;
|
||||
exports.unstable_forceFrameRate = unstable_forceFrameRate;
|
||||
exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
|
||||
exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode;
|
||||
exports.unstable_next = unstable_next;
|
||||
exports.unstable_now = unstable_now;
|
||||
exports.unstable_pauseExecution = unstable_pauseExecution;
|
||||
exports.unstable_requestPaint = unstable_requestPaint;
|
||||
exports.unstable_runWithPriority = unstable_runWithPriority;
|
||||
exports.unstable_scheduleCallback = unstable_scheduleCallback;
|
||||
exports.unstable_shouldYield = unstable_shouldYield;
|
||||
exports.unstable_wrapCallback = unstable_wrapCallback;
|
||||
})();
|
||||
}
|
||||
|
||||
140
web/node_modules/scheduler/cjs/scheduler-unstable_post_task.production.js
generated
vendored
140
web/node_modules/scheduler/cjs/scheduler-unstable_post_task.production.js
generated
vendored
@@ -1,140 +0,0 @@
|
||||
/**
|
||||
* @license React
|
||||
* scheduler-unstable_post_task.production.js
|
||||
*
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
var perf = window.performance,
|
||||
setTimeout = window.setTimeout,
|
||||
scheduler = global.scheduler,
|
||||
getCurrentTime = perf.now.bind(perf),
|
||||
deadline = 0,
|
||||
currentPriorityLevel_DEPRECATED = 3;
|
||||
function runTask(priorityLevel, postTaskPriority, node, callback) {
|
||||
deadline = getCurrentTime() + 5;
|
||||
try {
|
||||
currentPriorityLevel_DEPRECATED = priorityLevel;
|
||||
var result = callback(!1);
|
||||
if ("function" === typeof result) {
|
||||
var continuationOptions = { signal: node._controller.signal },
|
||||
nextTask = runTask.bind(
|
||||
null,
|
||||
priorityLevel,
|
||||
postTaskPriority,
|
||||
node,
|
||||
result
|
||||
);
|
||||
void 0 !== scheduler.yield
|
||||
? scheduler
|
||||
.yield(continuationOptions)
|
||||
.then(nextTask)
|
||||
.catch(handleAbortError)
|
||||
: scheduler
|
||||
.postTask(nextTask, continuationOptions)
|
||||
.catch(handleAbortError);
|
||||
}
|
||||
} catch (error) {
|
||||
setTimeout(function () {
|
||||
throw error;
|
||||
});
|
||||
} finally {
|
||||
currentPriorityLevel_DEPRECATED = 3;
|
||||
}
|
||||
}
|
||||
function handleAbortError() {}
|
||||
exports.unstable_IdlePriority = 5;
|
||||
exports.unstable_ImmediatePriority = 1;
|
||||
exports.unstable_LowPriority = 4;
|
||||
exports.unstable_NormalPriority = 3;
|
||||
exports.unstable_Profiling = null;
|
||||
exports.unstable_UserBlockingPriority = 2;
|
||||
exports.unstable_cancelCallback = function (node) {
|
||||
node._controller.abort();
|
||||
};
|
||||
exports.unstable_forceFrameRate = function () {};
|
||||
exports.unstable_getCurrentPriorityLevel = function () {
|
||||
return currentPriorityLevel_DEPRECATED;
|
||||
};
|
||||
exports.unstable_next = function (callback) {
|
||||
switch (currentPriorityLevel_DEPRECATED) {
|
||||
case 1:
|
||||
case 2:
|
||||
case 3:
|
||||
var priorityLevel = 3;
|
||||
break;
|
||||
default:
|
||||
priorityLevel = currentPriorityLevel_DEPRECATED;
|
||||
}
|
||||
var previousPriorityLevel = currentPriorityLevel_DEPRECATED;
|
||||
currentPriorityLevel_DEPRECATED = priorityLevel;
|
||||
try {
|
||||
return callback();
|
||||
} finally {
|
||||
currentPriorityLevel_DEPRECATED = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
exports.unstable_now = getCurrentTime;
|
||||
exports.unstable_requestPaint = function () {};
|
||||
exports.unstable_runWithPriority = function (priorityLevel, callback) {
|
||||
var previousPriorityLevel = currentPriorityLevel_DEPRECATED;
|
||||
currentPriorityLevel_DEPRECATED = priorityLevel;
|
||||
try {
|
||||
return callback();
|
||||
} finally {
|
||||
currentPriorityLevel_DEPRECATED = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
exports.unstable_scheduleCallback = function (
|
||||
priorityLevel,
|
||||
callback,
|
||||
options
|
||||
) {
|
||||
switch (priorityLevel) {
|
||||
case 1:
|
||||
case 2:
|
||||
var postTaskPriority = "user-blocking";
|
||||
break;
|
||||
case 4:
|
||||
case 3:
|
||||
postTaskPriority = "user-visible";
|
||||
break;
|
||||
case 5:
|
||||
postTaskPriority = "background";
|
||||
break;
|
||||
default:
|
||||
postTaskPriority = "user-visible";
|
||||
}
|
||||
var controller = new TaskController({ priority: postTaskPriority });
|
||||
options = {
|
||||
delay: "object" === typeof options && null !== options ? options.delay : 0,
|
||||
signal: controller.signal
|
||||
};
|
||||
controller = { _controller: controller };
|
||||
scheduler
|
||||
.postTask(
|
||||
runTask.bind(null, priorityLevel, postTaskPriority, controller, callback),
|
||||
options
|
||||
)
|
||||
.catch(handleAbortError);
|
||||
return controller;
|
||||
};
|
||||
exports.unstable_shouldYield = function () {
|
||||
return getCurrentTime() >= deadline;
|
||||
};
|
||||
exports.unstable_wrapCallback = function (callback) {
|
||||
var parentPriorityLevel = currentPriorityLevel_DEPRECATED;
|
||||
return function () {
|
||||
var previousPriorityLevel = currentPriorityLevel_DEPRECATED;
|
||||
currentPriorityLevel_DEPRECATED = parentPriorityLevel;
|
||||
try {
|
||||
return callback();
|
||||
} finally {
|
||||
currentPriorityLevel_DEPRECATED = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
};
|
||||
14
web/node_modules/scheduler/cjs/scheduler-unstable_post_task.production.min.js
generated
vendored
Normal file
14
web/node_modules/scheduler/cjs/scheduler-unstable_post_task.production.min.js
generated
vendored
Normal file
@@ -0,0 +1,14 @@
|
||||
/**
|
||||
* @license React
|
||||
* scheduler-unstable_post_task.production.min.js
|
||||
*
|
||||
* Copyright (c) Facebook, Inc. and its affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
'use strict';var a=window.performance,g=window.setTimeout,h=global.scheduler,k=a.now.bind(a),l=0,m=3;function p(c,d,b,f){l=k()+5;try{m=c;var e=f(!1);if("function"===typeof e){var n=new TaskController,r={priority:d,signal:n.signal};b._controller=n;h.postTask(p.bind(null,c,d,b,e),r).catch(q)}}catch(t){g(function(){throw t;})}finally{m=3}}function q(){}exports.unstable_IdlePriority=5;exports.unstable_ImmediatePriority=1;exports.unstable_LowPriority=4;exports.unstable_NormalPriority=3;
|
||||
exports.unstable_Profiling=null;exports.unstable_UserBlockingPriority=2;exports.unstable_cancelCallback=function(c){c._controller.abort()};exports.unstable_continueExecution=function(){};exports.unstable_forceFrameRate=function(){};exports.unstable_getCurrentPriorityLevel=function(){return m};exports.unstable_getFirstCallbackNode=function(){return null};exports.unstable_next=function(c){switch(m){case 1:case 2:case 3:var d=3;break;default:d=m}var b=m;m=d;try{return c()}finally{m=b}};
|
||||
exports.unstable_now=k;exports.unstable_pauseExecution=function(){};exports.unstable_requestPaint=function(){};exports.unstable_runWithPriority=function(c,d){var b=m;m=c;try{return d()}finally{m=b}};
|
||||
exports.unstable_scheduleCallback=function(c,d,b){switch(c){case 1:case 2:var f="user-blocking";break;case 4:case 3:f="user-visible";break;case 5:f="background";break;default:f="user-visible"}var e=new TaskController;b={priority:f,delay:"object"===typeof b&&null!==b?b.delay:0,signal:e.signal};e={_controller:e};h.postTask(p.bind(null,c,f,e,d),b).catch(q);return e};exports.unstable_shouldYield=function(){return k()>=l};
|
||||
exports.unstable_wrapCallback=function(c){var d=m;return function(){var b=m;m=d;try{return c()}finally{m=b}}};
|
||||
964
web/node_modules/scheduler/cjs/scheduler.development.js
generated
vendored
964
web/node_modules/scheduler/cjs/scheduler.development.js
generated
vendored
@@ -2,363 +2,633 @@
|
||||
* @license React
|
||||
* scheduler.development.js
|
||||
*
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
* Copyright (c) Facebook, Inc. and its affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
"production" !== process.env.NODE_ENV &&
|
||||
(function () {
|
||||
function performWorkUntilDeadline() {
|
||||
needsPaint = !1;
|
||||
if (isMessageLoopRunning) {
|
||||
var currentTime = exports.unstable_now();
|
||||
startTime = currentTime;
|
||||
var hasMoreWork = !0;
|
||||
try {
|
||||
a: {
|
||||
isHostCallbackScheduled = !1;
|
||||
isHostTimeoutScheduled &&
|
||||
((isHostTimeoutScheduled = !1),
|
||||
localClearTimeout(taskTimeoutID),
|
||||
(taskTimeoutID = -1));
|
||||
isPerformingWork = !0;
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
try {
|
||||
b: {
|
||||
advanceTimers(currentTime);
|
||||
for (
|
||||
currentTask = peek(taskQueue);
|
||||
null !== currentTask &&
|
||||
!(
|
||||
currentTask.expirationTime > currentTime &&
|
||||
shouldYieldToHost()
|
||||
);
|
||||
'use strict';
|
||||
|
||||
) {
|
||||
var callback = currentTask.callback;
|
||||
if ("function" === typeof callback) {
|
||||
currentTask.callback = null;
|
||||
currentPriorityLevel = currentTask.priorityLevel;
|
||||
var continuationCallback = callback(
|
||||
currentTask.expirationTime <= currentTime
|
||||
);
|
||||
currentTime = exports.unstable_now();
|
||||
if ("function" === typeof continuationCallback) {
|
||||
currentTask.callback = continuationCallback;
|
||||
advanceTimers(currentTime);
|
||||
hasMoreWork = !0;
|
||||
break b;
|
||||
}
|
||||
currentTask === peek(taskQueue) && pop(taskQueue);
|
||||
advanceTimers(currentTime);
|
||||
} else pop(taskQueue);
|
||||
currentTask = peek(taskQueue);
|
||||
}
|
||||
if (null !== currentTask) hasMoreWork = !0;
|
||||
else {
|
||||
var firstTimer = peek(timerQueue);
|
||||
null !== firstTimer &&
|
||||
requestHostTimeout(
|
||||
handleTimeout,
|
||||
firstTimer.startTime - currentTime
|
||||
);
|
||||
hasMoreWork = !1;
|
||||
}
|
||||
}
|
||||
break a;
|
||||
} finally {
|
||||
(currentTask = null),
|
||||
(currentPriorityLevel = previousPriorityLevel),
|
||||
(isPerformingWork = !1);
|
||||
}
|
||||
hasMoreWork = void 0;
|
||||
}
|
||||
} finally {
|
||||
hasMoreWork
|
||||
? schedulePerformWorkUntilDeadline()
|
||||
: (isMessageLoopRunning = !1);
|
||||
}
|
||||
}
|
||||
}
|
||||
function push(heap, node) {
|
||||
var index = heap.length;
|
||||
heap.push(node);
|
||||
a: for (; 0 < index; ) {
|
||||
var parentIndex = (index - 1) >>> 1,
|
||||
parent = heap[parentIndex];
|
||||
if (0 < compare(parent, node))
|
||||
(heap[parentIndex] = node),
|
||||
(heap[index] = parent),
|
||||
(index = parentIndex);
|
||||
else break a;
|
||||
}
|
||||
}
|
||||
function peek(heap) {
|
||||
return 0 === heap.length ? null : heap[0];
|
||||
}
|
||||
function pop(heap) {
|
||||
if (0 === heap.length) return null;
|
||||
var first = heap[0],
|
||||
last = heap.pop();
|
||||
if (last !== first) {
|
||||
heap[0] = last;
|
||||
a: for (
|
||||
var index = 0, length = heap.length, halfLength = length >>> 1;
|
||||
index < halfLength;
|
||||
if (process.env.NODE_ENV !== "production") {
|
||||
(function() {
|
||||
|
||||
) {
|
||||
var leftIndex = 2 * (index + 1) - 1,
|
||||
left = heap[leftIndex],
|
||||
rightIndex = leftIndex + 1,
|
||||
right = heap[rightIndex];
|
||||
if (0 > compare(left, last))
|
||||
rightIndex < length && 0 > compare(right, left)
|
||||
? ((heap[index] = right),
|
||||
(heap[rightIndex] = last),
|
||||
(index = rightIndex))
|
||||
: ((heap[index] = left),
|
||||
(heap[leftIndex] = last),
|
||||
(index = leftIndex));
|
||||
else if (rightIndex < length && 0 > compare(right, last))
|
||||
(heap[index] = right),
|
||||
(heap[rightIndex] = last),
|
||||
(index = rightIndex);
|
||||
else break a;
|
||||
}
|
||||
}
|
||||
return first;
|
||||
}
|
||||
function compare(a, b) {
|
||||
var diff = a.sortIndex - b.sortIndex;
|
||||
return 0 !== diff ? diff : a.id - b.id;
|
||||
}
|
||||
function advanceTimers(currentTime) {
|
||||
for (var timer = peek(timerQueue); null !== timer; ) {
|
||||
if (null === timer.callback) pop(timerQueue);
|
||||
else if (timer.startTime <= currentTime)
|
||||
pop(timerQueue),
|
||||
(timer.sortIndex = timer.expirationTime),
|
||||
push(taskQueue, timer);
|
||||
else break;
|
||||
timer = peek(timerQueue);
|
||||
}
|
||||
}
|
||||
function handleTimeout(currentTime) {
|
||||
isHostTimeoutScheduled = !1;
|
||||
advanceTimers(currentTime);
|
||||
if (!isHostCallbackScheduled)
|
||||
if (null !== peek(taskQueue))
|
||||
(isHostCallbackScheduled = !0),
|
||||
isMessageLoopRunning ||
|
||||
((isMessageLoopRunning = !0), schedulePerformWorkUntilDeadline());
|
||||
else {
|
||||
var firstTimer = peek(timerQueue);
|
||||
null !== firstTimer &&
|
||||
requestHostTimeout(
|
||||
handleTimeout,
|
||||
firstTimer.startTime - currentTime
|
||||
);
|
||||
}
|
||||
}
|
||||
function shouldYieldToHost() {
|
||||
return needsPaint
|
||||
? !0
|
||||
: exports.unstable_now() - startTime < frameInterval
|
||||
? !1
|
||||
: !0;
|
||||
}
|
||||
function requestHostTimeout(callback, ms) {
|
||||
taskTimeoutID = localSetTimeout(function () {
|
||||
callback(exports.unstable_now());
|
||||
}, ms);
|
||||
}
|
||||
"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
|
||||
"function" ===
|
||||
typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart &&
|
||||
__REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
|
||||
exports.unstable_now = void 0;
|
||||
if (
|
||||
"object" === typeof performance &&
|
||||
"function" === typeof performance.now
|
||||
) {
|
||||
var localPerformance = performance;
|
||||
exports.unstable_now = function () {
|
||||
return localPerformance.now();
|
||||
};
|
||||
'use strict';
|
||||
|
||||
/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
|
||||
if (
|
||||
typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
|
||||
typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart ===
|
||||
'function'
|
||||
) {
|
||||
__REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
|
||||
}
|
||||
var enableSchedulerDebugging = false;
|
||||
var enableProfiling = false;
|
||||
var frameYieldMs = 5;
|
||||
|
||||
function push(heap, node) {
|
||||
var index = heap.length;
|
||||
heap.push(node);
|
||||
siftUp(heap, node, index);
|
||||
}
|
||||
function peek(heap) {
|
||||
return heap.length === 0 ? null : heap[0];
|
||||
}
|
||||
function pop(heap) {
|
||||
if (heap.length === 0) {
|
||||
return null;
|
||||
}
|
||||
|
||||
var first = heap[0];
|
||||
var last = heap.pop();
|
||||
|
||||
if (last !== first) {
|
||||
heap[0] = last;
|
||||
siftDown(heap, last, 0);
|
||||
}
|
||||
|
||||
return first;
|
||||
}
|
||||
|
||||
function siftUp(heap, node, i) {
|
||||
var index = i;
|
||||
|
||||
while (index > 0) {
|
||||
var parentIndex = index - 1 >>> 1;
|
||||
var parent = heap[parentIndex];
|
||||
|
||||
if (compare(parent, node) > 0) {
|
||||
// The parent is larger. Swap positions.
|
||||
heap[parentIndex] = node;
|
||||
heap[index] = parent;
|
||||
index = parentIndex;
|
||||
} else {
|
||||
var localDate = Date,
|
||||
initialTime = localDate.now();
|
||||
exports.unstable_now = function () {
|
||||
return localDate.now() - initialTime;
|
||||
};
|
||||
// The parent is smaller. Exit.
|
||||
return;
|
||||
}
|
||||
var taskQueue = [],
|
||||
timerQueue = [],
|
||||
taskIdCounter = 1,
|
||||
currentTask = null,
|
||||
currentPriorityLevel = 3,
|
||||
isPerformingWork = !1,
|
||||
isHostCallbackScheduled = !1,
|
||||
isHostTimeoutScheduled = !1,
|
||||
needsPaint = !1,
|
||||
localSetTimeout = "function" === typeof setTimeout ? setTimeout : null,
|
||||
localClearTimeout =
|
||||
"function" === typeof clearTimeout ? clearTimeout : null,
|
||||
localSetImmediate =
|
||||
"undefined" !== typeof setImmediate ? setImmediate : null,
|
||||
isMessageLoopRunning = !1,
|
||||
taskTimeoutID = -1,
|
||||
frameInterval = 5,
|
||||
startTime = -1;
|
||||
if ("function" === typeof localSetImmediate)
|
||||
var schedulePerformWorkUntilDeadline = function () {
|
||||
localSetImmediate(performWorkUntilDeadline);
|
||||
};
|
||||
else if ("undefined" !== typeof MessageChannel) {
|
||||
var channel = new MessageChannel(),
|
||||
port = channel.port2;
|
||||
channel.port1.onmessage = performWorkUntilDeadline;
|
||||
schedulePerformWorkUntilDeadline = function () {
|
||||
port.postMessage(null);
|
||||
};
|
||||
} else
|
||||
schedulePerformWorkUntilDeadline = function () {
|
||||
localSetTimeout(performWorkUntilDeadline, 0);
|
||||
};
|
||||
exports.unstable_IdlePriority = 5;
|
||||
exports.unstable_ImmediatePriority = 1;
|
||||
exports.unstable_LowPriority = 4;
|
||||
exports.unstable_NormalPriority = 3;
|
||||
exports.unstable_Profiling = null;
|
||||
exports.unstable_UserBlockingPriority = 2;
|
||||
exports.unstable_cancelCallback = function (task) {
|
||||
task.callback = null;
|
||||
};
|
||||
exports.unstable_forceFrameRate = function (fps) {
|
||||
0 > fps || 125 < fps
|
||||
? console.error(
|
||||
"forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported"
|
||||
)
|
||||
: (frameInterval = 0 < fps ? Math.floor(1e3 / fps) : 5);
|
||||
};
|
||||
exports.unstable_getCurrentPriorityLevel = function () {
|
||||
return currentPriorityLevel;
|
||||
};
|
||||
exports.unstable_next = function (eventHandler) {
|
||||
switch (currentPriorityLevel) {
|
||||
case 1:
|
||||
case 2:
|
||||
case 3:
|
||||
var priorityLevel = 3;
|
||||
break;
|
||||
default:
|
||||
priorityLevel = currentPriorityLevel;
|
||||
}
|
||||
}
|
||||
|
||||
function siftDown(heap, node, i) {
|
||||
var index = i;
|
||||
var length = heap.length;
|
||||
var halfLength = length >>> 1;
|
||||
|
||||
while (index < halfLength) {
|
||||
var leftIndex = (index + 1) * 2 - 1;
|
||||
var left = heap[leftIndex];
|
||||
var rightIndex = leftIndex + 1;
|
||||
var right = heap[rightIndex]; // If the left or right node is smaller, swap with the smaller of those.
|
||||
|
||||
if (compare(left, node) < 0) {
|
||||
if (rightIndex < length && compare(right, left) < 0) {
|
||||
heap[index] = right;
|
||||
heap[rightIndex] = node;
|
||||
index = rightIndex;
|
||||
} else {
|
||||
heap[index] = left;
|
||||
heap[leftIndex] = node;
|
||||
index = leftIndex;
|
||||
}
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = priorityLevel;
|
||||
} else if (rightIndex < length && compare(right, node) < 0) {
|
||||
heap[index] = right;
|
||||
heap[rightIndex] = node;
|
||||
index = rightIndex;
|
||||
} else {
|
||||
// Neither child is smaller. Exit.
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function compare(a, b) {
|
||||
// Compare sort index first, then task id.
|
||||
var diff = a.sortIndex - b.sortIndex;
|
||||
return diff !== 0 ? diff : a.id - b.id;
|
||||
}
|
||||
|
||||
// TODO: Use symbols?
|
||||
var ImmediatePriority = 1;
|
||||
var UserBlockingPriority = 2;
|
||||
var NormalPriority = 3;
|
||||
var LowPriority = 4;
|
||||
var IdlePriority = 5;
|
||||
|
||||
function markTaskErrored(task, ms) {
|
||||
}
|
||||
|
||||
/* eslint-disable no-var */
|
||||
|
||||
var hasPerformanceNow = typeof performance === 'object' && typeof performance.now === 'function';
|
||||
|
||||
if (hasPerformanceNow) {
|
||||
var localPerformance = performance;
|
||||
|
||||
exports.unstable_now = function () {
|
||||
return localPerformance.now();
|
||||
};
|
||||
} else {
|
||||
var localDate = Date;
|
||||
var initialTime = localDate.now();
|
||||
|
||||
exports.unstable_now = function () {
|
||||
return localDate.now() - initialTime;
|
||||
};
|
||||
} // Max 31 bit integer. The max integer size in V8 for 32-bit systems.
|
||||
// Math.pow(2, 30) - 1
|
||||
// 0b111111111111111111111111111111
|
||||
|
||||
|
||||
var maxSigned31BitInt = 1073741823; // Times out immediately
|
||||
|
||||
var IMMEDIATE_PRIORITY_TIMEOUT = -1; // Eventually times out
|
||||
|
||||
var USER_BLOCKING_PRIORITY_TIMEOUT = 250;
|
||||
var NORMAL_PRIORITY_TIMEOUT = 5000;
|
||||
var LOW_PRIORITY_TIMEOUT = 10000; // Never times out
|
||||
|
||||
var IDLE_PRIORITY_TIMEOUT = maxSigned31BitInt; // Tasks are stored on a min heap
|
||||
|
||||
var taskQueue = [];
|
||||
var timerQueue = []; // Incrementing id counter. Used to maintain insertion order.
|
||||
|
||||
var taskIdCounter = 1; // Pausing the scheduler is useful for debugging.
|
||||
var currentTask = null;
|
||||
var currentPriorityLevel = NormalPriority; // This is set while performing work, to prevent re-entrance.
|
||||
|
||||
var isPerformingWork = false;
|
||||
var isHostCallbackScheduled = false;
|
||||
var isHostTimeoutScheduled = false; // Capture local references to native APIs, in case a polyfill overrides them.
|
||||
|
||||
var localSetTimeout = typeof setTimeout === 'function' ? setTimeout : null;
|
||||
var localClearTimeout = typeof clearTimeout === 'function' ? clearTimeout : null;
|
||||
var localSetImmediate = typeof setImmediate !== 'undefined' ? setImmediate : null; // IE and Node.js + jsdom
|
||||
|
||||
var isInputPending = typeof navigator !== 'undefined' && navigator.scheduling !== undefined && navigator.scheduling.isInputPending !== undefined ? navigator.scheduling.isInputPending.bind(navigator.scheduling) : null;
|
||||
|
||||
function advanceTimers(currentTime) {
|
||||
// Check for tasks that are no longer delayed and add them to the queue.
|
||||
var timer = peek(timerQueue);
|
||||
|
||||
while (timer !== null) {
|
||||
if (timer.callback === null) {
|
||||
// Timer was cancelled.
|
||||
pop(timerQueue);
|
||||
} else if (timer.startTime <= currentTime) {
|
||||
// Timer fired. Transfer to the task queue.
|
||||
pop(timerQueue);
|
||||
timer.sortIndex = timer.expirationTime;
|
||||
push(taskQueue, timer);
|
||||
} else {
|
||||
// Remaining timers are pending.
|
||||
return;
|
||||
}
|
||||
|
||||
timer = peek(timerQueue);
|
||||
}
|
||||
}
|
||||
|
||||
function handleTimeout(currentTime) {
|
||||
isHostTimeoutScheduled = false;
|
||||
advanceTimers(currentTime);
|
||||
|
||||
if (!isHostCallbackScheduled) {
|
||||
if (peek(taskQueue) !== null) {
|
||||
isHostCallbackScheduled = true;
|
||||
requestHostCallback(flushWork);
|
||||
} else {
|
||||
var firstTimer = peek(timerQueue);
|
||||
|
||||
if (firstTimer !== null) {
|
||||
requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function flushWork(hasTimeRemaining, initialTime) {
|
||||
|
||||
|
||||
isHostCallbackScheduled = false;
|
||||
|
||||
if (isHostTimeoutScheduled) {
|
||||
// We scheduled a timeout but it's no longer needed. Cancel it.
|
||||
isHostTimeoutScheduled = false;
|
||||
cancelHostTimeout();
|
||||
}
|
||||
|
||||
isPerformingWork = true;
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
|
||||
try {
|
||||
if (enableProfiling) {
|
||||
try {
|
||||
return eventHandler();
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
exports.unstable_requestPaint = function () {
|
||||
needsPaint = !0;
|
||||
};
|
||||
exports.unstable_runWithPriority = function (priorityLevel, eventHandler) {
|
||||
switch (priorityLevel) {
|
||||
case 1:
|
||||
case 2:
|
||||
case 3:
|
||||
case 4:
|
||||
case 5:
|
||||
break;
|
||||
default:
|
||||
priorityLevel = 3;
|
||||
}
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = priorityLevel;
|
||||
try {
|
||||
return eventHandler();
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
exports.unstable_scheduleCallback = function (
|
||||
priorityLevel,
|
||||
callback,
|
||||
options
|
||||
) {
|
||||
var currentTime = exports.unstable_now();
|
||||
"object" === typeof options && null !== options
|
||||
? ((options = options.delay),
|
||||
(options =
|
||||
"number" === typeof options && 0 < options
|
||||
? currentTime + options
|
||||
: currentTime))
|
||||
: (options = currentTime);
|
||||
switch (priorityLevel) {
|
||||
case 1:
|
||||
var timeout = -1;
|
||||
break;
|
||||
case 2:
|
||||
timeout = 250;
|
||||
break;
|
||||
case 5:
|
||||
timeout = 1073741823;
|
||||
break;
|
||||
case 4:
|
||||
timeout = 1e4;
|
||||
break;
|
||||
default:
|
||||
timeout = 5e3;
|
||||
}
|
||||
timeout = options + timeout;
|
||||
priorityLevel = {
|
||||
id: taskIdCounter++,
|
||||
callback: callback,
|
||||
priorityLevel: priorityLevel,
|
||||
startTime: options,
|
||||
expirationTime: timeout,
|
||||
sortIndex: -1
|
||||
};
|
||||
options > currentTime
|
||||
? ((priorityLevel.sortIndex = options),
|
||||
push(timerQueue, priorityLevel),
|
||||
null === peek(taskQueue) &&
|
||||
priorityLevel === peek(timerQueue) &&
|
||||
(isHostTimeoutScheduled
|
||||
? (localClearTimeout(taskTimeoutID), (taskTimeoutID = -1))
|
||||
: (isHostTimeoutScheduled = !0),
|
||||
requestHostTimeout(handleTimeout, options - currentTime)))
|
||||
: ((priorityLevel.sortIndex = timeout),
|
||||
push(taskQueue, priorityLevel),
|
||||
isHostCallbackScheduled ||
|
||||
isPerformingWork ||
|
||||
((isHostCallbackScheduled = !0),
|
||||
isMessageLoopRunning ||
|
||||
((isMessageLoopRunning = !0),
|
||||
schedulePerformWorkUntilDeadline())));
|
||||
return priorityLevel;
|
||||
};
|
||||
exports.unstable_shouldYield = shouldYieldToHost;
|
||||
exports.unstable_wrapCallback = function (callback) {
|
||||
var parentPriorityLevel = currentPriorityLevel;
|
||||
return function () {
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = parentPriorityLevel;
|
||||
try {
|
||||
return callback.apply(this, arguments);
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
return workLoop(hasTimeRemaining, initialTime);
|
||||
} catch (error) {
|
||||
if (currentTask !== null) {
|
||||
var currentTime = exports.unstable_now();
|
||||
markTaskErrored(currentTask, currentTime);
|
||||
currentTask.isQueued = false;
|
||||
}
|
||||
};
|
||||
};
|
||||
"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
|
||||
"function" ===
|
||||
typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop &&
|
||||
__REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
|
||||
|
||||
throw error;
|
||||
}
|
||||
} else {
|
||||
// No catch in prod code path.
|
||||
return workLoop(hasTimeRemaining, initialTime);
|
||||
}
|
||||
} finally {
|
||||
currentTask = null;
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
isPerformingWork = false;
|
||||
}
|
||||
}
|
||||
|
||||
function workLoop(hasTimeRemaining, initialTime) {
|
||||
var currentTime = initialTime;
|
||||
advanceTimers(currentTime);
|
||||
currentTask = peek(taskQueue);
|
||||
|
||||
while (currentTask !== null && !(enableSchedulerDebugging )) {
|
||||
if (currentTask.expirationTime > currentTime && (!hasTimeRemaining || shouldYieldToHost())) {
|
||||
// This currentTask hasn't expired, and we've reached the deadline.
|
||||
break;
|
||||
}
|
||||
|
||||
var callback = currentTask.callback;
|
||||
|
||||
if (typeof callback === 'function') {
|
||||
currentTask.callback = null;
|
||||
currentPriorityLevel = currentTask.priorityLevel;
|
||||
var didUserCallbackTimeout = currentTask.expirationTime <= currentTime;
|
||||
|
||||
var continuationCallback = callback(didUserCallbackTimeout);
|
||||
currentTime = exports.unstable_now();
|
||||
|
||||
if (typeof continuationCallback === 'function') {
|
||||
currentTask.callback = continuationCallback;
|
||||
} else {
|
||||
|
||||
if (currentTask === peek(taskQueue)) {
|
||||
pop(taskQueue);
|
||||
}
|
||||
}
|
||||
|
||||
advanceTimers(currentTime);
|
||||
} else {
|
||||
pop(taskQueue);
|
||||
}
|
||||
|
||||
currentTask = peek(taskQueue);
|
||||
} // Return whether there's additional work
|
||||
|
||||
|
||||
if (currentTask !== null) {
|
||||
return true;
|
||||
} else {
|
||||
var firstTimer = peek(timerQueue);
|
||||
|
||||
if (firstTimer !== null) {
|
||||
requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
function unstable_runWithPriority(priorityLevel, eventHandler) {
|
||||
switch (priorityLevel) {
|
||||
case ImmediatePriority:
|
||||
case UserBlockingPriority:
|
||||
case NormalPriority:
|
||||
case LowPriority:
|
||||
case IdlePriority:
|
||||
break;
|
||||
|
||||
default:
|
||||
priorityLevel = NormalPriority;
|
||||
}
|
||||
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = priorityLevel;
|
||||
|
||||
try {
|
||||
return eventHandler();
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
}
|
||||
}
|
||||
|
||||
function unstable_next(eventHandler) {
|
||||
var priorityLevel;
|
||||
|
||||
switch (currentPriorityLevel) {
|
||||
case ImmediatePriority:
|
||||
case UserBlockingPriority:
|
||||
case NormalPriority:
|
||||
// Shift down to normal priority
|
||||
priorityLevel = NormalPriority;
|
||||
break;
|
||||
|
||||
default:
|
||||
// Anything lower than normal priority should remain at the current level.
|
||||
priorityLevel = currentPriorityLevel;
|
||||
break;
|
||||
}
|
||||
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = priorityLevel;
|
||||
|
||||
try {
|
||||
return eventHandler();
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
}
|
||||
}
|
||||
|
||||
function unstable_wrapCallback(callback) {
|
||||
var parentPriorityLevel = currentPriorityLevel;
|
||||
return function () {
|
||||
// This is a fork of runWithPriority, inlined for performance.
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = parentPriorityLevel;
|
||||
|
||||
try {
|
||||
return callback.apply(this, arguments);
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
function unstable_scheduleCallback(priorityLevel, callback, options) {
|
||||
var currentTime = exports.unstable_now();
|
||||
var startTime;
|
||||
|
||||
if (typeof options === 'object' && options !== null) {
|
||||
var delay = options.delay;
|
||||
|
||||
if (typeof delay === 'number' && delay > 0) {
|
||||
startTime = currentTime + delay;
|
||||
} else {
|
||||
startTime = currentTime;
|
||||
}
|
||||
} else {
|
||||
startTime = currentTime;
|
||||
}
|
||||
|
||||
var timeout;
|
||||
|
||||
switch (priorityLevel) {
|
||||
case ImmediatePriority:
|
||||
timeout = IMMEDIATE_PRIORITY_TIMEOUT;
|
||||
break;
|
||||
|
||||
case UserBlockingPriority:
|
||||
timeout = USER_BLOCKING_PRIORITY_TIMEOUT;
|
||||
break;
|
||||
|
||||
case IdlePriority:
|
||||
timeout = IDLE_PRIORITY_TIMEOUT;
|
||||
break;
|
||||
|
||||
case LowPriority:
|
||||
timeout = LOW_PRIORITY_TIMEOUT;
|
||||
break;
|
||||
|
||||
case NormalPriority:
|
||||
default:
|
||||
timeout = NORMAL_PRIORITY_TIMEOUT;
|
||||
break;
|
||||
}
|
||||
|
||||
var expirationTime = startTime + timeout;
|
||||
var newTask = {
|
||||
id: taskIdCounter++,
|
||||
callback: callback,
|
||||
priorityLevel: priorityLevel,
|
||||
startTime: startTime,
|
||||
expirationTime: expirationTime,
|
||||
sortIndex: -1
|
||||
};
|
||||
|
||||
if (startTime > currentTime) {
|
||||
// This is a delayed task.
|
||||
newTask.sortIndex = startTime;
|
||||
push(timerQueue, newTask);
|
||||
|
||||
if (peek(taskQueue) === null && newTask === peek(timerQueue)) {
|
||||
// All tasks are delayed, and this is the task with the earliest delay.
|
||||
if (isHostTimeoutScheduled) {
|
||||
// Cancel an existing timeout.
|
||||
cancelHostTimeout();
|
||||
} else {
|
||||
isHostTimeoutScheduled = true;
|
||||
} // Schedule a timeout.
|
||||
|
||||
|
||||
requestHostTimeout(handleTimeout, startTime - currentTime);
|
||||
}
|
||||
} else {
|
||||
newTask.sortIndex = expirationTime;
|
||||
push(taskQueue, newTask);
|
||||
// wait until the next time we yield.
|
||||
|
||||
|
||||
if (!isHostCallbackScheduled && !isPerformingWork) {
|
||||
isHostCallbackScheduled = true;
|
||||
requestHostCallback(flushWork);
|
||||
}
|
||||
}
|
||||
|
||||
return newTask;
|
||||
}
|
||||
|
||||
function unstable_pauseExecution() {
|
||||
}
|
||||
|
||||
function unstable_continueExecution() {
|
||||
|
||||
if (!isHostCallbackScheduled && !isPerformingWork) {
|
||||
isHostCallbackScheduled = true;
|
||||
requestHostCallback(flushWork);
|
||||
}
|
||||
}
|
||||
|
||||
function unstable_getFirstCallbackNode() {
|
||||
return peek(taskQueue);
|
||||
}
|
||||
|
||||
function unstable_cancelCallback(task) {
|
||||
// remove from the queue because you can't remove arbitrary nodes from an
|
||||
// array based heap, only the first one.)
|
||||
|
||||
|
||||
task.callback = null;
|
||||
}
|
||||
|
||||
function unstable_getCurrentPriorityLevel() {
|
||||
return currentPriorityLevel;
|
||||
}
|
||||
|
||||
var isMessageLoopRunning = false;
|
||||
var scheduledHostCallback = null;
|
||||
var taskTimeoutID = -1; // Scheduler periodically yields in case there is other work on the main
|
||||
// thread, like user events. By default, it yields multiple times per frame.
|
||||
// It does not attempt to align with frame boundaries, since most tasks don't
|
||||
// need to be frame aligned; for those that do, use requestAnimationFrame.
|
||||
|
||||
var frameInterval = frameYieldMs;
|
||||
var startTime = -1;
|
||||
|
||||
function shouldYieldToHost() {
|
||||
var timeElapsed = exports.unstable_now() - startTime;
|
||||
|
||||
if (timeElapsed < frameInterval) {
|
||||
// The main thread has only been blocked for a really short amount of time;
|
||||
// smaller than a single frame. Don't yield yet.
|
||||
return false;
|
||||
} // The main thread has been blocked for a non-negligible amount of time. We
|
||||
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
function requestPaint() {
|
||||
|
||||
}
|
||||
|
||||
function forceFrameRate(fps) {
|
||||
if (fps < 0 || fps > 125) {
|
||||
// Using console['error'] to evade Babel and ESLint
|
||||
console['error']('forceFrameRate takes a positive int between 0 and 125, ' + 'forcing frame rates higher than 125 fps is not supported');
|
||||
return;
|
||||
}
|
||||
|
||||
if (fps > 0) {
|
||||
frameInterval = Math.floor(1000 / fps);
|
||||
} else {
|
||||
// reset the framerate
|
||||
frameInterval = frameYieldMs;
|
||||
}
|
||||
}
|
||||
|
||||
var performWorkUntilDeadline = function () {
|
||||
if (scheduledHostCallback !== null) {
|
||||
var currentTime = exports.unstable_now(); // Keep track of the start time so we can measure how long the main thread
|
||||
// has been blocked.
|
||||
|
||||
startTime = currentTime;
|
||||
var hasTimeRemaining = true; // If a scheduler task throws, exit the current browser task so the
|
||||
// error can be observed.
|
||||
//
|
||||
// Intentionally not using a try-catch, since that makes some debugging
|
||||
// techniques harder. Instead, if `scheduledHostCallback` errors, then
|
||||
// `hasMoreWork` will remain true, and we'll continue the work loop.
|
||||
|
||||
var hasMoreWork = true;
|
||||
|
||||
try {
|
||||
hasMoreWork = scheduledHostCallback(hasTimeRemaining, currentTime);
|
||||
} finally {
|
||||
if (hasMoreWork) {
|
||||
// If there's more work, schedule the next message event at the end
|
||||
// of the preceding one.
|
||||
schedulePerformWorkUntilDeadline();
|
||||
} else {
|
||||
isMessageLoopRunning = false;
|
||||
scheduledHostCallback = null;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
isMessageLoopRunning = false;
|
||||
} // Yielding to the browser will give it a chance to paint, so we can
|
||||
};
|
||||
|
||||
var schedulePerformWorkUntilDeadline;
|
||||
|
||||
if (typeof localSetImmediate === 'function') {
|
||||
// Node.js and old IE.
|
||||
// There's a few reasons for why we prefer setImmediate.
|
||||
//
|
||||
// Unlike MessageChannel, it doesn't prevent a Node.js process from exiting.
|
||||
// (Even though this is a DOM fork of the Scheduler, you could get here
|
||||
// with a mix of Node.js 15+, which has a MessageChannel, and jsdom.)
|
||||
// https://github.com/facebook/react/issues/20756
|
||||
//
|
||||
// But also, it runs earlier which is the semantic we want.
|
||||
// If other browsers ever implement it, it's better to use it.
|
||||
// Although both of these would be inferior to native scheduling.
|
||||
schedulePerformWorkUntilDeadline = function () {
|
||||
localSetImmediate(performWorkUntilDeadline);
|
||||
};
|
||||
} else if (typeof MessageChannel !== 'undefined') {
|
||||
// DOM and Worker environments.
|
||||
// We prefer MessageChannel because of the 4ms setTimeout clamping.
|
||||
var channel = new MessageChannel();
|
||||
var port = channel.port2;
|
||||
channel.port1.onmessage = performWorkUntilDeadline;
|
||||
|
||||
schedulePerformWorkUntilDeadline = function () {
|
||||
port.postMessage(null);
|
||||
};
|
||||
} else {
|
||||
// We should only fallback here in non-browser environments.
|
||||
schedulePerformWorkUntilDeadline = function () {
|
||||
localSetTimeout(performWorkUntilDeadline, 0);
|
||||
};
|
||||
}
|
||||
|
||||
function requestHostCallback(callback) {
|
||||
scheduledHostCallback = callback;
|
||||
|
||||
if (!isMessageLoopRunning) {
|
||||
isMessageLoopRunning = true;
|
||||
schedulePerformWorkUntilDeadline();
|
||||
}
|
||||
}
|
||||
|
||||
function requestHostTimeout(callback, ms) {
|
||||
taskTimeoutID = localSetTimeout(function () {
|
||||
callback(exports.unstable_now());
|
||||
}, ms);
|
||||
}
|
||||
|
||||
function cancelHostTimeout() {
|
||||
localClearTimeout(taskTimeoutID);
|
||||
taskTimeoutID = -1;
|
||||
}
|
||||
|
||||
var unstable_requestPaint = requestPaint;
|
||||
var unstable_Profiling = null;
|
||||
|
||||
exports.unstable_IdlePriority = IdlePriority;
|
||||
exports.unstable_ImmediatePriority = ImmediatePriority;
|
||||
exports.unstable_LowPriority = LowPriority;
|
||||
exports.unstable_NormalPriority = NormalPriority;
|
||||
exports.unstable_Profiling = unstable_Profiling;
|
||||
exports.unstable_UserBlockingPriority = UserBlockingPriority;
|
||||
exports.unstable_cancelCallback = unstable_cancelCallback;
|
||||
exports.unstable_continueExecution = unstable_continueExecution;
|
||||
exports.unstable_forceFrameRate = forceFrameRate;
|
||||
exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
|
||||
exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode;
|
||||
exports.unstable_next = unstable_next;
|
||||
exports.unstable_pauseExecution = unstable_pauseExecution;
|
||||
exports.unstable_requestPaint = unstable_requestPaint;
|
||||
exports.unstable_runWithPriority = unstable_runWithPriority;
|
||||
exports.unstable_scheduleCallback = unstable_scheduleCallback;
|
||||
exports.unstable_shouldYield = shouldYieldToHost;
|
||||
exports.unstable_wrapCallback = unstable_wrapCallback;
|
||||
/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
|
||||
if (
|
||||
typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
|
||||
typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop ===
|
||||
'function'
|
||||
) {
|
||||
__REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
|
||||
}
|
||||
|
||||
})();
|
||||
}
|
||||
|
||||
350
web/node_modules/scheduler/cjs/scheduler.native.development.js
generated
vendored
350
web/node_modules/scheduler/cjs/scheduler.native.development.js
generated
vendored
@@ -1,350 +0,0 @@
|
||||
/**
|
||||
* @license React
|
||||
* scheduler.native.development.js
|
||||
*
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
"production" !== process.env.NODE_ENV &&
|
||||
(function () {
|
||||
function performWorkUntilDeadline() {
|
||||
needsPaint = !1;
|
||||
if (isMessageLoopRunning) {
|
||||
var currentTime = getCurrentTime();
|
||||
startTime = currentTime;
|
||||
var hasMoreWork = !0;
|
||||
try {
|
||||
a: {
|
||||
isHostCallbackScheduled = !1;
|
||||
isHostTimeoutScheduled &&
|
||||
((isHostTimeoutScheduled = !1),
|
||||
localClearTimeout(taskTimeoutID),
|
||||
(taskTimeoutID = -1));
|
||||
isPerformingWork = !0;
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
try {
|
||||
b: {
|
||||
advanceTimers(currentTime);
|
||||
for (
|
||||
currentTask = peek(taskQueue);
|
||||
null !== currentTask &&
|
||||
!(
|
||||
currentTask.expirationTime > currentTime &&
|
||||
shouldYieldToHost()
|
||||
);
|
||||
|
||||
) {
|
||||
var callback = currentTask.callback;
|
||||
if ("function" === typeof callback) {
|
||||
currentTask.callback = null;
|
||||
currentPriorityLevel = currentTask.priorityLevel;
|
||||
var continuationCallback = callback(
|
||||
currentTask.expirationTime <= currentTime
|
||||
);
|
||||
currentTime = getCurrentTime();
|
||||
if ("function" === typeof continuationCallback) {
|
||||
currentTask.callback = continuationCallback;
|
||||
advanceTimers(currentTime);
|
||||
hasMoreWork = !0;
|
||||
break b;
|
||||
}
|
||||
currentTask === peek(taskQueue) && pop(taskQueue);
|
||||
advanceTimers(currentTime);
|
||||
} else pop(taskQueue);
|
||||
currentTask = peek(taskQueue);
|
||||
}
|
||||
if (null !== currentTask) hasMoreWork = !0;
|
||||
else {
|
||||
var firstTimer = peek(timerQueue);
|
||||
null !== firstTimer &&
|
||||
requestHostTimeout(
|
||||
handleTimeout,
|
||||
firstTimer.startTime - currentTime
|
||||
);
|
||||
hasMoreWork = !1;
|
||||
}
|
||||
}
|
||||
break a;
|
||||
} finally {
|
||||
(currentTask = null),
|
||||
(currentPriorityLevel = previousPriorityLevel),
|
||||
(isPerformingWork = !1);
|
||||
}
|
||||
hasMoreWork = void 0;
|
||||
}
|
||||
} finally {
|
||||
hasMoreWork
|
||||
? schedulePerformWorkUntilDeadline()
|
||||
: (isMessageLoopRunning = !1);
|
||||
}
|
||||
}
|
||||
}
|
||||
function push(heap, node) {
|
||||
var index = heap.length;
|
||||
heap.push(node);
|
||||
a: for (; 0 < index; ) {
|
||||
var parentIndex = (index - 1) >>> 1,
|
||||
parent = heap[parentIndex];
|
||||
if (0 < compare(parent, node))
|
||||
(heap[parentIndex] = node),
|
||||
(heap[index] = parent),
|
||||
(index = parentIndex);
|
||||
else break a;
|
||||
}
|
||||
}
|
||||
function peek(heap) {
|
||||
return 0 === heap.length ? null : heap[0];
|
||||
}
|
||||
function pop(heap) {
|
||||
if (0 === heap.length) return null;
|
||||
var first = heap[0],
|
||||
last = heap.pop();
|
||||
if (last !== first) {
|
||||
heap[0] = last;
|
||||
a: for (
|
||||
var index = 0, length = heap.length, halfLength = length >>> 1;
|
||||
index < halfLength;
|
||||
|
||||
) {
|
||||
var leftIndex = 2 * (index + 1) - 1,
|
||||
left = heap[leftIndex],
|
||||
rightIndex = leftIndex + 1,
|
||||
right = heap[rightIndex];
|
||||
if (0 > compare(left, last))
|
||||
rightIndex < length && 0 > compare(right, left)
|
||||
? ((heap[index] = right),
|
||||
(heap[rightIndex] = last),
|
||||
(index = rightIndex))
|
||||
: ((heap[index] = left),
|
||||
(heap[leftIndex] = last),
|
||||
(index = leftIndex));
|
||||
else if (rightIndex < length && 0 > compare(right, last))
|
||||
(heap[index] = right),
|
||||
(heap[rightIndex] = last),
|
||||
(index = rightIndex);
|
||||
else break a;
|
||||
}
|
||||
}
|
||||
return first;
|
||||
}
|
||||
function compare(a, b) {
|
||||
var diff = a.sortIndex - b.sortIndex;
|
||||
return 0 !== diff ? diff : a.id - b.id;
|
||||
}
|
||||
function advanceTimers(currentTime) {
|
||||
for (var timer = peek(timerQueue); null !== timer; ) {
|
||||
if (null === timer.callback) pop(timerQueue);
|
||||
else if (timer.startTime <= currentTime)
|
||||
pop(timerQueue),
|
||||
(timer.sortIndex = timer.expirationTime),
|
||||
push(taskQueue, timer);
|
||||
else break;
|
||||
timer = peek(timerQueue);
|
||||
}
|
||||
}
|
||||
function handleTimeout(currentTime) {
|
||||
isHostTimeoutScheduled = !1;
|
||||
advanceTimers(currentTime);
|
||||
if (!isHostCallbackScheduled)
|
||||
if (null !== peek(taskQueue))
|
||||
(isHostCallbackScheduled = !0),
|
||||
isMessageLoopRunning ||
|
||||
((isMessageLoopRunning = !0), schedulePerformWorkUntilDeadline());
|
||||
else {
|
||||
var firstTimer = peek(timerQueue);
|
||||
null !== firstTimer &&
|
||||
requestHostTimeout(
|
||||
handleTimeout,
|
||||
firstTimer.startTime - currentTime
|
||||
);
|
||||
}
|
||||
}
|
||||
function unstable_scheduleCallback$1(priorityLevel, callback, options) {
|
||||
var currentTime = getCurrentTime();
|
||||
"object" === typeof options && null !== options
|
||||
? ((options = options.delay),
|
||||
(options =
|
||||
"number" === typeof options && 0 < options
|
||||
? currentTime + options
|
||||
: currentTime))
|
||||
: (options = currentTime);
|
||||
switch (priorityLevel) {
|
||||
case 1:
|
||||
var timeout = -1;
|
||||
break;
|
||||
case 2:
|
||||
timeout = 250;
|
||||
break;
|
||||
case 5:
|
||||
timeout = 1073741823;
|
||||
break;
|
||||
case 4:
|
||||
timeout = 1e4;
|
||||
break;
|
||||
default:
|
||||
timeout = 5e3;
|
||||
}
|
||||
timeout = options + timeout;
|
||||
priorityLevel = {
|
||||
id: taskIdCounter++,
|
||||
callback: callback,
|
||||
priorityLevel: priorityLevel,
|
||||
startTime: options,
|
||||
expirationTime: timeout,
|
||||
sortIndex: -1
|
||||
};
|
||||
options > currentTime
|
||||
? ((priorityLevel.sortIndex = options),
|
||||
push(timerQueue, priorityLevel),
|
||||
null === peek(taskQueue) &&
|
||||
priorityLevel === peek(timerQueue) &&
|
||||
(isHostTimeoutScheduled
|
||||
? (localClearTimeout(taskTimeoutID), (taskTimeoutID = -1))
|
||||
: (isHostTimeoutScheduled = !0),
|
||||
requestHostTimeout(handleTimeout, options - currentTime)))
|
||||
: ((priorityLevel.sortIndex = timeout),
|
||||
push(taskQueue, priorityLevel),
|
||||
isHostCallbackScheduled ||
|
||||
isPerformingWork ||
|
||||
((isHostCallbackScheduled = !0),
|
||||
isMessageLoopRunning ||
|
||||
((isMessageLoopRunning = !0),
|
||||
schedulePerformWorkUntilDeadline())));
|
||||
return priorityLevel;
|
||||
}
|
||||
function unstable_cancelCallback$1(task) {
|
||||
task.callback = null;
|
||||
}
|
||||
function unstable_getCurrentPriorityLevel$1() {
|
||||
return currentPriorityLevel;
|
||||
}
|
||||
function shouldYieldToHost() {
|
||||
return needsPaint
|
||||
? !0
|
||||
: getCurrentTime() - startTime < frameInterval
|
||||
? !1
|
||||
: !0;
|
||||
}
|
||||
function requestPaint() {
|
||||
needsPaint = !0;
|
||||
}
|
||||
function requestHostTimeout(callback, ms) {
|
||||
taskTimeoutID = localSetTimeout(function () {
|
||||
callback(getCurrentTime());
|
||||
}, ms);
|
||||
}
|
||||
function throwNotImplemented() {
|
||||
throw Error("Not implemented.");
|
||||
}
|
||||
if (
|
||||
"object" === typeof performance &&
|
||||
"function" === typeof performance.now
|
||||
) {
|
||||
var localPerformance = performance;
|
||||
var getCurrentTime = function () {
|
||||
return localPerformance.now();
|
||||
};
|
||||
} else {
|
||||
var localDate = Date,
|
||||
initialTime = localDate.now();
|
||||
getCurrentTime = function () {
|
||||
return localDate.now() - initialTime;
|
||||
};
|
||||
}
|
||||
var taskQueue = [],
|
||||
timerQueue = [],
|
||||
taskIdCounter = 1,
|
||||
currentTask = null,
|
||||
currentPriorityLevel = 3,
|
||||
isPerformingWork = !1,
|
||||
isHostCallbackScheduled = !1,
|
||||
isHostTimeoutScheduled = !1,
|
||||
needsPaint = !1,
|
||||
localSetTimeout = "function" === typeof setTimeout ? setTimeout : null,
|
||||
localClearTimeout =
|
||||
"function" === typeof clearTimeout ? clearTimeout : null,
|
||||
localSetImmediate =
|
||||
"undefined" !== typeof setImmediate ? setImmediate : null,
|
||||
isMessageLoopRunning = !1,
|
||||
taskTimeoutID = -1,
|
||||
frameInterval = 5,
|
||||
startTime = -1;
|
||||
if ("function" === typeof localSetImmediate)
|
||||
var schedulePerformWorkUntilDeadline = function () {
|
||||
localSetImmediate(performWorkUntilDeadline);
|
||||
};
|
||||
else if ("undefined" !== typeof MessageChannel) {
|
||||
var channel = new MessageChannel(),
|
||||
port = channel.port2;
|
||||
channel.port1.onmessage = performWorkUntilDeadline;
|
||||
schedulePerformWorkUntilDeadline = function () {
|
||||
port.postMessage(null);
|
||||
};
|
||||
} else
|
||||
schedulePerformWorkUntilDeadline = function () {
|
||||
localSetTimeout(performWorkUntilDeadline, 0);
|
||||
};
|
||||
channel =
|
||||
"undefined" !== typeof nativeRuntimeScheduler
|
||||
? nativeRuntimeScheduler.unstable_UserBlockingPriority
|
||||
: 2;
|
||||
var unstable_NormalPriority =
|
||||
"undefined" !== typeof nativeRuntimeScheduler
|
||||
? nativeRuntimeScheduler.unstable_NormalPriority
|
||||
: 3,
|
||||
unstable_LowPriority =
|
||||
"undefined" !== typeof nativeRuntimeScheduler
|
||||
? nativeRuntimeScheduler.unstable_LowPriority
|
||||
: 4,
|
||||
unstable_ImmediatePriority =
|
||||
"undefined" !== typeof nativeRuntimeScheduler
|
||||
? nativeRuntimeScheduler.unstable_ImmediatePriority
|
||||
: 1,
|
||||
unstable_scheduleCallback =
|
||||
"undefined" !== typeof nativeRuntimeScheduler
|
||||
? nativeRuntimeScheduler.unstable_scheduleCallback
|
||||
: unstable_scheduleCallback$1,
|
||||
unstable_cancelCallback =
|
||||
"undefined" !== typeof nativeRuntimeScheduler
|
||||
? nativeRuntimeScheduler.unstable_cancelCallback
|
||||
: unstable_cancelCallback$1,
|
||||
unstable_getCurrentPriorityLevel =
|
||||
"undefined" !== typeof nativeRuntimeScheduler
|
||||
? nativeRuntimeScheduler.unstable_getCurrentPriorityLevel
|
||||
: unstable_getCurrentPriorityLevel$1,
|
||||
unstable_shouldYield =
|
||||
"undefined" !== typeof nativeRuntimeScheduler
|
||||
? nativeRuntimeScheduler.unstable_shouldYield
|
||||
: shouldYieldToHost,
|
||||
unstable_requestPaint =
|
||||
"undefined" !== typeof nativeRuntimeScheduler
|
||||
? nativeRuntimeScheduler.unstable_requestPaint
|
||||
: requestPaint,
|
||||
unstable_now =
|
||||
"undefined" !== typeof nativeRuntimeScheduler
|
||||
? nativeRuntimeScheduler.unstable_now
|
||||
: getCurrentTime;
|
||||
exports.unstable_IdlePriority =
|
||||
"undefined" !== typeof nativeRuntimeScheduler
|
||||
? nativeRuntimeScheduler.unstable_IdlePriority
|
||||
: 5;
|
||||
exports.unstable_ImmediatePriority = unstable_ImmediatePriority;
|
||||
exports.unstable_LowPriority = unstable_LowPriority;
|
||||
exports.unstable_NormalPriority = unstable_NormalPriority;
|
||||
exports.unstable_Profiling = null;
|
||||
exports.unstable_UserBlockingPriority = channel;
|
||||
exports.unstable_cancelCallback = unstable_cancelCallback;
|
||||
exports.unstable_forceFrameRate = throwNotImplemented;
|
||||
exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
|
||||
exports.unstable_next = throwNotImplemented;
|
||||
exports.unstable_now = unstable_now;
|
||||
exports.unstable_requestPaint = unstable_requestPaint;
|
||||
exports.unstable_runWithPriority = throwNotImplemented;
|
||||
exports.unstable_scheduleCallback = unstable_scheduleCallback;
|
||||
exports.unstable_shouldYield = unstable_shouldYield;
|
||||
exports.unstable_wrapCallback = throwNotImplemented;
|
||||
})();
|
||||
330
web/node_modules/scheduler/cjs/scheduler.native.production.js
generated
vendored
330
web/node_modules/scheduler/cjs/scheduler.native.production.js
generated
vendored
@@ -1,330 +0,0 @@
|
||||
/**
|
||||
* @license React
|
||||
* scheduler.native.production.js
|
||||
*
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
function push(heap, node) {
|
||||
var index = heap.length;
|
||||
heap.push(node);
|
||||
a: for (; 0 < index; ) {
|
||||
var parentIndex = (index - 1) >>> 1,
|
||||
parent = heap[parentIndex];
|
||||
if (0 < compare(parent, node))
|
||||
(heap[parentIndex] = node), (heap[index] = parent), (index = parentIndex);
|
||||
else break a;
|
||||
}
|
||||
}
|
||||
function peek(heap) {
|
||||
return 0 === heap.length ? null : heap[0];
|
||||
}
|
||||
function pop(heap) {
|
||||
if (0 === heap.length) return null;
|
||||
var first = heap[0],
|
||||
last = heap.pop();
|
||||
if (last !== first) {
|
||||
heap[0] = last;
|
||||
a: for (
|
||||
var index = 0, length = heap.length, halfLength = length >>> 1;
|
||||
index < halfLength;
|
||||
|
||||
) {
|
||||
var leftIndex = 2 * (index + 1) - 1,
|
||||
left = heap[leftIndex],
|
||||
rightIndex = leftIndex + 1,
|
||||
right = heap[rightIndex];
|
||||
if (0 > compare(left, last))
|
||||
rightIndex < length && 0 > compare(right, left)
|
||||
? ((heap[index] = right),
|
||||
(heap[rightIndex] = last),
|
||||
(index = rightIndex))
|
||||
: ((heap[index] = left),
|
||||
(heap[leftIndex] = last),
|
||||
(index = leftIndex));
|
||||
else if (rightIndex < length && 0 > compare(right, last))
|
||||
(heap[index] = right), (heap[rightIndex] = last), (index = rightIndex);
|
||||
else break a;
|
||||
}
|
||||
}
|
||||
return first;
|
||||
}
|
||||
function compare(a, b) {
|
||||
var diff = a.sortIndex - b.sortIndex;
|
||||
return 0 !== diff ? diff : a.id - b.id;
|
||||
}
|
||||
var getCurrentTime;
|
||||
if ("object" === typeof performance && "function" === typeof performance.now) {
|
||||
var localPerformance = performance;
|
||||
getCurrentTime = function () {
|
||||
return localPerformance.now();
|
||||
};
|
||||
} else {
|
||||
var localDate = Date,
|
||||
initialTime = localDate.now();
|
||||
getCurrentTime = function () {
|
||||
return localDate.now() - initialTime;
|
||||
};
|
||||
}
|
||||
var taskQueue = [],
|
||||
timerQueue = [],
|
||||
taskIdCounter = 1,
|
||||
currentTask = null,
|
||||
currentPriorityLevel = 3,
|
||||
isPerformingWork = !1,
|
||||
isHostCallbackScheduled = !1,
|
||||
isHostTimeoutScheduled = !1,
|
||||
needsPaint = !1,
|
||||
localSetTimeout = "function" === typeof setTimeout ? setTimeout : null,
|
||||
localClearTimeout = "function" === typeof clearTimeout ? clearTimeout : null,
|
||||
localSetImmediate = "undefined" !== typeof setImmediate ? setImmediate : null;
|
||||
function advanceTimers(currentTime) {
|
||||
for (var timer = peek(timerQueue); null !== timer; ) {
|
||||
if (null === timer.callback) pop(timerQueue);
|
||||
else if (timer.startTime <= currentTime)
|
||||
pop(timerQueue),
|
||||
(timer.sortIndex = timer.expirationTime),
|
||||
push(taskQueue, timer);
|
||||
else break;
|
||||
timer = peek(timerQueue);
|
||||
}
|
||||
}
|
||||
function handleTimeout(currentTime) {
|
||||
isHostTimeoutScheduled = !1;
|
||||
advanceTimers(currentTime);
|
||||
if (!isHostCallbackScheduled)
|
||||
if (null !== peek(taskQueue))
|
||||
(isHostCallbackScheduled = !0),
|
||||
isMessageLoopRunning ||
|
||||
((isMessageLoopRunning = !0), schedulePerformWorkUntilDeadline());
|
||||
else {
|
||||
var firstTimer = peek(timerQueue);
|
||||
null !== firstTimer &&
|
||||
requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
|
||||
}
|
||||
}
|
||||
function unstable_scheduleCallback$1(priorityLevel, callback, options) {
|
||||
var currentTime = getCurrentTime();
|
||||
"object" === typeof options && null !== options
|
||||
? ((options = options.delay),
|
||||
(options =
|
||||
"number" === typeof options && 0 < options
|
||||
? currentTime + options
|
||||
: currentTime))
|
||||
: (options = currentTime);
|
||||
switch (priorityLevel) {
|
||||
case 1:
|
||||
var timeout = -1;
|
||||
break;
|
||||
case 2:
|
||||
timeout = 250;
|
||||
break;
|
||||
case 5:
|
||||
timeout = 1073741823;
|
||||
break;
|
||||
case 4:
|
||||
timeout = 1e4;
|
||||
break;
|
||||
default:
|
||||
timeout = 5e3;
|
||||
}
|
||||
timeout = options + timeout;
|
||||
priorityLevel = {
|
||||
id: taskIdCounter++,
|
||||
callback: callback,
|
||||
priorityLevel: priorityLevel,
|
||||
startTime: options,
|
||||
expirationTime: timeout,
|
||||
sortIndex: -1
|
||||
};
|
||||
options > currentTime
|
||||
? ((priorityLevel.sortIndex = options),
|
||||
push(timerQueue, priorityLevel),
|
||||
null === peek(taskQueue) &&
|
||||
priorityLevel === peek(timerQueue) &&
|
||||
(isHostTimeoutScheduled
|
||||
? (localClearTimeout(taskTimeoutID), (taskTimeoutID = -1))
|
||||
: (isHostTimeoutScheduled = !0),
|
||||
requestHostTimeout(handleTimeout, options - currentTime)))
|
||||
: ((priorityLevel.sortIndex = timeout),
|
||||
push(taskQueue, priorityLevel),
|
||||
isHostCallbackScheduled ||
|
||||
isPerformingWork ||
|
||||
((isHostCallbackScheduled = !0),
|
||||
isMessageLoopRunning ||
|
||||
((isMessageLoopRunning = !0), schedulePerformWorkUntilDeadline())));
|
||||
return priorityLevel;
|
||||
}
|
||||
function unstable_cancelCallback$1(task) {
|
||||
task.callback = null;
|
||||
}
|
||||
function unstable_getCurrentPriorityLevel$1() {
|
||||
return currentPriorityLevel;
|
||||
}
|
||||
var isMessageLoopRunning = !1,
|
||||
taskTimeoutID = -1,
|
||||
startTime = -1;
|
||||
function shouldYieldToHost() {
|
||||
return needsPaint ? !0 : 5 > getCurrentTime() - startTime ? !1 : !0;
|
||||
}
|
||||
function requestPaint() {
|
||||
needsPaint = !0;
|
||||
}
|
||||
function performWorkUntilDeadline() {
|
||||
needsPaint = !1;
|
||||
if (isMessageLoopRunning) {
|
||||
var currentTime = getCurrentTime();
|
||||
startTime = currentTime;
|
||||
var hasMoreWork = !0;
|
||||
try {
|
||||
a: {
|
||||
isHostCallbackScheduled = !1;
|
||||
isHostTimeoutScheduled &&
|
||||
((isHostTimeoutScheduled = !1),
|
||||
localClearTimeout(taskTimeoutID),
|
||||
(taskTimeoutID = -1));
|
||||
isPerformingWork = !0;
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
try {
|
||||
b: {
|
||||
advanceTimers(currentTime);
|
||||
for (
|
||||
currentTask = peek(taskQueue);
|
||||
null !== currentTask &&
|
||||
!(
|
||||
currentTask.expirationTime > currentTime && shouldYieldToHost()
|
||||
);
|
||||
|
||||
) {
|
||||
var callback = currentTask.callback;
|
||||
if ("function" === typeof callback) {
|
||||
currentTask.callback = null;
|
||||
currentPriorityLevel = currentTask.priorityLevel;
|
||||
var continuationCallback = callback(
|
||||
currentTask.expirationTime <= currentTime
|
||||
);
|
||||
currentTime = getCurrentTime();
|
||||
if ("function" === typeof continuationCallback) {
|
||||
currentTask.callback = continuationCallback;
|
||||
advanceTimers(currentTime);
|
||||
hasMoreWork = !0;
|
||||
break b;
|
||||
}
|
||||
currentTask === peek(taskQueue) && pop(taskQueue);
|
||||
advanceTimers(currentTime);
|
||||
} else pop(taskQueue);
|
||||
currentTask = peek(taskQueue);
|
||||
}
|
||||
if (null !== currentTask) hasMoreWork = !0;
|
||||
else {
|
||||
var firstTimer = peek(timerQueue);
|
||||
null !== firstTimer &&
|
||||
requestHostTimeout(
|
||||
handleTimeout,
|
||||
firstTimer.startTime - currentTime
|
||||
);
|
||||
hasMoreWork = !1;
|
||||
}
|
||||
}
|
||||
break a;
|
||||
} finally {
|
||||
(currentTask = null),
|
||||
(currentPriorityLevel = previousPriorityLevel),
|
||||
(isPerformingWork = !1);
|
||||
}
|
||||
hasMoreWork = void 0;
|
||||
}
|
||||
} finally {
|
||||
hasMoreWork
|
||||
? schedulePerformWorkUntilDeadline()
|
||||
: (isMessageLoopRunning = !1);
|
||||
}
|
||||
}
|
||||
}
|
||||
var schedulePerformWorkUntilDeadline;
|
||||
if ("function" === typeof localSetImmediate)
|
||||
schedulePerformWorkUntilDeadline = function () {
|
||||
localSetImmediate(performWorkUntilDeadline);
|
||||
};
|
||||
else if ("undefined" !== typeof MessageChannel) {
|
||||
var channel = new MessageChannel(),
|
||||
port = channel.port2;
|
||||
channel.port1.onmessage = performWorkUntilDeadline;
|
||||
schedulePerformWorkUntilDeadline = function () {
|
||||
port.postMessage(null);
|
||||
};
|
||||
} else
|
||||
schedulePerformWorkUntilDeadline = function () {
|
||||
localSetTimeout(performWorkUntilDeadline, 0);
|
||||
};
|
||||
function requestHostTimeout(callback, ms) {
|
||||
taskTimeoutID = localSetTimeout(function () {
|
||||
callback(getCurrentTime());
|
||||
}, ms);
|
||||
}
|
||||
var unstable_UserBlockingPriority =
|
||||
"undefined" !== typeof nativeRuntimeScheduler
|
||||
? nativeRuntimeScheduler.unstable_UserBlockingPriority
|
||||
: 2,
|
||||
unstable_NormalPriority =
|
||||
"undefined" !== typeof nativeRuntimeScheduler
|
||||
? nativeRuntimeScheduler.unstable_NormalPriority
|
||||
: 3,
|
||||
unstable_LowPriority =
|
||||
"undefined" !== typeof nativeRuntimeScheduler
|
||||
? nativeRuntimeScheduler.unstable_LowPriority
|
||||
: 4,
|
||||
unstable_ImmediatePriority =
|
||||
"undefined" !== typeof nativeRuntimeScheduler
|
||||
? nativeRuntimeScheduler.unstable_ImmediatePriority
|
||||
: 1,
|
||||
unstable_scheduleCallback =
|
||||
"undefined" !== typeof nativeRuntimeScheduler
|
||||
? nativeRuntimeScheduler.unstable_scheduleCallback
|
||||
: unstable_scheduleCallback$1,
|
||||
unstable_cancelCallback =
|
||||
"undefined" !== typeof nativeRuntimeScheduler
|
||||
? nativeRuntimeScheduler.unstable_cancelCallback
|
||||
: unstable_cancelCallback$1,
|
||||
unstable_getCurrentPriorityLevel =
|
||||
"undefined" !== typeof nativeRuntimeScheduler
|
||||
? nativeRuntimeScheduler.unstable_getCurrentPriorityLevel
|
||||
: unstable_getCurrentPriorityLevel$1,
|
||||
unstable_shouldYield =
|
||||
"undefined" !== typeof nativeRuntimeScheduler
|
||||
? nativeRuntimeScheduler.unstable_shouldYield
|
||||
: shouldYieldToHost,
|
||||
unstable_requestPaint =
|
||||
"undefined" !== typeof nativeRuntimeScheduler
|
||||
? nativeRuntimeScheduler.unstable_requestPaint
|
||||
: requestPaint,
|
||||
unstable_now =
|
||||
"undefined" !== typeof nativeRuntimeScheduler
|
||||
? nativeRuntimeScheduler.unstable_now
|
||||
: getCurrentTime;
|
||||
function throwNotImplemented() {
|
||||
throw Error("Not implemented.");
|
||||
}
|
||||
exports.unstable_IdlePriority =
|
||||
"undefined" !== typeof nativeRuntimeScheduler
|
||||
? nativeRuntimeScheduler.unstable_IdlePriority
|
||||
: 5;
|
||||
exports.unstable_ImmediatePriority = unstable_ImmediatePriority;
|
||||
exports.unstable_LowPriority = unstable_LowPriority;
|
||||
exports.unstable_NormalPriority = unstable_NormalPriority;
|
||||
exports.unstable_Profiling = null;
|
||||
exports.unstable_UserBlockingPriority = unstable_UserBlockingPriority;
|
||||
exports.unstable_cancelCallback = unstable_cancelCallback;
|
||||
exports.unstable_forceFrameRate = throwNotImplemented;
|
||||
exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
|
||||
exports.unstable_next = throwNotImplemented;
|
||||
exports.unstable_now = unstable_now;
|
||||
exports.unstable_requestPaint = unstable_requestPaint;
|
||||
exports.unstable_runWithPriority = throwNotImplemented;
|
||||
exports.unstable_scheduleCallback = unstable_scheduleCallback;
|
||||
exports.unstable_shouldYield = unstable_shouldYield;
|
||||
exports.unstable_wrapCallback = throwNotImplemented;
|
||||
340
web/node_modules/scheduler/cjs/scheduler.production.js
generated
vendored
340
web/node_modules/scheduler/cjs/scheduler.production.js
generated
vendored
@@ -1,340 +0,0 @@
|
||||
/**
|
||||
* @license React
|
||||
* scheduler.production.js
|
||||
*
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
function push(heap, node) {
|
||||
var index = heap.length;
|
||||
heap.push(node);
|
||||
a: for (; 0 < index; ) {
|
||||
var parentIndex = (index - 1) >>> 1,
|
||||
parent = heap[parentIndex];
|
||||
if (0 < compare(parent, node))
|
||||
(heap[parentIndex] = node), (heap[index] = parent), (index = parentIndex);
|
||||
else break a;
|
||||
}
|
||||
}
|
||||
function peek(heap) {
|
||||
return 0 === heap.length ? null : heap[0];
|
||||
}
|
||||
function pop(heap) {
|
||||
if (0 === heap.length) return null;
|
||||
var first = heap[0],
|
||||
last = heap.pop();
|
||||
if (last !== first) {
|
||||
heap[0] = last;
|
||||
a: for (
|
||||
var index = 0, length = heap.length, halfLength = length >>> 1;
|
||||
index < halfLength;
|
||||
|
||||
) {
|
||||
var leftIndex = 2 * (index + 1) - 1,
|
||||
left = heap[leftIndex],
|
||||
rightIndex = leftIndex + 1,
|
||||
right = heap[rightIndex];
|
||||
if (0 > compare(left, last))
|
||||
rightIndex < length && 0 > compare(right, left)
|
||||
? ((heap[index] = right),
|
||||
(heap[rightIndex] = last),
|
||||
(index = rightIndex))
|
||||
: ((heap[index] = left),
|
||||
(heap[leftIndex] = last),
|
||||
(index = leftIndex));
|
||||
else if (rightIndex < length && 0 > compare(right, last))
|
||||
(heap[index] = right), (heap[rightIndex] = last), (index = rightIndex);
|
||||
else break a;
|
||||
}
|
||||
}
|
||||
return first;
|
||||
}
|
||||
function compare(a, b) {
|
||||
var diff = a.sortIndex - b.sortIndex;
|
||||
return 0 !== diff ? diff : a.id - b.id;
|
||||
}
|
||||
exports.unstable_now = void 0;
|
||||
if ("object" === typeof performance && "function" === typeof performance.now) {
|
||||
var localPerformance = performance;
|
||||
exports.unstable_now = function () {
|
||||
return localPerformance.now();
|
||||
};
|
||||
} else {
|
||||
var localDate = Date,
|
||||
initialTime = localDate.now();
|
||||
exports.unstable_now = function () {
|
||||
return localDate.now() - initialTime;
|
||||
};
|
||||
}
|
||||
var taskQueue = [],
|
||||
timerQueue = [],
|
||||
taskIdCounter = 1,
|
||||
currentTask = null,
|
||||
currentPriorityLevel = 3,
|
||||
isPerformingWork = !1,
|
||||
isHostCallbackScheduled = !1,
|
||||
isHostTimeoutScheduled = !1,
|
||||
needsPaint = !1,
|
||||
localSetTimeout = "function" === typeof setTimeout ? setTimeout : null,
|
||||
localClearTimeout = "function" === typeof clearTimeout ? clearTimeout : null,
|
||||
localSetImmediate = "undefined" !== typeof setImmediate ? setImmediate : null;
|
||||
function advanceTimers(currentTime) {
|
||||
for (var timer = peek(timerQueue); null !== timer; ) {
|
||||
if (null === timer.callback) pop(timerQueue);
|
||||
else if (timer.startTime <= currentTime)
|
||||
pop(timerQueue),
|
||||
(timer.sortIndex = timer.expirationTime),
|
||||
push(taskQueue, timer);
|
||||
else break;
|
||||
timer = peek(timerQueue);
|
||||
}
|
||||
}
|
||||
function handleTimeout(currentTime) {
|
||||
isHostTimeoutScheduled = !1;
|
||||
advanceTimers(currentTime);
|
||||
if (!isHostCallbackScheduled)
|
||||
if (null !== peek(taskQueue))
|
||||
(isHostCallbackScheduled = !0),
|
||||
isMessageLoopRunning ||
|
||||
((isMessageLoopRunning = !0), schedulePerformWorkUntilDeadline());
|
||||
else {
|
||||
var firstTimer = peek(timerQueue);
|
||||
null !== firstTimer &&
|
||||
requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
|
||||
}
|
||||
}
|
||||
var isMessageLoopRunning = !1,
|
||||
taskTimeoutID = -1,
|
||||
frameInterval = 5,
|
||||
startTime = -1;
|
||||
function shouldYieldToHost() {
|
||||
return needsPaint
|
||||
? !0
|
||||
: exports.unstable_now() - startTime < frameInterval
|
||||
? !1
|
||||
: !0;
|
||||
}
|
||||
function performWorkUntilDeadline() {
|
||||
needsPaint = !1;
|
||||
if (isMessageLoopRunning) {
|
||||
var currentTime = exports.unstable_now();
|
||||
startTime = currentTime;
|
||||
var hasMoreWork = !0;
|
||||
try {
|
||||
a: {
|
||||
isHostCallbackScheduled = !1;
|
||||
isHostTimeoutScheduled &&
|
||||
((isHostTimeoutScheduled = !1),
|
||||
localClearTimeout(taskTimeoutID),
|
||||
(taskTimeoutID = -1));
|
||||
isPerformingWork = !0;
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
try {
|
||||
b: {
|
||||
advanceTimers(currentTime);
|
||||
for (
|
||||
currentTask = peek(taskQueue);
|
||||
null !== currentTask &&
|
||||
!(
|
||||
currentTask.expirationTime > currentTime && shouldYieldToHost()
|
||||
);
|
||||
|
||||
) {
|
||||
var callback = currentTask.callback;
|
||||
if ("function" === typeof callback) {
|
||||
currentTask.callback = null;
|
||||
currentPriorityLevel = currentTask.priorityLevel;
|
||||
var continuationCallback = callback(
|
||||
currentTask.expirationTime <= currentTime
|
||||
);
|
||||
currentTime = exports.unstable_now();
|
||||
if ("function" === typeof continuationCallback) {
|
||||
currentTask.callback = continuationCallback;
|
||||
advanceTimers(currentTime);
|
||||
hasMoreWork = !0;
|
||||
break b;
|
||||
}
|
||||
currentTask === peek(taskQueue) && pop(taskQueue);
|
||||
advanceTimers(currentTime);
|
||||
} else pop(taskQueue);
|
||||
currentTask = peek(taskQueue);
|
||||
}
|
||||
if (null !== currentTask) hasMoreWork = !0;
|
||||
else {
|
||||
var firstTimer = peek(timerQueue);
|
||||
null !== firstTimer &&
|
||||
requestHostTimeout(
|
||||
handleTimeout,
|
||||
firstTimer.startTime - currentTime
|
||||
);
|
||||
hasMoreWork = !1;
|
||||
}
|
||||
}
|
||||
break a;
|
||||
} finally {
|
||||
(currentTask = null),
|
||||
(currentPriorityLevel = previousPriorityLevel),
|
||||
(isPerformingWork = !1);
|
||||
}
|
||||
hasMoreWork = void 0;
|
||||
}
|
||||
} finally {
|
||||
hasMoreWork
|
||||
? schedulePerformWorkUntilDeadline()
|
||||
: (isMessageLoopRunning = !1);
|
||||
}
|
||||
}
|
||||
}
|
||||
var schedulePerformWorkUntilDeadline;
|
||||
if ("function" === typeof localSetImmediate)
|
||||
schedulePerformWorkUntilDeadline = function () {
|
||||
localSetImmediate(performWorkUntilDeadline);
|
||||
};
|
||||
else if ("undefined" !== typeof MessageChannel) {
|
||||
var channel = new MessageChannel(),
|
||||
port = channel.port2;
|
||||
channel.port1.onmessage = performWorkUntilDeadline;
|
||||
schedulePerformWorkUntilDeadline = function () {
|
||||
port.postMessage(null);
|
||||
};
|
||||
} else
|
||||
schedulePerformWorkUntilDeadline = function () {
|
||||
localSetTimeout(performWorkUntilDeadline, 0);
|
||||
};
|
||||
function requestHostTimeout(callback, ms) {
|
||||
taskTimeoutID = localSetTimeout(function () {
|
||||
callback(exports.unstable_now());
|
||||
}, ms);
|
||||
}
|
||||
exports.unstable_IdlePriority = 5;
|
||||
exports.unstable_ImmediatePriority = 1;
|
||||
exports.unstable_LowPriority = 4;
|
||||
exports.unstable_NormalPriority = 3;
|
||||
exports.unstable_Profiling = null;
|
||||
exports.unstable_UserBlockingPriority = 2;
|
||||
exports.unstable_cancelCallback = function (task) {
|
||||
task.callback = null;
|
||||
};
|
||||
exports.unstable_forceFrameRate = function (fps) {
|
||||
0 > fps || 125 < fps
|
||||
? console.error(
|
||||
"forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported"
|
||||
)
|
||||
: (frameInterval = 0 < fps ? Math.floor(1e3 / fps) : 5);
|
||||
};
|
||||
exports.unstable_getCurrentPriorityLevel = function () {
|
||||
return currentPriorityLevel;
|
||||
};
|
||||
exports.unstable_next = function (eventHandler) {
|
||||
switch (currentPriorityLevel) {
|
||||
case 1:
|
||||
case 2:
|
||||
case 3:
|
||||
var priorityLevel = 3;
|
||||
break;
|
||||
default:
|
||||
priorityLevel = currentPriorityLevel;
|
||||
}
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = priorityLevel;
|
||||
try {
|
||||
return eventHandler();
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
exports.unstable_requestPaint = function () {
|
||||
needsPaint = !0;
|
||||
};
|
||||
exports.unstable_runWithPriority = function (priorityLevel, eventHandler) {
|
||||
switch (priorityLevel) {
|
||||
case 1:
|
||||
case 2:
|
||||
case 3:
|
||||
case 4:
|
||||
case 5:
|
||||
break;
|
||||
default:
|
||||
priorityLevel = 3;
|
||||
}
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = priorityLevel;
|
||||
try {
|
||||
return eventHandler();
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
exports.unstable_scheduleCallback = function (
|
||||
priorityLevel,
|
||||
callback,
|
||||
options
|
||||
) {
|
||||
var currentTime = exports.unstable_now();
|
||||
"object" === typeof options && null !== options
|
||||
? ((options = options.delay),
|
||||
(options =
|
||||
"number" === typeof options && 0 < options
|
||||
? currentTime + options
|
||||
: currentTime))
|
||||
: (options = currentTime);
|
||||
switch (priorityLevel) {
|
||||
case 1:
|
||||
var timeout = -1;
|
||||
break;
|
||||
case 2:
|
||||
timeout = 250;
|
||||
break;
|
||||
case 5:
|
||||
timeout = 1073741823;
|
||||
break;
|
||||
case 4:
|
||||
timeout = 1e4;
|
||||
break;
|
||||
default:
|
||||
timeout = 5e3;
|
||||
}
|
||||
timeout = options + timeout;
|
||||
priorityLevel = {
|
||||
id: taskIdCounter++,
|
||||
callback: callback,
|
||||
priorityLevel: priorityLevel,
|
||||
startTime: options,
|
||||
expirationTime: timeout,
|
||||
sortIndex: -1
|
||||
};
|
||||
options > currentTime
|
||||
? ((priorityLevel.sortIndex = options),
|
||||
push(timerQueue, priorityLevel),
|
||||
null === peek(taskQueue) &&
|
||||
priorityLevel === peek(timerQueue) &&
|
||||
(isHostTimeoutScheduled
|
||||
? (localClearTimeout(taskTimeoutID), (taskTimeoutID = -1))
|
||||
: (isHostTimeoutScheduled = !0),
|
||||
requestHostTimeout(handleTimeout, options - currentTime)))
|
||||
: ((priorityLevel.sortIndex = timeout),
|
||||
push(taskQueue, priorityLevel),
|
||||
isHostCallbackScheduled ||
|
||||
isPerformingWork ||
|
||||
((isHostCallbackScheduled = !0),
|
||||
isMessageLoopRunning ||
|
||||
((isMessageLoopRunning = !0), schedulePerformWorkUntilDeadline())));
|
||||
return priorityLevel;
|
||||
};
|
||||
exports.unstable_shouldYield = shouldYieldToHost;
|
||||
exports.unstable_wrapCallback = function (callback) {
|
||||
var parentPriorityLevel = currentPriorityLevel;
|
||||
return function () {
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = parentPriorityLevel;
|
||||
try {
|
||||
return callback.apply(this, arguments);
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
};
|
||||
19
web/node_modules/scheduler/cjs/scheduler.production.min.js
generated
vendored
Normal file
19
web/node_modules/scheduler/cjs/scheduler.production.min.js
generated
vendored
Normal file
@@ -0,0 +1,19 @@
|
||||
/**
|
||||
* @license React
|
||||
* scheduler.production.min.js
|
||||
*
|
||||
* Copyright (c) Facebook, Inc. and its affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
'use strict';function f(a,b){var c=a.length;a.push(b);a:for(;0<c;){var d=c-1>>>1,e=a[d];if(0<g(e,b))a[d]=b,a[c]=e,c=d;else break a}}function h(a){return 0===a.length?null:a[0]}function k(a){if(0===a.length)return null;var b=a[0],c=a.pop();if(c!==b){a[0]=c;a:for(var d=0,e=a.length,w=e>>>1;d<w;){var m=2*(d+1)-1,C=a[m],n=m+1,x=a[n];if(0>g(C,c))n<e&&0>g(x,C)?(a[d]=x,a[n]=c,d=n):(a[d]=C,a[m]=c,d=m);else if(n<e&&0>g(x,c))a[d]=x,a[n]=c,d=n;else break a}}return b}
|
||||
function g(a,b){var c=a.sortIndex-b.sortIndex;return 0!==c?c:a.id-b.id}if("object"===typeof performance&&"function"===typeof performance.now){var l=performance;exports.unstable_now=function(){return l.now()}}else{var p=Date,q=p.now();exports.unstable_now=function(){return p.now()-q}}var r=[],t=[],u=1,v=null,y=3,z=!1,A=!1,B=!1,D="function"===typeof setTimeout?setTimeout:null,E="function"===typeof clearTimeout?clearTimeout:null,F="undefined"!==typeof setImmediate?setImmediate:null;
|
||||
"undefined"!==typeof navigator&&void 0!==navigator.scheduling&&void 0!==navigator.scheduling.isInputPending&&navigator.scheduling.isInputPending.bind(navigator.scheduling);function G(a){for(var b=h(t);null!==b;){if(null===b.callback)k(t);else if(b.startTime<=a)k(t),b.sortIndex=b.expirationTime,f(r,b);else break;b=h(t)}}function H(a){B=!1;G(a);if(!A)if(null!==h(r))A=!0,I(J);else{var b=h(t);null!==b&&K(H,b.startTime-a)}}
|
||||
function J(a,b){A=!1;B&&(B=!1,E(L),L=-1);z=!0;var c=y;try{G(b);for(v=h(r);null!==v&&(!(v.expirationTime>b)||a&&!M());){var d=v.callback;if("function"===typeof d){v.callback=null;y=v.priorityLevel;var e=d(v.expirationTime<=b);b=exports.unstable_now();"function"===typeof e?v.callback=e:v===h(r)&&k(r);G(b)}else k(r);v=h(r)}if(null!==v)var w=!0;else{var m=h(t);null!==m&&K(H,m.startTime-b);w=!1}return w}finally{v=null,y=c,z=!1}}var N=!1,O=null,L=-1,P=5,Q=-1;
|
||||
function M(){return exports.unstable_now()-Q<P?!1:!0}function R(){if(null!==O){var a=exports.unstable_now();Q=a;var b=!0;try{b=O(!0,a)}finally{b?S():(N=!1,O=null)}}else N=!1}var S;if("function"===typeof F)S=function(){F(R)};else if("undefined"!==typeof MessageChannel){var T=new MessageChannel,U=T.port2;T.port1.onmessage=R;S=function(){U.postMessage(null)}}else S=function(){D(R,0)};function I(a){O=a;N||(N=!0,S())}function K(a,b){L=D(function(){a(exports.unstable_now())},b)}
|
||||
exports.unstable_IdlePriority=5;exports.unstable_ImmediatePriority=1;exports.unstable_LowPriority=4;exports.unstable_NormalPriority=3;exports.unstable_Profiling=null;exports.unstable_UserBlockingPriority=2;exports.unstable_cancelCallback=function(a){a.callback=null};exports.unstable_continueExecution=function(){A||z||(A=!0,I(J))};
|
||||
exports.unstable_forceFrameRate=function(a){0>a||125<a?console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported"):P=0<a?Math.floor(1E3/a):5};exports.unstable_getCurrentPriorityLevel=function(){return y};exports.unstable_getFirstCallbackNode=function(){return h(r)};exports.unstable_next=function(a){switch(y){case 1:case 2:case 3:var b=3;break;default:b=y}var c=y;y=b;try{return a()}finally{y=c}};exports.unstable_pauseExecution=function(){};
|
||||
exports.unstable_requestPaint=function(){};exports.unstable_runWithPriority=function(a,b){switch(a){case 1:case 2:case 3:case 4:case 5:break;default:a=3}var c=y;y=a;try{return b()}finally{y=c}};
|
||||
exports.unstable_scheduleCallback=function(a,b,c){var d=exports.unstable_now();"object"===typeof c&&null!==c?(c=c.delay,c="number"===typeof c&&0<c?d+c:d):c=d;switch(a){case 1:var e=-1;break;case 2:e=250;break;case 5:e=1073741823;break;case 4:e=1E4;break;default:e=5E3}e=c+e;a={id:u++,callback:b,priorityLevel:a,startTime:c,expirationTime:e,sortIndex:-1};c>d?(a.sortIndex=c,f(t,a),null===h(r)&&a===h(t)&&(B?(E(L),L=-1):B=!0,K(H,c-d))):(a.sortIndex=e,f(r,a),A||z||(A=!0,I(J)));return a};
|
||||
exports.unstable_shouldYield=M;exports.unstable_wrapCallback=function(a){var b=y;return function(){var c=y;y=b;try{return a.apply(this,arguments)}finally{y=c}}};
|
||||
Reference in New Issue
Block a user