scheduler - npm Package Compare versions

Comparing version 0.0.0-experimental-65b3449c8-20221005 to 0.0.0-experimental-65e06cb7-20241218

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

1089

cjs/scheduler-unstable_mock.development.js

		@@ -5,3 +5,3 @@ /**
		*
		* Copyright (c) Facebook, Inc. and its affiliates.
		* Copyright (c) Meta Platforms, Inc. and affiliates.
		*
		@@ -12,715 +12,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 = false;

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

		var first = heap[0];
		var last = heap.pop();

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

		return first;
		}

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

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

		if (compare(parent, node) > 0) {
		// The parent is larger. Swap positions.
		heap[parentIndex] = node;
		heap[index] = parent;
		index = parentIndex;
		} else {
		// The parent is smaller. Exit.
		return;
		"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;
		}
		}
		}
		}
		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;

		function siftDown(heap, node, i) {
		var index = i;
		var length = heap.length;
		var halfLength = length >>> 1;

		while (index < halfLength) {
		var leftIndex = (index + 1) * 2 - 1;
		var left = heap[leftIndex];
		var rightIndex = leftIndex + 1;
		var right = heap[rightIndex]; // If the left or right node is smaller, swap with the smaller of those.

		if (compare(left, node) < 0) {
		if (rightIndex < length && compare(right, left) < 0) {
		heap[index] = right;
		heap[rightIndex] = node;
		index = rightIndex;
		} else {
		heap[index] = left;
		heap[leftIndex] = node;
		index = leftIndex;
		) {
		var 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;
		}
		}
		} else if (rightIndex < length && compare(right, node) < 0) {
		heap[index] = right;
		heap[rightIndex] = node;
		index = rightIndex;
		} else {
		// Neither child is smaller. Exit.
		return;
		return first;
		}
		}
		}

		function compare(a, b) {
		// Compare sort index first, then task id.
		var diff = a.sortIndex - b.sortIndex;
		return diff !== 0 ? diff : a.id - b.id;
		}

		// TODO: Use symbols?
		var ImmediatePriority = 1;
		var UserBlockingPriority = 2;
		var NormalPriority = 3;
		var LowPriority = 4;
		var IdlePriority = 5;

		function markTaskErrored(task, ms) {
		}

		/* eslint-disable no-var */
		// Max 31 bit integer. The max integer size in V8 for 32-bit systems.
		// Math.pow(2, 30) - 1
		// 0b111111111111111111111111111111
		var maxSigned31BitInt = 1073741823; // Times out immediately

		var IMMEDIATE_PRIORITY_TIMEOUT = -1; // Eventually times out

		var USER_BLOCKING_PRIORITY_TIMEOUT = 250;
		var NORMAL_PRIORITY_TIMEOUT = 5000;
		var LOW_PRIORITY_TIMEOUT = 10000; // Never times out

		var IDLE_PRIORITY_TIMEOUT = maxSigned31BitInt; // Tasks are stored on a min heap

		var taskQueue = [];
		var timerQueue = []; // Incrementing id counter. Used to maintain insertion order.

		var taskIdCounter = 1; // Pausing the scheduler is useful for debugging.
		var currentTask = null;
		var currentPriorityLevel = NormalPriority; // This is set while performing work, to prevent re-entrance.

		var isPerformingWork = false;
		var isHostCallbackScheduled = false;
		var isHostTimeoutScheduled = false;
		var currentMockTime = 0;
		var scheduledCallback = null;
		var scheduledTimeout = null;
		var timeoutTime = -1;
		var yieldedValues = null;
		var expectedNumberOfYields = -1;
		var didStop = false;
		var isFlushing = false;
		var needsPaint = false;
		var shouldYieldForPaint = false;
		var disableYieldValue = false;

		function setDisableYieldValue(newValue) {
		disableYieldValue = newValue;
		}

		function advanceTimers(currentTime) {
		// Check for tasks that are no longer delayed and add them to the queue.
		var timer = peek(timerQueue);

		while (timer !== null) {
		if (timer.callback === null) {
		// Timer was cancelled.
		pop(timerQueue);
		} else if (timer.startTime <= currentTime) {
		// Timer fired. Transfer to the task queue.
		pop(timerQueue);
		timer.sortIndex = timer.expirationTime;
		push(taskQueue, timer);
		} else {
		// Remaining timers are pending.
		return;
		function compare(a, b) {
		var diff = a.sortIndex - b.sortIndex;
		return 0 !== diff ? diff : a.id - b.id;
		}

		timer = peek(timerQueue);
		}
		}

		function handleTimeout(currentTime) {
		isHostTimeoutScheduled = false;
		advanceTimers(currentTime);

		if (!isHostCallbackScheduled) {
		if (peek(taskQueue) !== null) {
		isHostCallbackScheduled = true;
		requestHostCallback(flushWork);
		} else {
		var firstTimer = peek(timerQueue);

		if (firstTimer !== null) {
		requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
		function advanceTimers(currentTime) {
		for (var timer = peek(timerQueue); null !== timer; ) {
		if (null === timer.callback) pop(timerQueue);
		else if (timer.startTime <= currentTime)
		pop(timerQueue),
		(timer.sortIndex = timer.expirationTime),
		push(taskQueue, timer);
		else break;
		timer = peek(timerQueue);
		}
		}
		}
		}

		function flushWork(hasTimeRemaining, initialTime) {


		isHostCallbackScheduled = false;

		if (isHostTimeoutScheduled) {
		// We scheduled a timeout but it's no longer needed. Cancel it.
		isHostTimeoutScheduled = false;
		cancelHostTimeout();
		}

		isPerformingWork = true;
		var previousPriorityLevel = currentPriorityLevel;

		try {
		if (enableProfiling) {
		try {
		return workLoop(hasTimeRemaining, initialTime);
		} catch (error) {
		if (currentTask !== null) {
		var currentTime = getCurrentTime(); // $FlowFixMe[incompatible-call] found when upgrading Flow

		markTaskErrored(currentTask, currentTime); // $FlowFixMe[incompatible-use] found when upgrading Flow

		currentTask.isQueued = false;
		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));
		}

		throw error;
		}
		} else {
		// No catch in prod code path.
		return workLoop(hasTimeRemaining, initialTime);
		}
		} finally {
		currentTask = null;
		currentPriorityLevel = previousPriorityLevel;
		isPerformingWork = false;
		}
		}
		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()));

		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;
		} // $FlowFixMe[incompatible-use] found when upgrading Flow


		var callback = currentTask.callback;

		if (typeof callback === 'function') {
		// $FlowFixMe[incompatible-use] found when upgrading Flow
		currentTask.callback = null; // $FlowFixMe[incompatible-use] found when upgrading Flow

		currentPriorityLevel = currentTask.priorityLevel; // $FlowFixMe[incompatible-use] found when upgrading Flow

		var didUserCallbackTimeout = currentTask.expirationTime <= currentTime;

		var continuationCallback = callback(didUserCallbackTimeout);
		currentTime = getCurrentTime();

		if (typeof continuationCallback === 'function') {
		// If a continuation is returned, immediately yield to the main thread
		// regardless of how much time is left in the current time slice.
		// $FlowFixMe[incompatible-use] found when upgrading Flow
		currentTask.callback = continuationCallback;

		advanceTimers(currentTime);

		if (shouldYieldForPaint) {
		needsPaint = true;
		return true;
		) {
		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;
		}
		}
		} else {

		if (currentTask === peek(taskQueue)) {
		pop(taskQueue);
		}

		advanceTimers(currentTime);
		return JSCompiler_inline_result;
		} finally {
		(currentTask = null),
		(currentPriorityLevel = previousPriorityLevel),
		(isPerformingWork = !1);
		}
		} 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);
		function shouldYieldToHost() {
		return (0 === expectedNumberOfYields && null === yieldedValues) \|\|
		(-1 !== expectedNumberOfYields &&
		null !== yieldedValues &&
		yieldedValues.length >= expectedNumberOfYields) \|\|
		(shouldYieldForPaint && needsPaint)
		? (didStop = !0)
		: !1;
		}

		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; // $FlowFixMe[incompatible-return]

		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_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 unstable_scheduleCallback(priorityLevel, callback, options) {
		var currentTime = getCurrentTime();
		var startTime;

		if (typeof options === 'object' && options !== null) {
		var delay = options.delay;

		if (typeof delay === 'number' && delay > 0) {
		startTime = currentTime + delay;
		} else {
		startTime = currentTime;
		}
		} else {
		startTime = currentTime;
		}

		var timeout;

		switch (priorityLevel) {
		case ImmediatePriority:
		timeout = IMMEDIATE_PRIORITY_TIMEOUT;
		break;

		case UserBlockingPriority:
		timeout = USER_BLOCKING_PRIORITY_TIMEOUT;
		break;

		case IdlePriority:
		timeout = IDLE_PRIORITY_TIMEOUT;
		break;

		case LowPriority:
		timeout = LOW_PRIORITY_TIMEOUT;
		break;

		case NormalPriority:
		default:
		timeout = NORMAL_PRIORITY_TIMEOUT;
		break;
		}

		var expirationTime = startTime + timeout;
		var newTask = {
		id: taskIdCounter++,
		callback: callback,
		priorityLevel: priorityLevel,
		startTime: startTime,
		expirationTime: expirationTime,
		sortIndex: -1
		};

		if (startTime > currentTime) {
		// This is a delayed task.
		newTask.sortIndex = startTime;
		push(timerQueue, newTask);

		if (peek(taskQueue) === null && newTask === peek(timerQueue)) {
		// All tasks are delayed, and this is the task with the earliest delay.
		if (isHostTimeoutScheduled) {
		// Cancel an existing timeout.
		cancelHostTimeout();
		} else {
		isHostTimeoutScheduled = true;
		} // Schedule a timeout.


		requestHostTimeout(handleTimeout, startTime - currentTime);
		}
		} else {
		newTask.sortIndex = expirationTime;
		push(taskQueue, newTask);
		// wait until the next time we yield.


		if (!isHostCallbackScheduled && !isPerformingWork) {
		isHostCallbackScheduled = true;
		requestHostCallback(flushWork);
		}
		}

		return newTask;
		}

		function unstable_pauseExecution() {
		}

		function unstable_continueExecution() {

		if (!isHostCallbackScheduled && !isPerformingWork) {
		isHostCallbackScheduled = true;
		requestHostCallback(flushWork);
		}
		}

		function unstable_getFirstCallbackNode() {
		return peek(taskQueue);
		}

		function unstable_cancelCallback(task) {
		// remove from the queue because you can't remove arbitrary nodes from an
		// array based heap, only the first one.)


		task.callback = null;
		}

		function unstable_getCurrentPriorityLevel() {
		return currentPriorityLevel;
		}

		function requestHostCallback(callback) {
		scheduledCallback = callback;
		}

		function requestHostTimeout(callback, ms) {
		scheduledTimeout = callback;
		timeoutTime = currentMockTime + ms;
		}

		function cancelHostTimeout() {
		scheduledTimeout = null;
		timeoutTime = -1;
		}

		function shouldYieldToHost() {
		if (expectedNumberOfYields === 0 && yieldedValues === null \|\| expectedNumberOfYields !== -1 && yieldedValues !== null && yieldedValues.length >= expectedNumberOfYields \|\| shouldYieldForPaint && needsPaint) {
		// We yielded at least as many values as expected. Stop flushing.
		didStop = true;
		return true;
		}

		return false;
		}

		function getCurrentTime() {
		return currentMockTime;
		}

		function forceFrameRate() {// No-op
		}

		function reset() {
		if (isFlushing) {
		throw new Error('Cannot reset while already flushing work.');
		}

		currentMockTime = 0;
		scheduledCallback = null;
		scheduledTimeout = null;
		timeoutTime = -1;
		yieldedValues = null;
		expectedNumberOfYields = -1;
		didStop = false;
		isFlushing = false;
		needsPaint = false;
		} // Should only be used via an assertion helper that inspects the yielded values.


		function unstable_flushNumberOfYields(count) {
		if (isFlushing) {
		throw new Error('Already flushing work.');
		}

		if (scheduledCallback !== null) {
		var cb = scheduledCallback;
		expectedNumberOfYields = count;
		isFlushing = true;

		try {
		var hasMoreWork = true;

		do {
		hasMoreWork = cb(true, currentMockTime);
		} while (hasMoreWork && !didStop);

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

		function unstable_flushUntilNextPaint() {
		if (isFlushing) {
		throw new Error('Already flushing work.');
		}

		if (scheduledCallback !== null) {
		var cb = scheduledCallback;
		shouldYieldForPaint = true;
		needsPaint = false;
		isFlushing = true;

		try {
		var hasMoreWork = true;

		do {
		hasMoreWork = cb(true, currentMockTime);
		} while (hasMoreWork && !didStop);

		if (!hasMoreWork) {
		scheduledCallback = null;
		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;
		}
		}
		} finally {
		shouldYieldForPaint = false;
		didStop = false;
		isFlushing = false;
		}
		}

		return false;
		}

		function unstable_hasPendingWork() {
		return scheduledCallback !== null;
		}

		function unstable_flushExpired() {
		if (isFlushing) {
		throw new Error('Already flushing work.');
		}

		if (scheduledCallback !== null) {
		isFlushing = true;

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

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

		function unstable_flushAllWithoutAsserting() {
		// Returns false if no work was flushed.
		if (isFlushing) {
		throw new Error('Already flushing work.');
		}

		if (scheduledCallback !== null) {
		var cb = scheduledCallback;
		isFlushing = true;

		try {
		var hasMoreWork = true;

		do {
		hasMoreWork = cb(true, currentMockTime);
		} while (hasMoreWork);

		if (!hasMoreWork) {
		scheduledCallback = null;
		};
		exports.unstable_flushUntilNextPaint = function () {
		if (isFlushing) throw Error("Already flushing work.");
		if (null !== scheduledCallback) {
		var cb = scheduledCallback;
		shouldYieldForPaint = !0;
		needsPaint = !1;
		isFlushing = !0;
		try {
		var hasMoreWork = !0;
		do hasMoreWork = cb(!0, currentMockTime);
		while (hasMoreWork && !didStop);
		hasMoreWork \|\| (scheduledCallback = null);
		} finally {
		isFlushing = didStop = shouldYieldForPaint = !1;
		}
		}

		return true;
		} finally {
		isFlushing = false;
		}
		} else {
		return false;
		}
		}

		function unstable_clearYields() {
		if (yieldedValues === null) {
		return [];
		}

		var values = yieldedValues;
		yieldedValues = null;
		return values;
		}

		function unstable_flushAll() {
		if (yieldedValues !== null) {
		throw new Error('Log is not empty. Assert on the log of yielded values before ' + 'flushing additional work.');
		}

		unstable_flushAllWithoutAsserting();

		if (yieldedValues !== null) {
		throw new Error('While flushing work, something yielded a value. Use an ' + 'assertion helper to assert on the log of yielded values, e.g. ' + 'expect(Scheduler).toFlushAndYield([...])');
		}
		}

		function unstable_yieldValue(value) {
		// eslint-disable-next-line react-internal/no-production-logging
		if (console.log.name === 'disabledLog' \|\| disableYieldValue) {
		// If console.log has been patched, we assume we're in render
		// replaying and we ignore any values yielding in the second pass.
		return;
		}

		if (yieldedValues === null) {
		yieldedValues = [value];
		} else {
		yieldedValues.push(value);
		}
		}

		function unstable_advanceTime(ms) {
		// eslint-disable-next-line react-internal/no-production-logging
		if (console.log.name === 'disabledLog' \|\| disableYieldValue) {
		// If console.log has been patched, we assume we're in render
		// replaying and we ignore any time advancing in the second pass.
		return;
		}

		currentMockTime += ms;

		if (scheduledTimeout !== null && timeoutTime <= currentMockTime) {
		scheduledTimeout(currentMockTime);
		timeoutTime = -1;
		scheduledTimeout = null;
		}
		}

		function requestPaint() {
		needsPaint = true;
		}
		var unstable_Profiling = null;

		exports.reset = reset;
		exports.unstable_IdlePriority = IdlePriority;
		exports.unstable_ImmediatePriority = ImmediatePriority;
		exports.unstable_LowPriority = LowPriority;
		exports.unstable_NormalPriority = NormalPriority;
		exports.unstable_Profiling = unstable_Profiling;
		exports.unstable_UserBlockingPriority = UserBlockingPriority;
		exports.unstable_advanceTime = unstable_advanceTime;
		exports.unstable_cancelCallback = unstable_cancelCallback;
		exports.unstable_clearYields = unstable_clearYields;
		exports.unstable_continueExecution = unstable_continueExecution;
		exports.unstable_flushAll = unstable_flushAll;
		exports.unstable_flushAllWithoutAsserting = unstable_flushAllWithoutAsserting;
		exports.unstable_flushExpired = unstable_flushExpired;
		exports.unstable_flushNumberOfYields = unstable_flushNumberOfYields;
		exports.unstable_flushUntilNextPaint = unstable_flushUntilNextPaint;
		exports.unstable_forceFrameRate = forceFrameRate;
		exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
		exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode;
		exports.unstable_hasPendingWork = unstable_hasPendingWork;
		exports.unstable_next = unstable_next;
		exports.unstable_now = getCurrentTime;
		exports.unstable_pauseExecution = unstable_pauseExecution;
		exports.unstable_requestPaint = requestPaint;
		exports.unstable_runWithPriority = unstable_runWithPriority;
		exports.unstable_scheduleCallback = unstable_scheduleCallback;
		exports.unstable_setDisableYieldValue = setDisableYieldValue;
		exports.unstable_shouldYield = shouldYieldToHost;
		exports.unstable_wrapCallback = unstable_wrapCallback;
		exports.unstable_yieldValue = unstable_yieldValue;
		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;
		}
		};
		};
		})();
		}

340

cjs/scheduler-unstable_post_task.development.js

		@@ -5,3 +5,3 @@ /**
		*
		* Copyright (c) Facebook, Inc. and its affiliates.
		* Copyright (c) Meta Platforms, Inc. and affiliates.
		*
		@@ -12,198 +12,146 @@ * This source code is licensed under the MIT license found in the

		'use strict';

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

		// TODO: Use symbols?
		var ImmediatePriority = 1;
		var UserBlockingPriority = 2;
		var NormalPriority = 3;
		var LowPriority = 4;
		var IdlePriority = 5;

		var perf = window.performance;
		var setTimeout = window.setTimeout; // Use experimental Chrome Scheduler postTask API.

		var scheduler = global.scheduler;
		var getCurrentTime = perf.now.bind(perf);
		var unstable_now = getCurrentTime; // Scheduler periodically yields in case there is other work on the main
		// thread, like user events. By default, it yields multiple times per frame.
		// It does not attempt to align with frame boundaries, since most tasks don't
		// need to be frame aligned; for those that do, use requestAnimationFrame.

		var yieldInterval = 5;
		var deadline = 0;
		var currentPriorityLevel_DEPRECATED = NormalPriority; // `isInputPending` is not available. Since we have no way of knowing if
		// there's pending input, always yield at the end of the frame.

		function unstable_shouldYield() {
		return getCurrentTime() >= deadline;
		}
		function unstable_requestPaint() {// Since we yield every frame regardless, `requestPaint` has no effect.
		}
		function unstable_scheduleCallback(priorityLevel, callback, options) {
		var postTaskPriority;

		switch (priorityLevel) {
		case ImmediatePriority:
		case UserBlockingPriority:
		postTaskPriority = 'user-blocking';
		break;

		case LowPriority:
		case NormalPriority:
		postTaskPriority = 'user-visible';
		break;

		case IdlePriority:
		postTaskPriority = 'background';
		break;

		default:
		postTaskPriority = 'user-visible';
		break;
		}

		var controller = new TaskController();
		var postTaskOptions = {
		priority: postTaskPriority,
		delay: typeof options === 'object' && options !== null ? options.delay : 0,
		signal: controller.signal
		};
		var node = {
		_controller: controller
		};
		scheduler.postTask(runTask.bind(null, priorityLevel, postTaskPriority, node, callback), postTaskOptions).catch(handleAbortError);
		return node;
		}

		function runTask(priorityLevel, postTaskPriority, node, callback) {
		deadline = getCurrentTime() + yieldInterval;

		try {
		currentPriorityLevel_DEPRECATED = priorityLevel;
		var _didTimeout_DEPRECATED = false;
		var result = callback(_didTimeout_DEPRECATED);

		if (typeof result === 'function') {
		// Assume this is a continuation
		var continuation = result;
		var continuationController = new TaskController();
		var continuationOptions = {
		priority: postTaskPriority,
		signal: continuationController.signal
		}; // Update the original callback node's controller, since even though we're
		// posting a new task, conceptually it's the same one.

		node._controller = continuationController;
		scheduler.postTask(runTask.bind(null, priorityLevel, postTaskPriority, node, continuation), continuationOptions).catch(handleAbortError);
		"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) {
		// We're inside a `postTask` promise. If we don't handle this error, then it
		// will trigger an "Unhandled promise rejection" error. We don't want that,
		// but we do want the default error reporting behavior that normal
		// (non-Promise) tasks get for unhandled errors.
		//
		// So we'll re-throw the error inside a regular browser task.
		setTimeout(function () {
		throw error;
		});
		} finally {
		currentPriorityLevel_DEPRECATED = NormalPriority;
		}
		}

		function handleAbortError(error) {// Abort errors are an implementation detail. We don't expose the
		// TaskController to the user, nor do we expose the promise that is returned
		// from `postTask`. So we should suppress them, since there's no way for the
		// user to handle them.
		}

		function unstable_cancelCallback(node) {
		var controller = node._controller;
		controller.abort();
		}
		function unstable_runWithPriority(priorityLevel, callback) {
		var previousPriorityLevel = currentPriorityLevel_DEPRECATED;
		currentPriorityLevel_DEPRECATED = priorityLevel;

		try {
		return callback();
		} finally {
		currentPriorityLevel_DEPRECATED = previousPriorityLevel;
		}
		}
		function unstable_getCurrentPriorityLevel() {
		return currentPriorityLevel_DEPRECATED;
		}
		function unstable_next(callback) {
		var priorityLevel;

		switch (currentPriorityLevel_DEPRECATED) {
		case ImmediatePriority:
		case UserBlockingPriority:
		case NormalPriority:
		// Shift down to normal priority
		priorityLevel = NormalPriority;
		break;

		default:
		// Anything lower than normal priority should remain at the current level.
		priorityLevel = currentPriorityLevel_DEPRECATED;
		break;
		}

		var previousPriorityLevel = currentPriorityLevel_DEPRECATED;
		currentPriorityLevel_DEPRECATED = priorityLevel;

		try {
		return callback();
		} finally {
		currentPriorityLevel_DEPRECATED = previousPriorityLevel;
		}
		}
		function unstable_wrapCallback(callback) {
		var parentPriorityLevel = currentPriorityLevel_DEPRECATED;
		return function () {
		var previousPriorityLevel = currentPriorityLevel_DEPRECATED;
		currentPriorityLevel_DEPRECATED = parentPriorityLevel;

		try {
		return callback();
		} finally {
		currentPriorityLevel_DEPRECATED = previousPriorityLevel;
		}
		};
		}
		function unstable_forceFrameRate() {}
		function unstable_pauseExecution() {}
		function unstable_continueExecution() {}
		function unstable_getFirstCallbackNode() {
		return null;
		} // Currently no profiling build

		var unstable_Profiling = null;

		exports.unstable_IdlePriority = IdlePriority;
		exports.unstable_ImmediatePriority = ImmediatePriority;
		exports.unstable_LowPriority = LowPriority;
		exports.unstable_NormalPriority = NormalPriority;
		exports.unstable_Profiling = unstable_Profiling;
		exports.unstable_UserBlockingPriority = UserBlockingPriority;
		exports.unstable_cancelCallback = unstable_cancelCallback;
		exports.unstable_continueExecution = unstable_continueExecution;
		exports.unstable_forceFrameRate = unstable_forceFrameRate;
		exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
		exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode;
		exports.unstable_next = unstable_next;
		exports.unstable_now = unstable_now;
		exports.unstable_pauseExecution = unstable_pauseExecution;
		exports.unstable_requestPaint = unstable_requestPaint;
		exports.unstable_runWithPriority = unstable_runWithPriority;
		exports.unstable_scheduleCallback = unstable_scheduleCallback;
		exports.unstable_shouldYield = unstable_shouldYield;
		exports.unstable_wrapCallback = unstable_wrapCallback;
		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;
		}
		var previousPriorityLevel = currentPriorityLevel_DEPRECATED;
		currentPriorityLevel_DEPRECATED = priorityLevel;
		try {
		return callback();
		} finally {
		currentPriorityLevel_DEPRECATED = previousPriorityLevel;
		}
		};
		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;
		}
		};
		exports.unstable_scheduleCallback = function (
		priorityLevel,
		callback,
		options
		) {
		switch (priorityLevel) {
		case 1:
		case 2:
		var postTaskPriority = "user-blocking";
		break;
		case 4:
		case 3:
		postTaskPriority = "user-visible";
		break;
		case 5:
		postTaskPriority = "background";
		break;
		default:
		postTaskPriority = "user-visible";
		}
		var controller = new TaskController({ priority: postTaskPriority });
		options = {
		delay:
		"object" === typeof options && null !== options ? options.delay : 0,
		signal: controller.signal
		};
		controller = { _controller: controller };
		scheduler
		.postTask(
		runTask.bind(
		null,
		priorityLevel,
		postTaskPriority,
		controller,
		callback
		),
		options
		)
		.catch(handleAbortError);
		return controller;
		};
		exports.unstable_shouldYield = function () {
		return getCurrentTime() >= deadline;
		};
		exports.unstable_wrapCallback = function (callback) {
		var parentPriorityLevel = currentPriorityLevel_DEPRECATED;
		return function () {
		var previousPriorityLevel = currentPriorityLevel_DEPRECATED;
		currentPriorityLevel_DEPRECATED = parentPriorityLevel;
		try {
		return callback();
		} finally {
		currentPriorityLevel_DEPRECATED = previousPriorityLevel;
		}
		};
		};
		})();
		}

963

cjs/scheduler.development.js

		@@ -5,3 +5,3 @@ /**
		*
		* Copyright (c) Facebook, Inc. and its affiliates.
		* Copyright (c) Meta Platforms, Inc. and affiliates.
		*
		@@ -12,644 +12,355 @@ * This source code is licensed under the MIT license found in the

		'use strict';
		"use strict";
		"production" !== process.env.NODE_ENV &&
		(function () {
		function performWorkUntilDeadline() {
		if (isMessageLoopRunning) {
		var currentTime = exports.unstable_now();
		startTime = currentTime;
		var hasMoreWork = !0;
		try {
		a: {
		isHostCallbackScheduled = !1;
		isHostTimeoutScheduled &&
		((isHostTimeoutScheduled = !1),
		localClearTimeout(taskTimeoutID),
		(taskTimeoutID = -1));
		isPerformingWork = !0;
		var previousPriorityLevel = currentPriorityLevel;
		try {
		b: {
		advanceTimers(currentTime);
		for (
		currentTask = peek(taskQueue);
		null !== currentTask &&
		!(
		currentTask.expirationTime > currentTime &&
		shouldYieldToHost()
		);

		if (process.env.NODE_ENV !== "production") {
		(function() {

		'use strict';

		/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
		if (
		typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
		typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart ===
		'function'
		) {
		__REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
		}
		var enableSchedulerDebugging = false;
		var enableProfiling = false;
		var frameYieldMs = 5;

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

		var first = heap[0];
		var last = heap.pop();

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

		return first;
		}

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

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

		if (compare(parent, node) > 0) {
		// The parent is larger. Swap positions.
		heap[parentIndex] = node;
		heap[index] = parent;
		index = parentIndex;
		} else {
		// The parent is smaller. Exit.
		return;
		) {
		var callback = currentTask.callback;
		if ("function" === typeof callback) {
		currentTask.callback = null;
		currentPriorityLevel = currentTask.priorityLevel;
		var continuationCallback = callback(
		currentTask.expirationTime <= currentTime
		);
		currentTime = exports.unstable_now();
		if ("function" === typeof continuationCallback) {
		currentTask.callback = continuationCallback;
		advanceTimers(currentTime);
		hasMoreWork = !0;
		break b;
		}
		currentTask === peek(taskQueue) && pop(taskQueue);
		advanceTimers(currentTime);
		} else pop(taskQueue);
		currentTask = peek(taskQueue);
		}
		if (null !== currentTask) hasMoreWork = !0;
		else {
		var firstTimer = peek(timerQueue);
		null !== firstTimer &&
		requestHostTimeout(
		handleTimeout,
		firstTimer.startTime - currentTime
		);
		hasMoreWork = !1;
		}
		}
		break a;
		} finally {
		(currentTask = null),
		(currentPriorityLevel = previousPriorityLevel),
		(isPerformingWork = !1);
		}
		hasMoreWork = void 0;
		}
		} finally {
		hasMoreWork
		? schedulePerformWorkUntilDeadline()
		: (isMessageLoopRunning = !1);
		}
		}
		}
		}
		}

		function siftDown(heap, node, i) {
		var index = i;
		var length = heap.length;
		var halfLength = length >>> 1;

		while (index < halfLength) {
		var leftIndex = (index + 1) * 2 - 1;
		var left = heap[leftIndex];
		var rightIndex = leftIndex + 1;
		var right = heap[rightIndex]; // If the left or right node is smaller, swap with the smaller of those.

		if (compare(left, node) < 0) {
		if (rightIndex < length && compare(right, left) < 0) {
		heap[index] = right;
		heap[rightIndex] = node;
		index = rightIndex;
		} else {
		heap[index] = left;
		heap[leftIndex] = node;
		index = leftIndex;
		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;
		}
		} else if (rightIndex < length && compare(right, node) < 0) {
		heap[index] = right;
		heap[rightIndex] = node;
		index = rightIndex;
		} else {
		// Neither child is smaller. Exit.
		return;
		}
		}
		}

		function compare(a, b) {
		// Compare sort index first, then task id.
		var diff = a.sortIndex - b.sortIndex;
		return diff !== 0 ? diff : a.id - b.id;
		}

		// TODO: Use symbols?
		var ImmediatePriority = 1;
		var UserBlockingPriority = 2;
		var NormalPriority = 3;
		var LowPriority = 4;
		var IdlePriority = 5;

		function markTaskErrored(task, ms) {
		}

		/* eslint-disable no-var */

		var hasPerformanceNow = // $FlowFixMe[method-unbinding]
		typeof performance === 'object' && typeof performance.now === 'function';

		if (hasPerformanceNow) {
		var localPerformance = performance;

		exports.unstable_now = function () {
		return localPerformance.now();
		};
		} else {
		var localDate = Date;

		var _initialTime = localDate.now();

		exports.unstable_now = function () {
		return localDate.now() - _initialTime;
		};
		} // Max 31 bit integer. The max integer size in V8 for 32-bit systems.
		// Math.pow(2, 30) - 1
		// 0b111111111111111111111111111111


		var maxSigned31BitInt = 1073741823; // Times out immediately

		var IMMEDIATE_PRIORITY_TIMEOUT = -1; // Eventually times out

		var USER_BLOCKING_PRIORITY_TIMEOUT = 250;
		var NORMAL_PRIORITY_TIMEOUT = 5000;
		var LOW_PRIORITY_TIMEOUT = 10000; // Never times out

		var IDLE_PRIORITY_TIMEOUT = maxSigned31BitInt; // Tasks are stored on a min heap

		var taskQueue = [];
		var timerQueue = []; // Incrementing id counter. Used to maintain insertion order.

		var taskIdCounter = 1; // Pausing the scheduler is useful for debugging.
		var currentTask = null;
		var currentPriorityLevel = NormalPriority; // This is set while performing work, to prevent re-entrance.

		var isPerformingWork = false;
		var isHostCallbackScheduled = false;
		var isHostTimeoutScheduled = false; // Capture local references to native APIs, in case a polyfill overrides them.

		var localSetTimeout = typeof setTimeout === 'function' ? setTimeout : null;
		var localClearTimeout = typeof clearTimeout === 'function' ? clearTimeout : null;
		var localSetImmediate = typeof setImmediate !== 'undefined' ? setImmediate : null; // IE and Node.js + jsdom

		var isInputPending = typeof navigator !== 'undefined' && // $FlowFixMe[prop-missing]
		navigator.scheduling !== undefined && // $FlowFixMe[incompatible-type]
		navigator.scheduling.isInputPending !== undefined ? navigator.scheduling.isInputPending.bind(navigator.scheduling) : null;

		function advanceTimers(currentTime) {
		// Check for tasks that are no longer delayed and add them to the queue.
		var timer = peek(timerQueue);

		while (timer !== null) {
		if (timer.callback === null) {
		// Timer was cancelled.
		pop(timerQueue);
		} else if (timer.startTime <= currentTime) {
		// Timer fired. Transfer to the task queue.
		pop(timerQueue);
		timer.sortIndex = timer.expirationTime;
		push(taskQueue, timer);
		} else {
		// Remaining timers are pending.
		return;
		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;

		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 leftIndex = 2 * (index + 1) - 1,
		left = heap[leftIndex],
		rightIndex = leftIndex + 1,
		right = heap[rightIndex];
		if (0 > compare(left, last))
		rightIndex < length && 0 > compare(right, left)
		? ((heap[index] = right),
		(heap[rightIndex] = last),
		(index = rightIndex))
		: ((heap[index] = left),
		(heap[leftIndex] = last),
		(index = leftIndex));
		else if (rightIndex < length && 0 > compare(right, last))
		(heap[index] = right),
		(heap[rightIndex] = last),
		(index = rightIndex);
		else break a;
		}
		}
		return first;
		}
		}
		}

		function flushWork(hasTimeRemaining, initialTime) {


		isHostCallbackScheduled = false;

		if (isHostTimeoutScheduled) {
		// We scheduled a timeout but it's no longer needed. Cancel it.
		isHostTimeoutScheduled = false;
		cancelHostTimeout();
		}

		isPerformingWork = true;
		var previousPriorityLevel = currentPriorityLevel;

		try {
		if (enableProfiling) {
		try {
		return workLoop(hasTimeRemaining, initialTime);
		} catch (error) {
		if (currentTask !== null) {
		var currentTime = exports.unstable_now(); // $FlowFixMe[incompatible-call] found when upgrading Flow

		markTaskErrored(currentTask, currentTime); // $FlowFixMe[incompatible-use] found when upgrading Flow

		currentTask.isQueued = false;
		}

		throw error;
		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);
		}
		} else {
		// No catch in prod code path.
		return workLoop(hasTimeRemaining, initialTime);
		}
		} finally {
		currentTask = null;
		currentPriorityLevel = previousPriorityLevel;
		isPerformingWork = false;
		}
		}

		function workLoop(hasTimeRemaining, initialTime) {
		var currentTime = initialTime;
		advanceTimers(currentTime);
		currentTask = peek(taskQueue);

		while (currentTask !== null && !(enableSchedulerDebugging )) {
		if (currentTask.expirationTime > currentTime && (!hasTimeRemaining \|\| shouldYieldToHost())) {
		// This currentTask hasn't expired, and we've reached the deadline.
		break;
		} // $FlowFixMe[incompatible-use] found when upgrading Flow


		var callback = currentTask.callback;

		if (typeof callback === 'function') {
		// $FlowFixMe[incompatible-use] found when upgrading Flow
		currentTask.callback = null; // $FlowFixMe[incompatible-use] found when upgrading Flow

		currentPriorityLevel = currentTask.priorityLevel; // $FlowFixMe[incompatible-use] found when upgrading Flow

		var didUserCallbackTimeout = currentTask.expirationTime <= currentTime;

		var continuationCallback = callback(didUserCallbackTimeout);
		currentTime = exports.unstable_now();

		if (typeof continuationCallback === 'function') {
		// If a continuation is returned, immediately yield to the main thread
		// regardless of how much time is left in the current time slice.
		// $FlowFixMe[incompatible-use] found when upgrading Flow
		currentTask.callback = continuationCallback;

		advanceTimers(currentTime);
		return true;
		} else {

		if (currentTask === peek(taskQueue)) {
		pop(taskQueue);
		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
		);
		}

		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);
		function shouldYieldToHost() {
		return exports.unstable_now() - startTime < frameInterval ? !1 : !0;
		}

		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; // $FlowFixMe[incompatible-return]

		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 requestHostCallback() {
		isMessageLoopRunning \|\|
		((isMessageLoopRunning = !0), schedulePerformWorkUntilDeadline());
		}
		};
		}

		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;
		function requestHostTimeout(callback, ms) {
		taskTimeoutID = localSetTimeout(function () {
		callback(exports.unstable_now());
		}, ms);
		}
		"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
		"function" ===
		typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart &&
		__REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
		exports.unstable_now = void 0;
		if (
		"object" === typeof performance &&
		"function" === typeof performance.now
		) {
		var localPerformance = performance;
		exports.unstable_now = function () {
		return localPerformance.now();
		};
		} else {
		startTime = currentTime;
		var localDate = Date,
		initialTime = localDate.now();
		exports.unstable_now = function () {
		return localDate.now() - initialTime;
		};
		}
		} else {
		startTime = currentTime;
		}

		var timeout;

		switch (priorityLevel) {
		case ImmediatePriority:
		timeout = IMMEDIATE_PRIORITY_TIMEOUT;
		break;

		case UserBlockingPriority:
		timeout = USER_BLOCKING_PRIORITY_TIMEOUT;
		break;

		case IdlePriority:
		timeout = IDLE_PRIORITY_TIMEOUT;
		break;

		case LowPriority:
		timeout = LOW_PRIORITY_TIMEOUT;
		break;

		case NormalPriority:
		default:
		timeout = NORMAL_PRIORITY_TIMEOUT;
		break;
		}

		var expirationTime = startTime + timeout;
		var newTask = {
		id: taskIdCounter++,
		callback: callback,
		priorityLevel: priorityLevel,
		startTime: startTime,
		expirationTime: expirationTime,
		sortIndex: -1
		};

		if (startTime > currentTime) {
		// This is a delayed task.
		newTask.sortIndex = startTime;
		push(timerQueue, newTask);

		if (peek(taskQueue) === null && newTask === peek(timerQueue)) {
		// All tasks are delayed, and this is the task with the earliest delay.
		if (isHostTimeoutScheduled) {
		// Cancel an existing timeout.
		cancelHostTimeout();
		} else {
		isHostTimeoutScheduled = true;
		} // Schedule a timeout.


		requestHostTimeout(handleTimeout, startTime - currentTime);
		}
		} else {
		newTask.sortIndex = expirationTime;
		push(taskQueue, newTask);
		// wait until the next time we yield.


		if (!isHostCallbackScheduled && !isPerformingWork) {
		isHostCallbackScheduled = true;
		requestHostCallback(flushWork);
		}
		}

		return newTask;
		}

		function unstable_pauseExecution() {
		}

		function unstable_continueExecution() {

		if (!isHostCallbackScheduled && !isPerformingWork) {
		isHostCallbackScheduled = true;
		requestHostCallback(flushWork);
		}
		}

		function unstable_getFirstCallbackNode() {
		return peek(taskQueue);
		}

		function unstable_cancelCallback(task) {
		// remove from the queue because you can't remove arbitrary nodes from an
		// array based heap, only the first one.)


		task.callback = null;
		}

		function unstable_getCurrentPriorityLevel() {
		return currentPriorityLevel;
		}

		var isMessageLoopRunning = false;
		var scheduledHostCallback = null;
		var taskTimeoutID = -1; // Scheduler periodically yields in case there is other work on the main
		// thread, like user events. By default, it yields multiple times per frame.
		// It does not attempt to align with frame boundaries, since most tasks don't
		// need to be frame aligned; for those that do, use requestAnimationFrame.

		var frameInterval = frameYieldMs;
		var startTime = -1;

		function shouldYieldToHost() {
		var timeElapsed = exports.unstable_now() - startTime;

		if (timeElapsed < frameInterval) {
		// The main thread has only been blocked for a really short amount of time;
		// smaller than a single frame. Don't yield yet.
		return false;
		} // The main thread has been blocked for a non-negligible amount of time. We


		return true;
		}

		function requestPaint() {

		}

		function forceFrameRate(fps) {
		if (fps < 0 \|\| fps > 125) {
		// Using console['error'] to evade Babel and ESLint
		console['error']('forceFrameRate takes a positive int between 0 and 125, ' + 'forcing frame rates higher than 125 fps is not supported');
		return;
		}

		if (fps > 0) {
		frameInterval = Math.floor(1000 / fps);
		} else {
		// reset the framerate
		frameInterval = frameYieldMs;
		}
		}

		var performWorkUntilDeadline = function () {
		if (scheduledHostCallback !== null) {
		var currentTime = exports.unstable_now(); // Keep track of the start time so we can measure how long the main thread
		// has been blocked.

		startTime = currentTime;
		var _hasTimeRemaining = true; // If a scheduler task throws, exit the current browser task so the
		// error can be observed.
		//
		// Intentionally not using a try-catch, since that makes some debugging
		// techniques harder. Instead, if `scheduledHostCallback` errors, then
		// `hasMoreWork` will remain true, and we'll continue the work loop.

		var hasMoreWork = true;

		try {
		// $FlowFixMe[not-a-function] found when upgrading Flow
		hasMoreWork = scheduledHostCallback(_hasTimeRemaining, currentTime);
		} finally {
		if (hasMoreWork) {
		// If there's more work, schedule the next message event at the end
		// of the preceding one.
		schedulePerformWorkUntilDeadline();
		} else {
		isMessageLoopRunning = false;
		scheduledHostCallback = null;
		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;
		}
		}
		} else {
		isMessageLoopRunning = false;
		} // Yielding to the browser will give it a chance to paint, so we can
		};

		var schedulePerformWorkUntilDeadline;

		if (typeof localSetImmediate === 'function') {
		// Node.js and old IE.
		// There's a few reasons for why we prefer setImmediate.
		//
		// Unlike MessageChannel, it doesn't prevent a Node.js process from exiting.
		// (Even though this is a DOM fork of the Scheduler, you could get here
		// with a mix of Node.js 15+, which has a MessageChannel, and jsdom.)
		// https://github.com/facebook/react/issues/20756
		//
		// But also, it runs earlier which is the semantic we want.
		// If other browsers ever implement it, it's better to use it.
		// Although both of these would be inferior to native scheduling.
		schedulePerformWorkUntilDeadline = function () {
		localSetImmediate(performWorkUntilDeadline);
		};
		} else if (typeof MessageChannel !== 'undefined') {
		// DOM and Worker environments.
		// We prefer MessageChannel because of the 4ms setTimeout clamping.
		var channel = new MessageChannel();
		var port = channel.port2;
		channel.port1.onmessage = performWorkUntilDeadline;

		schedulePerformWorkUntilDeadline = function () {
		port.postMessage(null);
		};
		} else {
		// We should only fallback here in non-browser environments.
		schedulePerformWorkUntilDeadline = function () {
		// $FlowFixMe[not-a-function] nullable value
		localSetTimeout(performWorkUntilDeadline, 0);
		};
		}

		function requestHostCallback(callback) {
		scheduledHostCallback = callback;

		if (!isMessageLoopRunning) {
		isMessageLoopRunning = true;
		schedulePerformWorkUntilDeadline();
		}
		}

		function requestHostTimeout(callback, ms) {
		// $FlowFixMe[not-a-function] nullable value
		taskTimeoutID = localSetTimeout(function () {
		callback(exports.unstable_now());
		}, ms);
		}

		function cancelHostTimeout() {
		// $FlowFixMe[not-a-function] nullable value
		localClearTimeout(taskTimeoutID);
		taskTimeoutID = -1;
		}
		var unstable_Profiling = null;

		exports.unstable_IdlePriority = IdlePriority;
		exports.unstable_ImmediatePriority = ImmediatePriority;
		exports.unstable_LowPriority = LowPriority;
		exports.unstable_NormalPriority = NormalPriority;
		exports.unstable_Profiling = unstable_Profiling;
		exports.unstable_UserBlockingPriority = UserBlockingPriority;
		exports.unstable_cancelCallback = unstable_cancelCallback;
		exports.unstable_continueExecution = unstable_continueExecution;
		exports.unstable_forceFrameRate = forceFrameRate;
		exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
		exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode;
		exports.unstable_next = unstable_next;
		exports.unstable_pauseExecution = unstable_pauseExecution;
		exports.unstable_requestPaint = requestPaint;
		exports.unstable_runWithPriority = unstable_runWithPriority;
		exports.unstable_scheduleCallback = unstable_scheduleCallback;
		exports.unstable_shouldYield = shouldYieldToHost;
		exports.unstable_wrapCallback = unstable_wrapCallback;
		/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
		if (
		typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
		typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop ===
		'function'
		) {
		__REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
		}

		var previousPriorityLevel = currentPriorityLevel;
		currentPriorityLevel = priorityLevel;
		try {
		return eventHandler();
		} finally {
		currentPriorityLevel = previousPriorityLevel;
		}
		};
		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;
		}
		var previousPriorityLevel = currentPriorityLevel;
		currentPriorityLevel = priorityLevel;
		try {
		return eventHandler();
		} finally {
		currentPriorityLevel = previousPriorityLevel;
		}
		};
		exports.unstable_scheduleCallback = function (
		priorityLevel,
		callback,
		options
		) {
		var currentTime = exports.unstable_now();
		"object" === typeof options && null !== options
		? ((options = options.delay),
		(options =
		"number" === typeof options && 0 < options
		? currentTime + options
		: currentTime))
		: (options = currentTime);
		switch (priorityLevel) {
		case 1:
		var timeout = -1;
		break;
		case 2:
		timeout = 250;
		break;
		case 5:
		timeout = 1073741823;
		break;
		case 4:
		timeout = 1e4;
		break;
		default:
		timeout = 5e3;
		}
		timeout = options + timeout;
		priorityLevel = {
		id: taskIdCounter++,
		callback: callback,
		priorityLevel: priorityLevel,
		startTime: options,
		expirationTime: timeout,
		sortIndex: -1
		};
		options > currentTime
		? ((priorityLevel.sortIndex = options),
		push(timerQueue, priorityLevel),
		null === peek(taskQueue) &&
		priorityLevel === peek(timerQueue) &&
		(isHostTimeoutScheduled
		? (localClearTimeout(taskTimeoutID), (taskTimeoutID = -1))
		: (isHostTimeoutScheduled = !0),
		requestHostTimeout(handleTimeout, options - currentTime)))
		: ((priorityLevel.sortIndex = timeout),
		push(taskQueue, priorityLevel),
		isHostCallbackScheduled \|\|
		isPerformingWork \|\|
		((isHostCallbackScheduled = !0), 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-65b3449c8-20221005",
		"version": "0.0.0-experimental-65e06cb7-20241218",
		"description": "Cooperative scheduler for the browser environment.",
		"main": "index.js",
		"repository": {
		@@ -18,6 +17,3 @@ "type": "git",
		},
		"homepage": "https://reactjs.org/",
		"dependencies": {
		"loose-envify": "^1.1.0"
		},
		"homepage": "https://react.dev/",
		"files": [
		@@ -27,12 +23,7 @@ "LICENSE",
		"index.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');
		}

cjs/scheduler-unstable_mock.production.min.js

cjs/scheduler-unstable_post_task.production.min.js

cjs/scheduler.production.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