scheduler

Package Overview

Dependencies

Maintainers

Versions

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies

Install

scheduler - npm Package Compare versions

Comparing version 0.0.0-experimental-94c0244ba to 0.0.0-experimental-94e652d5-20240912

cjs/scheduler-unstable_mock.production.js

cjs/scheduler-unstable_post_task.production.js

cjs/scheduler.native.development.js

cjs/scheduler.native.production.js

cjs/scheduler.production.js

index.native.js

1239

cjs/scheduler-unstable_mock.development.js

		@@ -1,5 +0,6 @@
		/** @license React v0.0.0-experimental-94c0244ba
		/**
		* @license React
		* scheduler-unstable_mock.development.js
		*
		* Copyright (c) Facebook, Inc. and its affiliates.
		* Copyright (c) Meta Platforms, Inc. and affiliates.
		*
		@@ -10,862 +11,414 @@ * This source code is licensed under the MIT license found in the

		'use strict';

		if (process.env.NODE_ENV !== "production") {
		(function() {
		'use strict';

		var enableSchedulerDebugging = false;
		var enableProfiling = true;

		var currentTime = 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;
		function requestHostCallback(callback) {
		scheduledCallback = callback;
		}
		function requestHostTimeout(callback, ms) {
		scheduledTimeout = callback;
		timeoutTime = currentTime + ms;
		}
		function cancelHostTimeout() {
		scheduledTimeout = null;
		timeoutTime = -1;
		}
		function shouldYieldToHost() {
		if (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 currentTime;
		}
		function forceFrameRate() {// No-op
		}

		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, currentTime);
		} while (hasMoreWork && !didStop);

		if (!hasMoreWork) {
		scheduledCallback = null;
		"use strict";
		"production" !== process.env.NODE_ENV &&
		(function () {
		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;
		}
		} 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, currentTime);
		} while (hasMoreWork && !didStop);

		if (!hasMoreWork) {
		scheduledCallback = null;
		}
		} finally {
		shouldYieldForPaint = false;
		didStop = false;
		isFlushing = false;
		function peek(heap) {
		return 0 === heap.length ? null : heap[0];
		}
		}
		}
		function unstable_flushExpired() {
		if (isFlushing) {
		throw new Error('Already flushing work.');
		}
		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 (scheduledCallback !== null) {
		isFlushing = true;

		try {
		var hasMoreWork = scheduledCallback(false, currentTime);

		if (!hasMoreWork) {
		scheduledCallback = null;
		) {
		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;
		}
		}
		} finally {
		isFlushing = false;
		return first;
		}
		}
		}
		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, currentTime);
		} while (hasMoreWork);

		if (!hasMoreWork) {
		scheduledCallback = null;
		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);
		}

		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') {
		// 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') {
		// If console.log has been patched, we assume we're in render
		// replaying and we ignore any time advancing in the second pass.
		return;
		}

		currentTime += ms;

		if (scheduledTimeout !== null && timeoutTime <= currentTime) {
		scheduledTimeout(currentTime);
		timeoutTime = -1;
		scheduledTimeout = null;
		}
		}
		function requestPaint() {
		needsPaint = true;
		}

		function push(heap, node) {
		var index = heap.length;
		heap.push(node);
		siftUp(heap, node, index);
		}
		function peek(heap) {
		var first = heap[0];
		return first === undefined ? null : first;
		}
		function pop(heap) {
		var first = heap[0];

		if (first !== undefined) {
		var last = heap.pop();

		if (last !== first) {
		heap[0] = last;
		siftDown(heap, last, 0);
		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()));

		return first;
		} else {
		return null;
		}
		}

		function siftUp(heap, node, i) {
		var index = i;

		while (true) {
		var parentIndex = index - 1 >>> 1;
		var parent = heap[parentIndex];

		if (parent !== undefined && 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;

		while (index < length) {
		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 (left !== undefined && compare(left, node) < 0) {
		if (right !== undefined && compare(right, left) < 0) {
		heap[index] = right;
		heap[rightIndex] = node;
		index = rightIndex;
		} else {
		heap[index] = left;
		heap[leftIndex] = node;
		index = leftIndex;
		) {
		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);
		}
		} else if (right !== undefined && 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 NoPriority = 0;
		var ImmediatePriority = 1;
		var UserBlockingPriority = 2;
		var NormalPriority = 3;
		var LowPriority = 4;
		var IdlePriority = 5;

		var runIdCounter = 0;
		var mainThreadIdCounter = 0;
		var profilingStateSize = 4;
		var sharedProfilingBuffer = // $FlowFixMe Flow doesn't know about SharedArrayBuffer
		typeof SharedArrayBuffer === 'function' ? new SharedArrayBuffer(profilingStateSize * Int32Array.BYTES_PER_ELEMENT) : // $FlowFixMe Flow doesn't know about ArrayBuffer
		typeof ArrayBuffer === 'function' ? new ArrayBuffer(profilingStateSize * Int32Array.BYTES_PER_ELEMENT) : null // Don't crash the init path on IE9
		;
		var profilingState = sharedProfilingBuffer !== null ? new Int32Array(sharedProfilingBuffer) : []; // We can't read this but it helps save bytes for null checks

		var PRIORITY = 0;
		var CURRENT_TASK_ID = 1;
		var CURRENT_RUN_ID = 2;
		var QUEUE_SIZE = 3;

		{
		profilingState[PRIORITY] = NoPriority; // This is maintained with a counter, because the size of the priority queue
		// array might include canceled tasks.

		profilingState[QUEUE_SIZE] = 0;
		profilingState[CURRENT_TASK_ID] = 0;
		} // Bytes per element is 4


		var INITIAL_EVENT_LOG_SIZE = 131072;
		var MAX_EVENT_LOG_SIZE = 524288; // Equivalent to 2 megabytes

		var eventLogSize = 0;
		var eventLogBuffer = null;
		var eventLog = null;
		var eventLogIndex = 0;
		var TaskStartEvent = 1;
		var TaskCompleteEvent = 2;
		var TaskErrorEvent = 3;
		var TaskCancelEvent = 4;
		var TaskRunEvent = 5;
		var TaskYieldEvent = 6;
		var SchedulerSuspendEvent = 7;
		var SchedulerResumeEvent = 8;

		function logEvent(entries) {
		if (eventLog !== null) {
		var offset = eventLogIndex;
		eventLogIndex += entries.length;

		if (eventLogIndex + 1 > eventLogSize) {
		eventLogSize *= 2;

		if (eventLogSize > MAX_EVENT_LOG_SIZE) {
		// Using console['error'] to evade Babel and ESLint
		console['error']("Scheduler Profiling: Event log exceeded maximum size. Don't " + 'forget to call `stopLoggingProfilingEvents()`.');
		stopLoggingProfilingEvents();
		return;
		}

		var newEventLog = new Int32Array(eventLogSize * 4);
		newEventLog.set(eventLog);
		eventLogBuffer = newEventLog.buffer;
		eventLog = newEventLog;
		function shouldYieldToHost() {
		return (0 === expectedNumberOfYields && null === yieldedValues) \|\|
		(-1 !== expectedNumberOfYields &&
		null !== yieldedValues &&
		yieldedValues.length >= expectedNumberOfYields) \|\|
		(shouldYieldForPaint && needsPaint)
		? (didStop = !0)
		: !1;
		}

		eventLog.set(entries, offset);
		}
		}

		function startLoggingProfilingEvents() {
		eventLogSize = INITIAL_EVENT_LOG_SIZE;
		eventLogBuffer = new ArrayBuffer(eventLogSize * 4);
		eventLog = new Int32Array(eventLogBuffer);
		eventLogIndex = 0;
		}
		function stopLoggingProfilingEvents() {
		var buffer = eventLogBuffer;
		eventLogSize = 0;
		eventLogBuffer = null;
		eventLog = null;
		eventLogIndex = 0;
		return buffer;
		}
		function markTaskStart(task, ms) {
		{
		profilingState[QUEUE_SIZE]++;

		if (eventLog !== null) {
		// performance.now returns a float, representing milliseconds. When the
		// event is logged, it's coerced to an int. Convert to microseconds to
		// maintain extra degrees of precision.
		logEvent([TaskStartEvent, ms * 1000, task.id, task.priorityLevel]);
		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;
		}
		}
		}
		function markTaskCompleted(task, ms) {
		{
		profilingState[PRIORITY] = NoPriority;
		profilingState[CURRENT_TASK_ID] = 0;
		profilingState[QUEUE_SIZE]--;

		if (eventLog !== null) {
		logEvent([TaskCompleteEvent, ms * 1000, task.id]);
		}
		}
		}
		function markTaskCanceled(task, ms) {
		{
		profilingState[QUEUE_SIZE]--;

		if (eventLog !== null) {
		logEvent([TaskCancelEvent, ms * 1000, task.id]);
		}
		}
		}
		function markTaskErrored(task, ms) {
		{
		profilingState[PRIORITY] = NoPriority;
		profilingState[CURRENT_TASK_ID] = 0;
		profilingState[QUEUE_SIZE]--;

		if (eventLog !== null) {
		logEvent([TaskErrorEvent, ms * 1000, task.id]);
		}
		}
		}
		function markTaskRun(task, ms) {
		{
		runIdCounter++;
		profilingState[PRIORITY] = task.priorityLevel;
		profilingState[CURRENT_TASK_ID] = task.id;
		profilingState[CURRENT_RUN_ID] = runIdCounter;

		if (eventLog !== null) {
		logEvent([TaskRunEvent, ms * 1000, task.id, runIdCounter]);
		}
		}
		}
		function markTaskYield(task, ms) {
		{
		profilingState[PRIORITY] = NoPriority;
		profilingState[CURRENT_TASK_ID] = 0;
		profilingState[CURRENT_RUN_ID] = 0;

		if (eventLog !== null) {
		logEvent([TaskYieldEvent, ms * 1000, task.id, runIdCounter]);
		}
		}
		}
		function markSchedulerSuspended(ms) {
		{
		mainThreadIdCounter++;

		if (eventLog !== null) {
		logEvent([SchedulerSuspendEvent, ms * 1000, mainThreadIdCounter]);
		}
		}
		}
		function markSchedulerUnsuspended(ms) {
		{
		if (eventLog !== null) {
		logEvent([SchedulerResumeEvent, ms * 1000, mainThreadIdCounter]);
		}
		}
		}

		/* 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-entrancy.

		var isPerformingWork = false;
		var isHostCallbackScheduled = false;
		var isHostTimeoutScheduled = false;

		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);

		{
		markTaskStart(timer, currentTime);
		timer.isQueued = true;
		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;
		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_continueExecution = function () {
		isHostCallbackScheduled \|\|
		isPerformingWork \|\|
		((isHostCallbackScheduled = !0), (scheduledCallback = flushWork));
		};
		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;
		}
		}
		} 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);
		};
		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);
		}
		}
		}
		}
		}

		function flushWork(hasTimeRemaining, initialTime) {
		{
		markSchedulerUnsuspended(initialTime);
		} // We'll need a host callback the next time work is scheduled.


		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;
		};
		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;
		}

		throw error;
		}
		} else {
		// No catch in prod code path.
		return workLoop(hasTimeRemaining, initialTime);
		}
		} finally {
		currentTask = null;
		currentPriorityLevel = previousPriorityLevel;
		isPerformingWork = false;

		{
		var _currentTime = getCurrentTime();

		markSchedulerSuspended(_currentTime);
		}
		}
		}

		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;
		markTaskRun(currentTask, currentTime);
		var continuationCallback = callback(didUserCallbackTimeout);
		currentTime = getCurrentTime();

		if (typeof continuationCallback === 'function') {
		currentTask.callback = continuationCallback;
		markTaskYield(currentTask, currentTime);
		} else {
		{
		markTaskCompleted(currentTask, currentTime);
		currentTask.isQueued = false;
		return !1;
		};
		exports.unstable_forceFrameRate = function () {};
		exports.unstable_getCurrentPriorityLevel = function () {
		return currentPriorityLevel;
		};
		exports.unstable_getFirstCallbackNode = function () {
		return peek(taskQueue);
		};
		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_pauseExecution = function () {};
		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;
		}

		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
		};

		{
		newTask.isQueued = false;
		}

		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);

		{
		markTaskStart(newTask, currentTime);
		newTask.isQueued = true;
		} // Schedule a host callback, if needed. If we're already performing work,
		// 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) {
		{
		if (task.isQueued) {
		var currentTime = getCurrentTime();
		markTaskCanceled(task, currentTime);
		task.isQueued = false;
		}
		} // Null out the callback to indicate the task has been canceled. (Can't
		// 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 unstable_shouldYield() {
		var currentTime = getCurrentTime();
		advanceTimers(currentTime);
		var firstTask = peek(taskQueue);
		return firstTask !== currentTask && currentTask !== null && firstTask !== null && firstTask.callback !== null && firstTask.startTime <= currentTime && firstTask.expirationTime < currentTask.expirationTime \|\| shouldYieldToHost();
		}

		var unstable_requestPaint = requestPaint;
		var unstable_Profiling = {
		startLoggingProfilingEvents: startLoggingProfilingEvents,
		stopLoggingProfilingEvents: stopLoggingProfilingEvents,
		sharedProfilingBuffer: sharedProfilingBuffer
		} ;

		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 = unstable_requestPaint;
		exports.unstable_runWithPriority = unstable_runWithPriority;
		exports.unstable_scheduleCallback = unstable_scheduleCallback;
		exports.unstable_shouldYield = unstable_shouldYield;
		exports.unstable_wrapCallback = unstable_wrapCallback;
		exports.unstable_yieldValue = unstable_yieldValue;
		};
		};
		})();
		}

877

cjs/scheduler-unstable_post_task.development.js

		@@ -1,5 +0,6 @@
		/** @license React v0.0.0-experimental-94c0244ba
		/**
		* @license React
		* scheduler-unstable_post_task.development.js
		*
		* Copyright (c) Facebook, Inc. and its affiliates.
		* Copyright (c) Meta Platforms, Inc. and affiliates.
		*
		@@ -10,744 +11,146 @@ * This source code is licensed under the MIT license found in the

		'use strict';

		if (process.env.NODE_ENV !== "production") {
		(function() {
		'use strict';

		var enableSchedulerDebugging = false;
		var enableProfiling = true;

		// Capture local references to native APIs, in case a polyfill overrides them.
		var perf = window.performance;
		var setTimeout = window.setTimeout;
		var clearTimeout = window.clearTimeout;

		function postTask(callback) {
		// Use experimental Chrome Scheduler postTask API.
		global.scheduler.postTask(callback);
		}

		function getNow() {
		return perf.now();
		}

		var isTaskLoopRunning = 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 yieldInterval = 5;
		var deadline = 0; // `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 shouldYieldToHost() {
		return getNow() >= deadline;
		}
		function requestPaint() {// Since we yield every frame regardless, `requestPaint` has no effect.
		}
		function forceFrameRate(fps) {// No-op
		}

		function performWorkUntilDeadline() {
		if (scheduledHostCallback !== null) {
		var currentTime = getNow(); // Yield after `yieldInterval` ms, regardless of where we are in the vsync
		// cycle. This means there's always time remaining at the beginning of
		// the message event.

		deadline = currentTime + yieldInterval;
		var hasTimeRemaining = true;

		try {
		var hasMoreWork = scheduledHostCallback(hasTimeRemaining, currentTime);

		if (!hasMoreWork) {
		isTaskLoopRunning = false;
		scheduledHostCallback = null;
		} else {
		// If there's more work, schedule the next message event at the end
		// of the preceding one.
		postTask(performWorkUntilDeadline);
		"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;
		}
		} catch (error) {
		// If a scheduler task throws, exit the current browser task so the
		// error can be observed.
		postTask(performWorkUntilDeadline);
		throw error;
		}
		} else {
		isTaskLoopRunning = false;
		}
		}

		function requestHostCallback(callback) {
		scheduledHostCallback = callback;

		if (!isTaskLoopRunning) {
		isTaskLoopRunning = true;
		postTask(performWorkUntilDeadline);
		}
		}
		function requestHostTimeout(callback, ms) {
		taskTimeoutID = setTimeout(function () {
		callback(getNow());
		}, ms);
		}
		function cancelHostTimeout() {
		clearTimeout(taskTimeoutID);
		taskTimeoutID = -1;
		}
		var getCurrentTime = getNow;

		function push(heap, node) {
		var index = heap.length;
		heap.push(node);
		siftUp(heap, node, index);
		}
		function peek(heap) {
		var first = heap[0];
		return first === undefined ? null : first;
		}
		function pop(heap) {
		var first = heap[0];

		if (first !== undefined) {
		var last = heap.pop();

		if (last !== first) {
		heap[0] = last;
		siftDown(heap, last, 0);
		}

		return first;
		} else {
		return null;
		}
		}

		function siftUp(heap, node, i) {
		var index = i;

		while (true) {
		var parentIndex = index - 1 >>> 1;
		var parent = heap[parentIndex];

		if (parent !== undefined && 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;

		while (index < length) {
		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 (left !== undefined && compare(left, node) < 0) {
		if (right !== undefined && compare(right, left) < 0) {
		heap[index] = right;
		heap[rightIndex] = node;
		index = rightIndex;
		} else {
		heap[index] = left;
		heap[leftIndex] = node;
		index = leftIndex;
		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_continueExecution = function () {};
		exports.unstable_forceFrameRate = function () {};
		exports.unstable_getCurrentPriorityLevel = function () {
		return currentPriorityLevel_DEPRECATED;
		};
		exports.unstable_getFirstCallbackNode = function () {
		return null;
		};
		exports.unstable_next = function (callback) {
		switch (currentPriorityLevel_DEPRECATED) {
		case 1:
		case 2:
		case 3:
		var priorityLevel = 3;
		break;
		default:
		priorityLevel = currentPriorityLevel_DEPRECATED;
		}
		} else if (right !== undefined && 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 NoPriority = 0;
		var ImmediatePriority = 1;
		var UserBlockingPriority = 2;
		var NormalPriority = 3;
		var LowPriority = 4;
		var IdlePriority = 5;

		var runIdCounter = 0;
		var mainThreadIdCounter = 0;
		var profilingStateSize = 4;
		var sharedProfilingBuffer = // $FlowFixMe Flow doesn't know about SharedArrayBuffer
		typeof SharedArrayBuffer === 'function' ? new SharedArrayBuffer(profilingStateSize * Int32Array.BYTES_PER_ELEMENT) : // $FlowFixMe Flow doesn't know about ArrayBuffer
		typeof ArrayBuffer === 'function' ? new ArrayBuffer(profilingStateSize * Int32Array.BYTES_PER_ELEMENT) : null // Don't crash the init path on IE9
		;
		var profilingState = sharedProfilingBuffer !== null ? new Int32Array(sharedProfilingBuffer) : []; // We can't read this but it helps save bytes for null checks

		var PRIORITY = 0;
		var CURRENT_TASK_ID = 1;
		var CURRENT_RUN_ID = 2;
		var QUEUE_SIZE = 3;

		{
		profilingState[PRIORITY] = NoPriority; // This is maintained with a counter, because the size of the priority queue
		// array might include canceled tasks.

		profilingState[QUEUE_SIZE] = 0;
		profilingState[CURRENT_TASK_ID] = 0;
		} // Bytes per element is 4


		var INITIAL_EVENT_LOG_SIZE = 131072;
		var MAX_EVENT_LOG_SIZE = 524288; // Equivalent to 2 megabytes

		var eventLogSize = 0;
		var eventLogBuffer = null;
		var eventLog = null;
		var eventLogIndex = 0;
		var TaskStartEvent = 1;
		var TaskCompleteEvent = 2;
		var TaskErrorEvent = 3;
		var TaskCancelEvent = 4;
		var TaskRunEvent = 5;
		var TaskYieldEvent = 6;
		var SchedulerSuspendEvent = 7;
		var SchedulerResumeEvent = 8;

		function logEvent(entries) {
		if (eventLog !== null) {
		var offset = eventLogIndex;
		eventLogIndex += entries.length;

		if (eventLogIndex + 1 > eventLogSize) {
		eventLogSize *= 2;

		if (eventLogSize > MAX_EVENT_LOG_SIZE) {
		// Using console['error'] to evade Babel and ESLint
		console['error']("Scheduler Profiling: Event log exceeded maximum size. Don't " + 'forget to call `stopLoggingProfilingEvents()`.');
		stopLoggingProfilingEvents();
		return;
		var previousPriorityLevel = currentPriorityLevel_DEPRECATED;
		currentPriorityLevel_DEPRECATED = priorityLevel;
		try {
		return callback();
		} finally {
		currentPriorityLevel_DEPRECATED = previousPriorityLevel;
		}

		var newEventLog = new Int32Array(eventLogSize * 4);
		newEventLog.set(eventLog);
		eventLogBuffer = newEventLog.buffer;
		eventLog = newEventLog;
		}

		eventLog.set(entries, offset);
		}
		}

		function startLoggingProfilingEvents() {
		eventLogSize = INITIAL_EVENT_LOG_SIZE;
		eventLogBuffer = new ArrayBuffer(eventLogSize * 4);
		eventLog = new Int32Array(eventLogBuffer);
		eventLogIndex = 0;
		}
		function stopLoggingProfilingEvents() {
		var buffer = eventLogBuffer;
		eventLogSize = 0;
		eventLogBuffer = null;
		eventLog = null;
		eventLogIndex = 0;
		return buffer;
		}
		function markTaskStart(task, ms) {
		{
		profilingState[QUEUE_SIZE]++;

		if (eventLog !== null) {
		// performance.now returns a float, representing milliseconds. When the
		// event is logged, it's coerced to an int. Convert to microseconds to
		// maintain extra degrees of precision.
		logEvent([TaskStartEvent, ms * 1000, task.id, task.priorityLevel]);
		}
		}
		}
		function markTaskCompleted(task, ms) {
		{
		profilingState[PRIORITY] = NoPriority;
		profilingState[CURRENT_TASK_ID] = 0;
		profilingState[QUEUE_SIZE]--;

		if (eventLog !== null) {
		logEvent([TaskCompleteEvent, ms * 1000, task.id]);
		}
		}
		}
		function markTaskCanceled(task, ms) {
		{
		profilingState[QUEUE_SIZE]--;

		if (eventLog !== null) {
		logEvent([TaskCancelEvent, ms * 1000, task.id]);
		}
		}
		}
		function markTaskErrored(task, ms) {
		{
		profilingState[PRIORITY] = NoPriority;
		profilingState[CURRENT_TASK_ID] = 0;
		profilingState[QUEUE_SIZE]--;

		if (eventLog !== null) {
		logEvent([TaskErrorEvent, ms * 1000, task.id]);
		}
		}
		}
		function markTaskRun(task, ms) {
		{
		runIdCounter++;
		profilingState[PRIORITY] = task.priorityLevel;
		profilingState[CURRENT_TASK_ID] = task.id;
		profilingState[CURRENT_RUN_ID] = runIdCounter;

		if (eventLog !== null) {
		logEvent([TaskRunEvent, ms * 1000, task.id, runIdCounter]);
		}
		}
		}
		function markTaskYield(task, ms) {
		{
		profilingState[PRIORITY] = NoPriority;
		profilingState[CURRENT_TASK_ID] = 0;
		profilingState[CURRENT_RUN_ID] = 0;

		if (eventLog !== null) {
		logEvent([TaskYieldEvent, ms * 1000, task.id, runIdCounter]);
		}
		}
		}
		function markSchedulerSuspended(ms) {
		{
		mainThreadIdCounter++;

		if (eventLog !== null) {
		logEvent([SchedulerSuspendEvent, ms * 1000, mainThreadIdCounter]);
		}
		}
		}
		function markSchedulerUnsuspended(ms) {
		{
		if (eventLog !== null) {
		logEvent([SchedulerResumeEvent, ms * 1000, mainThreadIdCounter]);
		}
		}
		}

		/* 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-entrancy.

		var isPerformingWork = false;
		var isHostCallbackScheduled = false;
		var isHostTimeoutScheduled = false;

		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);

		{
		markTaskStart(timer, currentTime);
		timer.isQueued = true;
		};
		exports.unstable_now = getCurrentTime;
		exports.unstable_pauseExecution = function () {};
		exports.unstable_requestPaint = function () {};
		exports.unstable_runWithPriority = function (priorityLevel, callback) {
		var previousPriorityLevel = currentPriorityLevel_DEPRECATED;
		currentPriorityLevel_DEPRECATED = priorityLevel;
		try {
		return callback();
		} finally {
		currentPriorityLevel_DEPRECATED = previousPriorityLevel;
		}
		} 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);
		};
		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";
		}
		}
		}
		}

		function flushWork(hasTimeRemaining, initialTime) {
		{
		markSchedulerUnsuspended(initialTime);
		} // We'll need a host callback the next time work is scheduled.


		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;
		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;
		}

		throw error;
		}
		} else {
		// No catch in prod code path.
		return workLoop(hasTimeRemaining, initialTime);
		}
		} finally {
		currentTask = null;
		currentPriorityLevel = previousPriorityLevel;
		isPerformingWork = false;

		{
		var _currentTime = getCurrentTime();

		markSchedulerSuspended(_currentTime);
		}
		}
		}

		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;
		markTaskRun(currentTask, currentTime);
		var continuationCallback = callback(didUserCallbackTimeout);
		currentTime = getCurrentTime();

		if (typeof continuationCallback === 'function') {
		currentTask.callback = continuationCallback;
		markTaskYield(currentTask, currentTime);
		} else {
		{
		markTaskCompleted(currentTask, currentTime);
		currentTask.isQueued = false;
		}

		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
		};

		{
		newTask.isQueued = false;
		}

		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);

		{
		markTaskStart(newTask, currentTime);
		newTask.isQueued = true;
		} // Schedule a host callback, if needed. If we're already performing work,
		// 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) {
		{
		if (task.isQueued) {
		var currentTime = getCurrentTime();
		markTaskCanceled(task, currentTime);
		task.isQueued = false;
		}
		} // Null out the callback to indicate the task has been canceled. (Can't
		// 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 unstable_shouldYield() {
		var currentTime = getCurrentTime();
		advanceTimers(currentTime);
		var firstTask = peek(taskQueue);
		return firstTask !== currentTask && currentTask !== null && firstTask !== null && firstTask.callback !== null && firstTask.startTime <= currentTime && firstTask.expirationTime < currentTask.expirationTime \|\| shouldYieldToHost();
		}

		var unstable_requestPaint = requestPaint;
		var unstable_Profiling = {
		startLoggingProfilingEvents: startLoggingProfilingEvents,
		stopLoggingProfilingEvents: stopLoggingProfilingEvents,
		sharedProfilingBuffer: sharedProfilingBuffer
		} ;

		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_now = getCurrentTime;
		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;
		};
		};
		})();
		}

1153

cjs/scheduler.development.js

		@@ -1,5 +0,6 @@
		/** @license React v0.0.0-experimental-94c0244ba
		/**
		* @license React
		* scheduler.development.js
		*
		* Copyright (c) Facebook, Inc. and its affiliates.
		* Copyright (c) Meta Platforms, Inc. and affiliates.
		*
		@@ -10,845 +11,355 @@ * This source code is licensed under the MIT license found in the

		'use strict';

		if (process.env.NODE_ENV !== "production") {
		(function() {
		'use strict';

		var enableSchedulerDebugging = false;
		var enableProfiling = true;

		var requestHostCallback;
		var requestHostTimeout;
		var cancelHostTimeout;
		var shouldYieldToHost;
		var requestPaint;
		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;
		};
		}

		if ( // If Scheduler runs in a non-DOM environment, it falls back to a naive
		// implementation using setTimeout.
		typeof window === 'undefined' \|\| // Check if MessageChannel is supported, too.
		typeof MessageChannel !== 'function') {
		// If this accidentally gets imported in a non-browser environment, e.g. JavaScriptCore,
		// fallback to a naive implementation.
		var _callback = null;
		var _timeoutID = null;

		var _flushCallback = function () {
		if (_callback !== null) {
		try {
		"use strict";
		"production" !== process.env.NODE_ENV &&
		(function () {
		function performWorkUntilDeadline() {
		if (isMessageLoopRunning) {
		var currentTime = exports.unstable_now();
		var hasRemainingTime = true;
		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()
		);

		_callback(hasRemainingTime, currentTime);

		_callback = null;
		} catch (e) {
		setTimeout(_flushCallback, 0);
		throw e;
		) {
		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);
		}
		}
		}
		};

		requestHostCallback = function (cb) {
		if (_callback !== null) {
		// Protect against re-entrancy.
		setTimeout(requestHostCallback, 0, cb);
		} else {
		_callback = cb;
		setTimeout(_flushCallback, 0);
		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;
		}
		}
		};

		requestHostTimeout = function (cb, ms) {
		_timeoutID = setTimeout(cb, ms);
		};

		cancelHostTimeout = function () {
		clearTimeout(_timeoutID);
		};

		shouldYieldToHost = function () {
		return false;
		};

		requestPaint = exports.unstable_forceFrameRate = function () {};
		} else {
		// Capture local references to native APIs, in case a polyfill overrides them.
		var _setTimeout = window.setTimeout;
		var _clearTimeout = window.clearTimeout;

		if (typeof console !== 'undefined') {
		// TODO: Scheduler no longer requires these methods to be polyfilled. But
		// maybe we want to continue warning if they don't exist, to preserve the
		// option to rely on it in the future?
		var requestAnimationFrame = window.requestAnimationFrame;
		var cancelAnimationFrame = window.cancelAnimationFrame; // TODO: Remove fb.me link

		if (typeof requestAnimationFrame !== 'function') {
		// Using console['error'] to evade Babel and ESLint
		console['error']("This browser doesn't support requestAnimationFrame. " + 'Make sure that you load a ' + 'polyfill in older browsers. https://fb.me/react-polyfills');
		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 (typeof cancelAnimationFrame !== 'function') {
		// Using console['error'] to evade Babel and ESLint
		console['error']("This browser doesn't support cancelAnimationFrame. " + 'Make sure that you load a ' + 'polyfill in older browsers. https://fb.me/react-polyfills');
		}
		}

		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 yieldInterval = 5;
		var deadline = 0; // TODO: Make this configurable

		{
		// `isInputPending` is not available. Since we have no way of knowing if
		// there's pending input, always yield at the end of the frame.
		shouldYieldToHost = function () {
		return exports.unstable_now() >= deadline;
		}; // Since we yield every frame regardless, `requestPaint` has no effect.


		requestPaint = function () {};
		}

		exports.unstable_forceFrameRate = function (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) {
		yieldInterval = Math.floor(1000 / fps);
		} else {
		// reset the framerate
		yieldInterval = 5;
		}
		};

		var performWorkUntilDeadline = function () {
		if (scheduledHostCallback !== null) {
		var currentTime = exports.unstable_now(); // Yield after `yieldInterval` ms, regardless of where we are in the vsync
		// cycle. This means there's always time remaining at the beginning of
		// the message event.

		deadline = currentTime + yieldInterval;
		var hasTimeRemaining = true;

		try {
		var hasMoreWork = scheduledHostCallback(hasTimeRemaining, currentTime);

		if (!hasMoreWork) {
		isMessageLoopRunning = false;
		scheduledHostCallback = null;
		} else {
		// If there's more work, schedule the next message event at the end
		// of the preceding one.
		port.postMessage(null);
		) {
		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;
		}
		} catch (error) {
		// If a scheduler task throws, exit the current browser task so the
		// error can be observed.
		port.postMessage(null);
		throw error;
		}
		} else {
		isMessageLoopRunning = false;
		} // Yielding to the browser will give it a chance to paint, so we can
		};

		var channel = new MessageChannel();
		var port = channel.port2;
		channel.port1.onmessage = performWorkUntilDeadline;

		requestHostCallback = function (callback) {
		scheduledHostCallback = callback;

		if (!isMessageLoopRunning) {
		isMessageLoopRunning = true;
		port.postMessage(null);
		return first;
		}
		};

		requestHostTimeout = function (callback, ms) {
		taskTimeoutID = _setTimeout(function () {
		callback(exports.unstable_now());
		}, ms);
		};

		cancelHostTimeout = function () {
		_clearTimeout(taskTimeoutID);

		taskTimeoutID = -1;
		};
		}

		function push(heap, node) {
		var index = heap.length;
		heap.push(node);
		siftUp(heap, node, index);
		}
		function peek(heap) {
		var first = heap[0];
		return first === undefined ? null : first;
		}
		function pop(heap) {
		var first = heap[0];

		if (first !== undefined) {
		var last = heap.pop();

		if (last !== first) {
		heap[0] = last;
		siftDown(heap, last, 0);
		function compare(a, b) {
		var diff = a.sortIndex - b.sortIndex;
		return 0 !== diff ? diff : a.id - b.id;
		}

		return first;
		} else {
		return null;
		}
		}

		function siftUp(heap, node, i) {
		var index = i;

		while (true) {
		var parentIndex = index - 1 >>> 1;
		var parent = heap[parentIndex];

		if (parent !== undefined && 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;

		while (index < length) {
		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 (left !== undefined && compare(left, node) < 0) {
		if (right !== undefined && compare(right, left) < 0) {
		heap[index] = right;
		heap[rightIndex] = node;
		index = rightIndex;
		} else {
		heap[index] = left;
		heap[leftIndex] = node;
		index = leftIndex;
		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);
		}
		} else if (right !== undefined && 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 NoPriority = 0;
		var ImmediatePriority = 1;
		var UserBlockingPriority = 2;
		var NormalPriority = 3;
		var LowPriority = 4;
		var IdlePriority = 5;

		var runIdCounter = 0;
		var mainThreadIdCounter = 0;
		var profilingStateSize = 4;
		var sharedProfilingBuffer = // $FlowFixMe Flow doesn't know about SharedArrayBuffer
		typeof SharedArrayBuffer === 'function' ? new SharedArrayBuffer(profilingStateSize * Int32Array.BYTES_PER_ELEMENT) : // $FlowFixMe Flow doesn't know about ArrayBuffer
		typeof ArrayBuffer === 'function' ? new ArrayBuffer(profilingStateSize * Int32Array.BYTES_PER_ELEMENT) : null // Don't crash the init path on IE9
		;
		var profilingState = sharedProfilingBuffer !== null ? new Int32Array(sharedProfilingBuffer) : []; // We can't read this but it helps save bytes for null checks

		var PRIORITY = 0;
		var CURRENT_TASK_ID = 1;
		var CURRENT_RUN_ID = 2;
		var QUEUE_SIZE = 3;

		{
		profilingState[PRIORITY] = NoPriority; // This is maintained with a counter, because the size of the priority queue
		// array might include canceled tasks.

		profilingState[QUEUE_SIZE] = 0;
		profilingState[CURRENT_TASK_ID] = 0;
		} // Bytes per element is 4


		var INITIAL_EVENT_LOG_SIZE = 131072;
		var MAX_EVENT_LOG_SIZE = 524288; // Equivalent to 2 megabytes

		var eventLogSize = 0;
		var eventLogBuffer = null;
		var eventLog = null;
		var eventLogIndex = 0;
		var TaskStartEvent = 1;
		var TaskCompleteEvent = 2;
		var TaskErrorEvent = 3;
		var TaskCancelEvent = 4;
		var TaskRunEvent = 5;
		var TaskYieldEvent = 6;
		var SchedulerSuspendEvent = 7;
		var SchedulerResumeEvent = 8;

		function logEvent(entries) {
		if (eventLog !== null) {
		var offset = eventLogIndex;
		eventLogIndex += entries.length;

		if (eventLogIndex + 1 > eventLogSize) {
		eventLogSize *= 2;

		if (eventLogSize > MAX_EVENT_LOG_SIZE) {
		// Using console['error'] to evade Babel and ESLint
		console['error']("Scheduler Profiling: Event log exceeded maximum size. Don't " + 'forget to call `stopLoggingProfilingEvents()`.');
		stopLoggingProfilingEvents();
		return;
		}

		var newEventLog = new Int32Array(eventLogSize * 4);
		newEventLog.set(eventLog);
		eventLogBuffer = newEventLog.buffer;
		eventLog = newEventLog;
		function handleTimeout(currentTime) {
		isHostTimeoutScheduled = !1;
		advanceTimers(currentTime);
		if (!isHostCallbackScheduled)
		if (null !== peek(taskQueue))
		(isHostCallbackScheduled = !0), requestHostCallback();
		else {
		var firstTimer = peek(timerQueue);
		null !== firstTimer &&
		requestHostTimeout(
		handleTimeout,
		firstTimer.startTime - currentTime
		);
		}
		}

		eventLog.set(entries, offset);
		}
		}

		function startLoggingProfilingEvents() {
		eventLogSize = INITIAL_EVENT_LOG_SIZE;
		eventLogBuffer = new ArrayBuffer(eventLogSize * 4);
		eventLog = new Int32Array(eventLogBuffer);
		eventLogIndex = 0;
		}
		function stopLoggingProfilingEvents() {
		var buffer = eventLogBuffer;
		eventLogSize = 0;
		eventLogBuffer = null;
		eventLog = null;
		eventLogIndex = 0;
		return buffer;
		}
		function markTaskStart(task, ms) {
		{
		profilingState[QUEUE_SIZE]++;

		if (eventLog !== null) {
		// performance.now returns a float, representing milliseconds. When the
		// event is logged, it's coerced to an int. Convert to microseconds to
		// maintain extra degrees of precision.
		logEvent([TaskStartEvent, ms * 1000, task.id, task.priorityLevel]);
		function shouldYieldToHost() {
		return exports.unstable_now() - startTime < frameInterval ? !1 : !0;
		}
		}
		}
		function markTaskCompleted(task, ms) {
		{
		profilingState[PRIORITY] = NoPriority;
		profilingState[CURRENT_TASK_ID] = 0;
		profilingState[QUEUE_SIZE]--;

		if (eventLog !== null) {
		logEvent([TaskCompleteEvent, ms * 1000, task.id]);
		function requestHostCallback() {
		isMessageLoopRunning \|\|
		((isMessageLoopRunning = !0), schedulePerformWorkUntilDeadline());
		}
		}
		}
		function markTaskCanceled(task, ms) {
		{
		profilingState[QUEUE_SIZE]--;

		if (eventLog !== null) {
		logEvent([TaskCancelEvent, ms * 1000, task.id]);
		function requestHostTimeout(callback, ms) {
		taskTimeoutID = localSetTimeout(function () {
		callback(exports.unstable_now());
		}, ms);
		}
		}
		}
		function markTaskErrored(task, ms) {
		{
		profilingState[PRIORITY] = NoPriority;
		profilingState[CURRENT_TASK_ID] = 0;
		profilingState[QUEUE_SIZE]--;

		if (eventLog !== null) {
		logEvent([TaskErrorEvent, ms * 1000, task.id]);
		}
		}
		}
		function markTaskRun(task, ms) {
		{
		runIdCounter++;
		profilingState[PRIORITY] = task.priorityLevel;
		profilingState[CURRENT_TASK_ID] = task.id;
		profilingState[CURRENT_RUN_ID] = runIdCounter;

		if (eventLog !== null) {
		logEvent([TaskRunEvent, ms * 1000, task.id, runIdCounter]);
		}
		}
		}
		function markTaskYield(task, ms) {
		{
		profilingState[PRIORITY] = NoPriority;
		profilingState[CURRENT_TASK_ID] = 0;
		profilingState[CURRENT_RUN_ID] = 0;

		if (eventLog !== null) {
		logEvent([TaskYieldEvent, ms * 1000, task.id, runIdCounter]);
		}
		}
		}
		function markSchedulerSuspended(ms) {
		{
		mainThreadIdCounter++;

		if (eventLog !== null) {
		logEvent([SchedulerSuspendEvent, ms * 1000, mainThreadIdCounter]);
		}
		}
		}
		function markSchedulerUnsuspended(ms) {
		{
		if (eventLog !== null) {
		logEvent([SchedulerResumeEvent, ms * 1000, mainThreadIdCounter]);
		}
		}
		}

		/* 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-entrancy.

		var isPerformingWork = false;
		var isHostCallbackScheduled = false;
		var isHostTimeoutScheduled = false;

		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);

		{
		markTaskStart(timer, currentTime);
		timer.isQueued = true;
		}
		"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 {
		// Remaining timers are pending.
		return;
		var localDate = Date,
		initialTime = localDate.now();
		exports.unstable_now = function () {
		return localDate.now() - initialTime;
		};
		}

		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);
		var taskQueue = [],
		timerQueue = [],
		taskIdCounter = 1,
		currentTask = null,
		currentPriorityLevel = 3,
		isPerformingWork = !1,
		isHostCallbackScheduled = !1,
		isHostTimeoutScheduled = !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_continueExecution = function () {
		isHostCallbackScheduled \|\|
		isPerformingWork \|\|
		((isHostCallbackScheduled = !0), requestHostCallback());
		};
		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_getFirstCallbackNode = function () {
		return peek(taskQueue);
		};
		exports.unstable_next = function (eventHandler) {
		switch (currentPriorityLevel) {
		case 1:
		case 2:
		case 3:
		var priorityLevel = 3;
		break;
		default:
		priorityLevel = currentPriorityLevel;
		}
		}
		}
		}

		function flushWork(hasTimeRemaining, initialTime) {
		{
		markSchedulerUnsuspended(initialTime);
		} // We'll need a host callback the next time work is scheduled.


		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) {
		var previousPriorityLevel = currentPriorityLevel;
		currentPriorityLevel = priorityLevel;
		try {
		return workLoop(hasTimeRemaining, initialTime);
		} catch (error) {
		if (currentTask !== null) {
		var currentTime = exports.unstable_now();
		markTaskErrored(currentTask, currentTime);
		currentTask.isQueued = false;
		}

		throw error;
		return eventHandler();
		} finally {
		currentPriorityLevel = previousPriorityLevel;
		}
		} else {
		// No catch in prod code path.
		return workLoop(hasTimeRemaining, initialTime);
		}
		} finally {
		currentTask = null;
		currentPriorityLevel = previousPriorityLevel;
		isPerformingWork = false;

		{
		var _currentTime = exports.unstable_now();

		markSchedulerSuspended(_currentTime);
		}
		}
		}

		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;
		markTaskRun(currentTask, currentTime);
		var continuationCallback = callback(didUserCallbackTimeout);
		currentTime = exports.unstable_now();

		if (typeof continuationCallback === 'function') {
		currentTask.callback = continuationCallback;
		markTaskYield(currentTask, currentTime);
		} else {
		{
		markTaskCompleted(currentTask, currentTime);
		currentTask.isQueued = false;
		}

		if (currentTask === peek(taskQueue)) {
		pop(taskQueue);
		}
		};
		exports.unstable_pauseExecution = function () {};
		exports.unstable_requestPaint = function () {};
		exports.unstable_runWithPriority = function (priorityLevel, eventHandler) {
		switch (priorityLevel) {
		case 1:
		case 2:
		case 3:
		case 4:
		case 5:
		break;
		default:
		priorityLevel = 3;
		}

		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
		};

		{
		newTask.isQueued = false;
		}

		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);

		{
		markTaskStart(newTask, currentTime);
		newTask.isQueued = true;
		} // Schedule a host callback, if needed. If we're already performing work,
		// 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) {
		{
		if (task.isQueued) {
		var previousPriorityLevel = currentPriorityLevel;
		currentPriorityLevel = priorityLevel;
		try {
		return eventHandler();
		} finally {
		currentPriorityLevel = previousPriorityLevel;
		}
		};
		exports.unstable_scheduleCallback = function (
		priorityLevel,
		callback,
		options
		) {
		var currentTime = exports.unstable_now();
		markTaskCanceled(task, currentTime);
		task.isQueued = false;
		}
		} // Null out the callback to indicate the task has been canceled. (Can't
		// 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 unstable_shouldYield() {
		var currentTime = exports.unstable_now();
		advanceTimers(currentTime);
		var firstTask = peek(taskQueue);
		return firstTask !== currentTask && currentTask !== null && firstTask !== null && firstTask.callback !== null && firstTask.startTime <= currentTime && firstTask.expirationTime < currentTask.expirationTime \|\| shouldYieldToHost();
		}

		var unstable_requestPaint = requestPaint;
		var unstable_Profiling = {
		startLoggingProfilingEvents: startLoggingProfilingEvents,
		stopLoggingProfilingEvents: stopLoggingProfilingEvents,
		sharedProfilingBuffer: sharedProfilingBuffer
		} ;

		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_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 = unstable_shouldYield;
		exports.unstable_wrapCallback = unstable_wrapCallback;
		"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), requestHostCallback()));
		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());
		})();
		}

index.js

		'use strict';

		if (process.env.NODE_ENV === 'production') {
		module.exports = require('./cjs/scheduler.production.min.js');
		module.exports = require('./cjs/scheduler.production.js');
		} else {
		module.exports = require('./cjs/scheduler.development.js');
		}

package.json

		{
		"name": "scheduler",
		"version": "0.0.0-experimental-94c0244ba",
		"version": "0.0.0-experimental-94e652d5-20240912",
		"description": "Cooperative scheduler for the browser environment.",
		"main": "index.js",
		"repository": {
		@@ -18,24 +17,12 @@ "type": "git",
		},
		"homepage": "https://reactjs.org/",
		"dependencies": {
		"loose-envify": "^1.1.0",
		"object-assign": "^4.1.1"
		},
		"homepage": "https://react.dev/",
		"files": [
		"LICENSE",
		"README.md",
		"build-info.json",
		"index.js",
		"tracing.js",
		"tracing-profiling.js",
		"index.native.js",
		"unstable_mock.js",
		"unstable_post_task.js",
		"cjs/",
		"umd/"
		],
		"browserify": {
		"transform": [
		"loose-envify"
		]
		}
		}
		"cjs/"
		]
		}

unstable_mock.js

		'use strict';

		if (process.env.NODE_ENV === 'production') {
		module.exports = require('./cjs/scheduler-unstable_mock.production.min.js');
		module.exports = require('./cjs/scheduler-unstable_mock.production.js');
		} else {
		module.exports = require('./cjs/scheduler-unstable_mock.development.js');
		}

unstable_post_task.js

		'use strict';

		if (process.env.NODE_ENV === 'production') {
		module.exports = require('./cjs/scheduler-unstable_post_task.production.min.js');
		module.exports = require('./cjs/scheduler-unstable_post_task.production.js');
		} else {
		module.exports = require('./cjs/scheduler-unstable_post_task.development.js');
		}

build-info.json

cjs/scheduler-tracing.development.js

cjs/scheduler-tracing.production.min.js

cjs/scheduler-tracing.profiling.min.js

cjs/scheduler-unstable_mock.production.min.js

cjs/scheduler-unstable_post_task.production.min.js

cjs/scheduler.production.min.js

tracing-profiling.js

tracing.js

umd/scheduler-tracing.development.js

umd/scheduler-tracing.production.min.js

umd/scheduler-tracing.profiling.min.js

umd/scheduler-unstable_mock.development.js

umd/scheduler-unstable_mock.production.min.js

umd/scheduler.development.js

umd/scheduler.production.min.js

umd/scheduler.profiling.min.js

LICENSE

Sorry, the diff of this file is not supported yet

scheduler - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics

Dependency changes