summaryrefslogtreecommitdiff
path: root/node_modules/scheduler/cjs
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/scheduler/cjs')
-rw-r--r--node_modules/scheduler/cjs/scheduler-unstable_mock.development.js700
-rw-r--r--node_modules/scheduler/cjs/scheduler-unstable_mock.production.min.js20
-rw-r--r--node_modules/scheduler/cjs/scheduler-unstable_post_task.development.js207
-rw-r--r--node_modules/scheduler/cjs/scheduler-unstable_post_task.production.min.js14
-rw-r--r--node_modules/scheduler/cjs/scheduler.development.js634
-rw-r--r--node_modules/scheduler/cjs/scheduler.production.min.js19
6 files changed, 1594 insertions, 0 deletions
diff --git a/node_modules/scheduler/cjs/scheduler-unstable_mock.development.js b/node_modules/scheduler/cjs/scheduler-unstable_mock.development.js
new file mode 100644
index 0000000..0b56921
--- /dev/null
+++ b/node_modules/scheduler/cjs/scheduler-unstable_mock.development.js
@@ -0,0 +1,700 @@
+/**
+ * @license React
+ * scheduler-unstable_mock.development.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';
+
+if (process.env.NODE_ENV !== "production") {
+ (function() {
+'use strict';
+
+var enableSchedulerDebugging = false;
+var enableProfiling = false;
+
+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 {
+ // The parent is smaller. Exit.
+ return;
+ }
+ }
+}
+
+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;
+ }
+ } 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 */
+// 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;
+var currentMockTime = 0;
+var scheduledCallback = null;
+var scheduledTimeout = null;
+var timeoutTime = -1;
+var yieldedValues = null;
+var expectedNumberOfYields = -1;
+var didStop = false;
+var isFlushing = false;
+var needsPaint = false;
+var shouldYieldForPaint = false;
+var disableYieldValue = false;
+
+function setDisableYieldValue(newValue) {
+ disableYieldValue = newValue;
+}
+
+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 workLoop(hasTimeRemaining, initialTime);
+ } catch (error) {
+ if (currentTask !== null) {
+ var currentTime = getCurrentTime();
+ markTaskErrored(currentTask, currentTime);
+ currentTask.isQueued = false;
+ }
+
+ 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 = getCurrentTime();
+
+ 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 = getCurrentTime();
+ 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;
+}
+
+function requestHostCallback(callback) {
+ scheduledCallback = callback;
+}
+
+function requestHostTimeout(callback, ms) {
+ scheduledTimeout = callback;
+ timeoutTime = currentMockTime + ms;
+}
+
+function cancelHostTimeout() {
+ scheduledTimeout = null;
+ timeoutTime = -1;
+}
+
+function shouldYieldToHost() {
+ if (expectedNumberOfYields === 0 && yieldedValues === null || expectedNumberOfYields !== -1 && yieldedValues !== null && yieldedValues.length >= expectedNumberOfYields || shouldYieldForPaint && needsPaint) {
+ // We yielded at least as many values as expected. Stop flushing.
+ didStop = true;
+ return true;
+ }
+
+ return false;
+}
+
+function getCurrentTime() {
+ return currentMockTime;
+}
+
+function forceFrameRate() {// No-op
+}
+
+function reset() {
+ if (isFlushing) {
+ throw new Error('Cannot reset while already flushing work.');
+ }
+
+ currentMockTime = 0;
+ scheduledCallback = null;
+ scheduledTimeout = null;
+ timeoutTime = -1;
+ yieldedValues = null;
+ expectedNumberOfYields = -1;
+ didStop = false;
+ isFlushing = false;
+ needsPaint = false;
+} // Should only be used via an assertion helper that inspects the yielded values.
+
+
+function unstable_flushNumberOfYields(count) {
+ if (isFlushing) {
+ throw new Error('Already flushing work.');
+ }
+
+ if (scheduledCallback !== null) {
+ var cb = scheduledCallback;
+ expectedNumberOfYields = count;
+ isFlushing = true;
+
+ try {
+ var hasMoreWork = true;
+
+ do {
+ hasMoreWork = cb(true, currentMockTime);
+ } while (hasMoreWork && !didStop);
+
+ if (!hasMoreWork) {
+ scheduledCallback = null;
+ }
+ } finally {
+ expectedNumberOfYields = -1;
+ didStop = false;
+ isFlushing = false;
+ }
+ }
+}
+
+function unstable_flushUntilNextPaint() {
+ if (isFlushing) {
+ throw new Error('Already flushing work.');
+ }
+
+ if (scheduledCallback !== null) {
+ var cb = scheduledCallback;
+ shouldYieldForPaint = true;
+ needsPaint = false;
+ isFlushing = true;
+
+ try {
+ var hasMoreWork = true;
+
+ do {
+ hasMoreWork = cb(true, currentMockTime);
+ } while (hasMoreWork && !didStop);
+
+ if (!hasMoreWork) {
+ scheduledCallback = null;
+ }
+ } finally {
+ shouldYieldForPaint = false;
+ didStop = false;
+ isFlushing = false;
+ }
+ }
+}
+
+function unstable_flushExpired() {
+ if (isFlushing) {
+ throw new Error('Already flushing work.');
+ }
+
+ if (scheduledCallback !== null) {
+ isFlushing = true;
+
+ try {
+ var hasMoreWork = scheduledCallback(false, currentMockTime);
+
+ if (!hasMoreWork) {
+ scheduledCallback = null;
+ }
+ } finally {
+ isFlushing = false;
+ }
+ }
+}
+
+function unstable_flushAllWithoutAsserting() {
+ // Returns false if no work was flushed.
+ if (isFlushing) {
+ throw new Error('Already flushing work.');
+ }
+
+ if (scheduledCallback !== null) {
+ var cb = scheduledCallback;
+ isFlushing = true;
+
+ try {
+ var hasMoreWork = true;
+
+ do {
+ hasMoreWork = cb(true, currentMockTime);
+ } while (hasMoreWork);
+
+ if (!hasMoreWork) {
+ scheduledCallback = null;
+ }
+
+ return true;
+ } finally {
+ isFlushing = false;
+ }
+ } else {
+ return false;
+ }
+}
+
+function unstable_clearYields() {
+ if (yieldedValues === null) {
+ return [];
+ }
+
+ var values = yieldedValues;
+ yieldedValues = null;
+ return values;
+}
+
+function unstable_flushAll() {
+ if (yieldedValues !== null) {
+ throw new Error('Log is not empty. Assert on the log of yielded values before ' + 'flushing additional work.');
+ }
+
+ unstable_flushAllWithoutAsserting();
+
+ if (yieldedValues !== null) {
+ throw new 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([...])');
+ }
+}
+
+function unstable_yieldValue(value) {
+ // eslint-disable-next-line react-internal/no-production-logging
+ if (console.log.name === 'disabledLog' || disableYieldValue) {
+ // If console.log has been patched, we assume we're in render
+ // replaying and we ignore any values yielding in the second pass.
+ return;
+ }
+
+ if (yieldedValues === null) {
+ yieldedValues = [value];
+ } else {
+ yieldedValues.push(value);
+ }
+}
+
+function unstable_advanceTime(ms) {
+ // eslint-disable-next-line react-internal/no-production-logging
+ if (console.log.name === 'disabledLog' || disableYieldValue) {
+ // If console.log has been patched, we assume we're in render
+ // replaying and we ignore any time advancing in the second pass.
+ return;
+ }
+
+ currentMockTime += ms;
+
+ if (scheduledTimeout !== null && timeoutTime <= currentMockTime) {
+ scheduledTimeout(currentMockTime);
+ timeoutTime = -1;
+ scheduledTimeout = null;
+ }
+}
+
+function requestPaint() {
+ needsPaint = true;
+}
+var unstable_Profiling = null;
+
+exports.reset = reset;
+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_advanceTime = unstable_advanceTime;
+exports.unstable_cancelCallback = unstable_cancelCallback;
+exports.unstable_clearYields = unstable_clearYields;
+exports.unstable_continueExecution = unstable_continueExecution;
+exports.unstable_flushAll = unstable_flushAll;
+exports.unstable_flushAllWithoutAsserting = unstable_flushAllWithoutAsserting;
+exports.unstable_flushExpired = unstable_flushExpired;
+exports.unstable_flushNumberOfYields = unstable_flushNumberOfYields;
+exports.unstable_flushUntilNextPaint = unstable_flushUntilNextPaint;
+exports.unstable_forceFrameRate = forceFrameRate;
+exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
+exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode;
+exports.unstable_next = unstable_next;
+exports.unstable_now = getCurrentTime;
+exports.unstable_pauseExecution = unstable_pauseExecution;
+exports.unstable_requestPaint = requestPaint;
+exports.unstable_runWithPriority = unstable_runWithPriority;
+exports.unstable_scheduleCallback = unstable_scheduleCallback;
+exports.unstable_setDisableYieldValue = setDisableYieldValue;
+exports.unstable_shouldYield = shouldYieldToHost;
+exports.unstable_wrapCallback = unstable_wrapCallback;
+exports.unstable_yieldValue = unstable_yieldValue;
+ })();
+}
diff --git a/node_modules/scheduler/cjs/scheduler-unstable_mock.production.min.js b/node_modules/scheduler/cjs/scheduler-unstable_mock.production.min.js
new file mode 100644
index 0000000..9bf3c29
--- /dev/null
+++ b/node_modules/scheduler/cjs/scheduler-unstable_mock.production.min.js
@@ -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))};
diff --git a/node_modules/scheduler/cjs/scheduler-unstable_post_task.development.js b/node_modules/scheduler/cjs/scheduler-unstable_post_task.development.js
new file mode 100644
index 0000000..30b1221
--- /dev/null
+++ b/node_modules/scheduler/cjs/scheduler-unstable_post_task.development.js
@@ -0,0 +1,207 @@
+/**
+ * @license React
+ * scheduler-unstable_post_task.development.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';
+
+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);
+ }
+ } 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;
+ })();
+}
diff --git a/node_modules/scheduler/cjs/scheduler-unstable_post_task.production.min.js b/node_modules/scheduler/cjs/scheduler-unstable_post_task.production.min.js
new file mode 100644
index 0000000..a5ca18e
--- /dev/null
+++ b/node_modules/scheduler/cjs/scheduler-unstable_post_task.production.min.js
@@ -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}}};
diff --git a/node_modules/scheduler/cjs/scheduler.development.js b/node_modules/scheduler/cjs/scheduler.development.js
new file mode 100644
index 0000000..21bfb25
--- /dev/null
+++ b/node_modules/scheduler/cjs/scheduler.development.js
@@ -0,0 +1,634 @@
+/**
+ * @license React
+ * scheduler.development.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';
+
+if (process.env.NODE_ENV !== "production") {
+ (function() {
+
+ '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 {
+ // The parent is smaller. Exit.
+ return;
+ }
+ }
+}
+
+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;
+ }
+ } 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 workLoop(hasTimeRemaining, initialTime);
+ } catch (error) {
+ if (currentTask !== null) {
+ var currentTime = exports.unstable_now();
+ markTaskErrored(currentTask, currentTime);
+ currentTask.isQueued = false;
+ }
+
+ 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());
+}
+
+ })();
+}
diff --git a/node_modules/scheduler/cjs/scheduler.production.min.js b/node_modules/scheduler/cjs/scheduler.production.min.js
new file mode 100644
index 0000000..7f84d25
--- /dev/null
+++ b/node_modules/scheduler/cjs/scheduler.production.min.js
@@ -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}}};
generated by cgit v1.2.3 (git 2.39.1) at 2025-01-18 13:18:18 +0300