Refactor code structure for improved readability and maintainability
This commit is contained in:
Lago
292
node_modules/.vite/deps/chunk-SVR3SNXV.js
generated
vendored
Normal file
292
node_modules/.vite/deps/chunk-SVR3SNXV.js
generated
vendored
Normal file
@@ -0,0 +1,292 @@
|
||||
import {
|
||||
__commonJS
|
||||
} from "./chunk-WBF6APZF.js";
|
||||
|
||||
// node_modules/scheduler/cjs/scheduler.development.js
|
||||
var require_scheduler_development = __commonJS({
|
||||
"node_modules/scheduler/cjs/scheduler.development.js"(exports) {
|
||||
"use strict";
|
||||
(function() {
|
||||
function performWorkUntilDeadline() {
|
||||
needsPaint = false;
|
||||
if (isMessageLoopRunning) {
|
||||
var currentTime = exports.unstable_now();
|
||||
startTime = currentTime;
|
||||
var hasMoreWork = true;
|
||||
try {
|
||||
a: {
|
||||
isHostCallbackScheduled = false;
|
||||
isHostTimeoutScheduled && (isHostTimeoutScheduled = false, localClearTimeout(taskTimeoutID), taskTimeoutID = -1);
|
||||
isPerformingWork = true;
|
||||
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 = true;
|
||||
break b;
|
||||
}
|
||||
currentTask === peek(taskQueue) && pop(taskQueue);
|
||||
advanceTimers(currentTime);
|
||||
} else pop(taskQueue);
|
||||
currentTask = peek(taskQueue);
|
||||
}
|
||||
if (null !== currentTask) hasMoreWork = true;
|
||||
else {
|
||||
var firstTimer = peek(timerQueue);
|
||||
null !== firstTimer && requestHostTimeout(
|
||||
handleTimeout,
|
||||
firstTimer.startTime - currentTime
|
||||
);
|
||||
hasMoreWork = false;
|
||||
}
|
||||
}
|
||||
break a;
|
||||
} finally {
|
||||
currentTask = null, currentPriorityLevel = previousPriorityLevel, isPerformingWork = false;
|
||||
}
|
||||
hasMoreWork = void 0;
|
||||
}
|
||||
} finally {
|
||||
hasMoreWork ? schedulePerformWorkUntilDeadline() : isMessageLoopRunning = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
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 = false;
|
||||
advanceTimers(currentTime);
|
||||
if (!isHostCallbackScheduled)
|
||||
if (null !== peek(taskQueue))
|
||||
isHostCallbackScheduled = true, isMessageLoopRunning || (isMessageLoopRunning = true, schedulePerformWorkUntilDeadline());
|
||||
else {
|
||||
var firstTimer = peek(timerQueue);
|
||||
null !== firstTimer && requestHostTimeout(
|
||||
handleTimeout,
|
||||
firstTimer.startTime - currentTime
|
||||
);
|
||||
}
|
||||
}
|
||||
function shouldYieldToHost() {
|
||||
return needsPaint ? true : exports.unstable_now() - startTime < frameInterval ? false : true;
|
||||
}
|
||||
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();
|
||||
};
|
||||
} 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 = false, isHostCallbackScheduled = false, isHostTimeoutScheduled = false, needsPaint = false, localSetTimeout = "function" === typeof setTimeout ? setTimeout : null, localClearTimeout = "function" === typeof clearTimeout ? clearTimeout : null, localSetImmediate = "undefined" !== typeof setImmediate ? setImmediate : null, isMessageLoopRunning = false, 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;
|
||||
}
|
||||
var previousPriorityLevel = currentPriorityLevel;
|
||||
currentPriorityLevel = priorityLevel;
|
||||
try {
|
||||
return eventHandler();
|
||||
} finally {
|
||||
currentPriorityLevel = previousPriorityLevel;
|
||||
}
|
||||
};
|
||||
exports.unstable_requestPaint = function() {
|
||||
needsPaint = true;
|
||||
};
|
||||
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,
|
||||
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 = true, requestHostTimeout(handleTimeout, options - currentTime))) : (priorityLevel.sortIndex = timeout, push(taskQueue, priorityLevel), isHostCallbackScheduled || isPerformingWork || (isHostCallbackScheduled = true, isMessageLoopRunning || (isMessageLoopRunning = true, 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;
|
||||
}
|
||||
};
|
||||
};
|
||||
"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
|
||||
})();
|
||||
}
|
||||
});
|
||||
|
||||
// node_modules/scheduler/index.js
|
||||
var require_scheduler = __commonJS({
|
||||
"node_modules/scheduler/index.js"(exports, module) {
|
||||
"use strict";
|
||||
if (false) {
|
||||
module.exports = null;
|
||||
} else {
|
||||
module.exports = require_scheduler_development();
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
export {
|
||||
require_scheduler
|
||||
};
|
||||
/*! Bundled license information:
|
||||
|
||||
scheduler/cjs/scheduler.development.js:
|
||||
(**
|
||||
* @license React
|
||||
* scheduler.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.
|
||||
*)
|
||||
*/
|
||||
//# sourceMappingURL=chunk-SVR3SNXV.js.map
|
||||
Reference in New Issue
Block a user