scheduler - npm Package Compare versions

Comparing version 0.0.0-11565a207 to 0.0.0-235a6c4af

cjs/scheduler-unstable_mock.development.js

cjs/scheduler-unstable_mock.production.min.js

umd/scheduler-unstable_mock.development.js

umd/scheduler-unstable_mock.production.min.js

unstable_mock.js

build-info.json

		{
		"branch": "pull/14773",
		"buildNumber": "13390",
		"checksum": "0a9ba5d",
		"commit": "11565a207",
		"branch": "master",
		"buildNumber": "97459",
		"checksum": "57a4b58",
		"commit": "235a6c4af",
		"environment": "ci",
		"reactVersion": "16.8.0-canary-11565a207"
		"reactVersion": "16.13.0-235a6c4af"
		}

124

cjs/scheduler-tracing.development.js

		@@ -1,2 +0,2 @@
		/** @license React v0.0.0-11565a207
		/** @license React v0.0.0-235a6c4af
		* scheduler-tracing.development.js
		@@ -18,58 +18,15 @@ *

		Object.defineProperty(exports, '__esModule', { value: true });
		var DEFAULT_THREAD_ID = 0; // Counters used to generate unique IDs.

		// Helps identify side effects in begin-phase lifecycle hooks and setState reducers:


		// In some cases, StrictMode should also double-render lifecycles.
		// This can be confusing for tests though,
		// And it can be bad for performance in production.
		// This feature flag can be used to control the behavior:


		// To preserve the "Pause on caught exceptions" behavior of the debugger, we
		// replay the begin phase of a failed component inside invokeGuardedCallback.


		// Warn about deprecated, async-unsafe lifecycles; relates to RFC #6:


		// Gather advanced timing metrics for Profiler subtrees.


		// Trace which interactions trigger each commit.
		var enableSchedulerTracing = true;

		// Only used in www builds.
		// TODO: true? Here it might just be false.

		// Only used in www builds.


		// Only used in www builds.


		// React Fire: prevent the value and checked attributes from syncing
		// with their related DOM properties


		// These APIs will no longer be "unstable" in the upcoming 16.7 release,
		// Control this behavior with a flag to support 16.6 minor releases in the meanwhile.

		var DEFAULT_THREAD_ID = 0;

		// Counters used to generate unique IDs.
		var interactionIDCounter = 0;
		var threadIDCounter = 0;

		// Set of currently traced interactions.
		var threadIDCounter = 0; // Set of currently traced interactions.
		// Interactions "stack"–
		// Meaning that newly traced interactions are appended to the previously active set.
		// When an interaction goes out of scope, the previous set (if any) is restored.
		exports.__interactionsRef = null;

		// Listener(s) to notify when interactions begin and end.
		exports.__interactionsRef = null; // Listener(s) to notify when interactions begin and end.

		exports.__subscriberRef = null;

		if (enableSchedulerTracing) {
		{
		exports.__interactionsRef = {
		@@ -82,7 +39,3 @@ current: new Set()
		}

		function unstable_clear(callback) {
		if (!enableSchedulerTracing) {
		return callback();
		}

		@@ -98,22 +51,13 @@ var prevInteractions = exports.__interactionsRef.current;
		}

		function unstable_getCurrent() {
		if (!enableSchedulerTracing) {
		return null;
		} else {
		{
		return exports.__interactionsRef.current;
		}
		}

		function unstable_getThreadID() {
		return ++threadIDCounter;
		}

		function unstable_trace(name, timestamp, callback) {
		var threadID = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : DEFAULT_THREAD_ID;

		if (!enableSchedulerTracing) {
		return callback();
		}

		var interaction = {
		@@ -125,14 +69,11 @@ __count: 1,
		};

		var prevInteractions = exports.__interactionsRef.current;

		// Traced interactions should stack/accumulate.
		var prevInteractions = exports.__interactionsRef.current; // Traced interactions should stack/accumulate.
		// To do that, clone the current interactions.
		// The previous set will be restored upon completion.

		var interactions = new Set(prevInteractions);
		interactions.add(interaction);
		exports.__interactionsRef.current = interactions;

		var subscriber = exports.__subscriberRef.current;
		var returnValue = void 0;
		var returnValue;

		@@ -159,6 +100,5 @@ try {
		} finally {
		interaction.__count--;
		interaction.__count--; // If no async work was scheduled for this interaction,
		// Notify subscribers that it's completed.

		// If no async work was scheduled for this interaction,
		// Notify subscribers that it's completed.
		if (subscriber !== null && interaction.__count === 0) {
		@@ -174,23 +114,17 @@ subscriber.onInteractionScheduledWorkCompleted(interaction);
		}

		function unstable_wrap(callback) {
		var threadID = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DEFAULT_THREAD_ID;

		if (!enableSchedulerTracing) {
		return callback;
		}

		var wrappedInteractions = exports.__interactionsRef.current;
		var subscriber = exports.__subscriberRef.current;

		var subscriber = exports.__subscriberRef.current;
		if (subscriber !== null) {
		subscriber.onWorkScheduled(wrappedInteractions, threadID);
		}
		} // Update the pending async work count for the current interactions.
		// Update after calling subscribers in case of error.

		// Update the pending async work count for the current interactions.
		// Update after calling subscribers in case of error.

		wrappedInteractions.forEach(function (interaction) {
		interaction.__count++;
		});

		var hasRun = false;
		@@ -201,7 +135,6 @@
		exports.__interactionsRef.current = wrappedInteractions;

		subscriber = exports.__subscriberRef.current;

		try {
		var returnValue = void 0;
		var returnValue;

		@@ -230,7 +163,6 @@ try {
		// Only decrement the outstanding interaction counts once.
		hasRun = true;

		// Update pending async counts for all wrapped interactions.
		hasRun = true; // Update pending async counts for all wrapped interactions.
		// If this was the last scheduled async work for any of them,
		// Mark them as completed.

		wrappedInteractions.forEach(function (interaction) {
		@@ -272,3 +204,4 @@ interaction.__count--;
		var subscribers = null;
		if (enableSchedulerTracing) {

		{
		subscribers = new Set();
		@@ -278,3 +211,3 @@ }
		function unstable_subscribe(subscriber) {
		if (enableSchedulerTracing) {
		{
		subscribers.add(subscriber);
		@@ -294,5 +227,4 @@
		}

		function unstable_unsubscribe(subscriber) {
		if (enableSchedulerTracing) {
		{
		subscribers.delete(subscriber);
		@@ -309,3 +241,2 @@
		var caughtError = null;

		subscribers.forEach(function (subscriber) {
		@@ -330,3 +261,2 @@ try {
		var caughtError = null;

		subscribers.forEach(function (subscriber) {
		@@ -351,3 +281,2 @@ try {
		var caughtError = null;

		subscribers.forEach(function (subscriber) {
		@@ -372,3 +301,2 @@ try {
		var caughtError = null;

		subscribers.forEach(function (subscriber) {
		@@ -393,3 +321,2 @@ try {
		var caughtError = null;

		subscribers.forEach(function (subscriber) {
		@@ -414,3 +341,2 @@ try {
		var caughtError = null;

		subscribers.forEach(function (subscriber) {
		@@ -435,7 +361,7 @@ try {
		exports.unstable_getThreadID = unstable_getThreadID;
		exports.unstable_subscribe = unstable_subscribe;
		exports.unstable_trace = unstable_trace;
		exports.unstable_unsubscribe = unstable_unsubscribe;
		exports.unstable_wrap = unstable_wrap;
		exports.unstable_subscribe = unstable_subscribe;
		exports.unstable_unsubscribe = unstable_unsubscribe;
		})();
		}

cjs/scheduler-tracing.production.min.js

		@@ -1,2 +0,2 @@
		/** @license React v0.0.0-11565a207
		/** @license React v0.0.0-235a6c4af
		* scheduler-tracing.production.min.js
		@@ -10,2 +10,2 @@ *

		'use strict';Object.defineProperty(exports,"__esModule",{value:!0});var b=0;exports.__interactionsRef=null;exports.__subscriberRef=null;exports.unstable_clear=function(a){return a()};exports.unstable_getCurrent=function(){return null};exports.unstable_getThreadID=function(){return++b};exports.unstable_trace=function(a,d,c){return c()};exports.unstable_wrap=function(a){return a};exports.unstable_subscribe=function(){};exports.unstable_unsubscribe=function(){};
		'use strict';var b=0;exports.__interactionsRef=null;exports.__subscriberRef=null;exports.unstable_clear=function(a){return a()};exports.unstable_getCurrent=function(){return null};exports.unstable_getThreadID=function(){return++b};exports.unstable_subscribe=function(){};exports.unstable_trace=function(a,d,c){return c()};exports.unstable_unsubscribe=function(){};exports.unstable_wrap=function(a){return a};

cjs/scheduler-tracing.profiling.min.js

		@@ -1,2 +0,2 @@
		/** @license React v0.0.0-11565a207
		/** @license React v0.0.0-235a6c4af
		* scheduler-tracing.profiling.min.js
		@@ -10,9 +10,9 @@ *

		'use strict';Object.defineProperty(exports,"__esModule",{value:!0});var g=0,m=0;exports.__interactionsRef=null;exports.__subscriberRef=null;exports.__interactionsRef={current:new Set};exports.__subscriberRef={current:null};var n=null;n=new Set;function p(e){var d=!1,a=null;n.forEach(function(c){try{c.onInteractionTraced(e)}catch(b){d\|\|(d=!0,a=b)}});if(d)throw a;}
		function q(e){var d=!1,a=null;n.forEach(function(c){try{c.onInteractionScheduledWorkCompleted(e)}catch(b){d\|\|(d=!0,a=b)}});if(d)throw a;}function r(e,d){var a=!1,c=null;n.forEach(function(b){try{b.onWorkScheduled(e,d)}catch(f){a\|\|(a=!0,c=f)}});if(a)throw c;}function t(e,d){var a=!1,c=null;n.forEach(function(b){try{b.onWorkStarted(e,d)}catch(f){a\|\|(a=!0,c=f)}});if(a)throw c;}function u(e,d){var a=!1,c=null;n.forEach(function(b){try{b.onWorkStopped(e,d)}catch(f){a\|\|(a=!0,c=f)}});if(a)throw c;}
		function v(e,d){var a=!1,c=null;n.forEach(function(b){try{b.onWorkCanceled(e,d)}catch(f){a\|\|(a=!0,c=f)}});if(a)throw c;}exports.unstable_clear=function(e){var d=exports.__interactionsRef.current;exports.__interactionsRef.current=new Set;try{return e()}finally{exports.__interactionsRef.current=d}};exports.unstable_getCurrent=function(){return exports.__interactionsRef.current};exports.unstable_getThreadID=function(){return++m};
		exports.unstable_trace=function(e,d,a){var c=3<arguments.length&&void 0!==arguments[3]?arguments[3]:0,b={__count:1,id:g++,name:e,timestamp:d},f=exports.__interactionsRef.current,k=new Set(f);k.add(b);exports.__interactionsRef.current=k;var h=exports.__subscriberRef.current,l=void 0;try{if(null!==h)h.onInteractionTraced(b)}finally{try{if(null!==h)h.onWorkStarted(k,c)}finally{try{l=a()}finally{exports.__interactionsRef.current=f;try{if(null!==h)h.onWorkStopped(k,c)}finally{if(b.__count--,null!==h&&
		0===b.__count)h.onInteractionScheduledWorkCompleted(b)}}}}return l};
		exports.unstable_wrap=function(e){function d(){var d=exports.__interactionsRef.current;exports.__interactionsRef.current=c;b=exports.__subscriberRef.current;try{var h=void 0;try{if(null!==b)b.onWorkStarted(c,a)}finally{try{h=e.apply(void 0,arguments)}finally{if(exports.__interactionsRef.current=d,null!==b)b.onWorkStopped(c,a)}}return h}finally{f\|\|(f=!0,c.forEach(function(a){a.__count--;if(null!==b&&0===a.__count)b.onInteractionScheduledWorkCompleted(a)}))}}var a=1<arguments.length&&void 0!==arguments[1]?
		arguments[1]:0,c=exports.__interactionsRef.current,b=exports.__subscriberRef.current;if(null!==b)b.onWorkScheduled(c,a);c.forEach(function(a){a.__count++});var f=!1;d.cancel=function(){b=exports.__subscriberRef.current;try{if(null!==b)b.onWorkCanceled(c,a)}finally{c.forEach(function(a){a.__count--;if(b&&0===a.__count)b.onInteractionScheduledWorkCompleted(a)})}};return d};
		exports.unstable_subscribe=function(e){n.add(e);1===n.size&&(exports.__subscriberRef.current={onInteractionScheduledWorkCompleted:q,onInteractionTraced:p,onWorkCanceled:v,onWorkScheduled:r,onWorkStarted:t,onWorkStopped:u})};exports.unstable_unsubscribe=function(e){n.delete(e);0===n.size&&(exports.__subscriberRef.current=null)};
		'use strict';var g=0,l=0;exports.__interactionsRef=null;exports.__subscriberRef=null;exports.__interactionsRef={current:new Set};exports.__subscriberRef={current:null};var m=null;m=new Set;function n(e){var d=!1,a=null;m.forEach(function(c){try{c.onInteractionTraced(e)}catch(b){d\|\|(d=!0,a=b)}});if(d)throw a;}function p(e){var d=!1,a=null;m.forEach(function(c){try{c.onInteractionScheduledWorkCompleted(e)}catch(b){d\|\|(d=!0,a=b)}});if(d)throw a;}
		function q(e,d){var a=!1,c=null;m.forEach(function(b){try{b.onWorkScheduled(e,d)}catch(f){a\|\|(a=!0,c=f)}});if(a)throw c;}function r(e,d){var a=!1,c=null;m.forEach(function(b){try{b.onWorkStarted(e,d)}catch(f){a\|\|(a=!0,c=f)}});if(a)throw c;}function t(e,d){var a=!1,c=null;m.forEach(function(b){try{b.onWorkStopped(e,d)}catch(f){a\|\|(a=!0,c=f)}});if(a)throw c;}function u(e,d){var a=!1,c=null;m.forEach(function(b){try{b.onWorkCanceled(e,d)}catch(f){a\|\|(a=!0,c=f)}});if(a)throw c;}
		exports.unstable_clear=function(e){var d=exports.__interactionsRef.current;exports.__interactionsRef.current=new Set;try{return e()}finally{exports.__interactionsRef.current=d}};exports.unstable_getCurrent=function(){return exports.__interactionsRef.current};exports.unstable_getThreadID=function(){return++l};
		exports.unstable_subscribe=function(e){m.add(e);1===m.size&&(exports.__subscriberRef.current={onInteractionScheduledWorkCompleted:p,onInteractionTraced:n,onWorkCanceled:u,onWorkScheduled:q,onWorkStarted:r,onWorkStopped:t})};
		exports.unstable_trace=function(e,d,a){var c=3<arguments.length&&void 0!==arguments[3]?arguments[3]:0,b={__count:1,id:g++,name:e,timestamp:d},f=exports.__interactionsRef.current,k=new Set(f);k.add(b);exports.__interactionsRef.current=k;var h=exports.__subscriberRef.current;try{if(null!==h)h.onInteractionTraced(b)}finally{try{if(null!==h)h.onWorkStarted(k,c)}finally{try{var v=a()}finally{exports.__interactionsRef.current=f;try{if(null!==h)h.onWorkStopped(k,c)}finally{if(b.__count--,null!==h&&0===b.__count)h.onInteractionScheduledWorkCompleted(b)}}}}return v};
		exports.unstable_unsubscribe=function(e){m.delete(e);0===m.size&&(exports.__subscriberRef.current=null)};
		exports.unstable_wrap=function(e){function d(){var d=exports.__interactionsRef.current;exports.__interactionsRef.current=c;b=exports.__subscriberRef.current;try{try{if(null!==b)b.onWorkStarted(c,a)}finally{try{var h=e.apply(void 0,arguments)}finally{if(exports.__interactionsRef.current=d,null!==b)b.onWorkStopped(c,a)}}return h}finally{f\|\|(f=!0,c.forEach(function(a){a.__count--;if(null!==b&&0===a.__count)b.onInteractionScheduledWorkCompleted(a)}))}}var a=1<arguments.length&&void 0!==arguments[1]?arguments[1]:
		0,c=exports.__interactionsRef.current,b=exports.__subscriberRef.current;if(null!==b)b.onWorkScheduled(c,a);c.forEach(function(a){a.__count++});var f=!1;d.cancel=function(){b=exports.__subscriberRef.current;try{if(null!==b)b.onWorkCanceled(c,a)}finally{c.forEach(function(a){a.__count--;if(b&&0===a.__count)b.onInteractionScheduledWorkCompleted(a)})}};return d};

1221

cjs/scheduler.development.js

		@@ -1,2 +0,2 @@
		/** @license React v0.0.0-11565a207
		/** @license React v0.0.0-235a6c4af
		* scheduler.development.js
		@@ -18,9 +18,279 @@ *

		Object.defineProperty(exports, '__esModule', { value: true });

		var enableSchedulerDebugging = false;
		var enableProfiling = true;

		/* eslint-disable no-var */
		var requestHostCallback;
		var requestHostTimeout;
		var cancelHostTimeout;
		var shouldYieldToHost;
		var requestPaint;

		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 {
		var currentTime = exports.unstable_now();
		var hasRemainingTime = true;

		_callback(hasRemainingTime, currentTime);

		_callback = null;
		} catch (e) {
		setTimeout(_flushCallback, 0);
		throw e;
		}
		}
		};

		var initialTime = Date.now();

		exports.unstable_now = function () {
		return Date.now() - initialTime;
		};

		requestHostCallback = function (cb) {
		if (_callback !== null) {
		// Protect against re-entrancy.
		setTimeout(requestHostCallback, 0, cb);
		} else {
		_callback = cb;
		setTimeout(_flushCallback, 0);
		}
		};

		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 performance = window.performance;
		var _Date = window.Date;
		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');
		}

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

		if (typeof performance === 'object' && typeof performance.now === 'function') {
		exports.unstable_now = function () {
		return performance.now();
		};
		} else {
		var _initialTime = _Date.now();

		exports.unstable_now = function () {
		return _Date.now() - _initialTime;
		};
		}

		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 framerates higher than 125 fps is not unsupported');
		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);
		}
		} 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);
		}
		};

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

		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;
		}
		} 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;
		@@ -32,151 +302,228 @@ var UserBlockingPriority = 2;

		// Max 31 bit integer. The max integer size in V8 for 32-bit systems.
		// Math.pow(2, 30) - 1
		// 0b111111111111111111111111111111
		var maxSigned31BitInt = 1073741823;
		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

		// Times out immediately
		var IMMEDIATE_PRIORITY_TIMEOUT = -1;
		// Eventually times out
		var USER_BLOCKING_PRIORITY = 250;
		var NORMAL_PRIORITY_TIMEOUT = 5000;
		var LOW_PRIORITY_TIMEOUT = 10000;
		// Never times out
		var IDLE_PRIORITY = maxSigned31BitInt;
		var PRIORITY = 0;
		var CURRENT_TASK_ID = 1;
		var CURRENT_RUN_ID = 2;
		var QUEUE_SIZE = 3;

		// Callbacks are stored as a circular, doubly linked list.
		var firstCallbackNode = null;
		{
		profilingState[PRIORITY] = NoPriority; // This is maintained with a counter, because the size of the priority queue
		// array might include canceled tasks.

		var currentDidTimeout = false;
		// Pausing the scheduler is useful for debugging.
		var isSchedulerPaused = false;
		profilingState[QUEUE_SIZE] = 0;
		profilingState[CURRENT_TASK_ID] = 0;
		} // Bytes per element is 4

		var currentPriorityLevel = NormalPriority;
		var currentEventStartTime = -1;
		var currentExpirationTime = -1;

		// This is set when a callback is being executed, to prevent re-entrancy.
		var isExecutingCallback = false;
		var INITIAL_EVENT_LOG_SIZE = 131072;
		var MAX_EVENT_LOG_SIZE = 524288; // Equivalent to 2 megabytes

		var isHostCallbackScheduled = false;
		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;

		var hasNativePerformanceNow = typeof performance === 'object' && typeof performance.now === 'function';
		function logEvent(entries) {
		if (eventLog !== null) {
		var offset = eventLogIndex;
		eventLogIndex += entries.length;

		function ensureHostCallbackIsScheduled() {
		if (isExecutingCallback) {
		// Don't schedule work yet; wait until the next time we yield.
		return;
		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;
		}

		eventLog.set(entries, offset);
		}
		// Schedule the host callback using the earliest expiration in the list.
		var expirationTime = firstCallbackNode.expirationTime;
		if (!isHostCallbackScheduled) {
		isHostCallbackScheduled = true;
		} else {
		// Cancel the existing host callback.
		cancelHostCallback();
		}

		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]);
		}
		}
		requestHostCallback(flushWork, expirationTime);
		}
		function markTaskCompleted(task, ms) {
		{
		profilingState[PRIORITY] = NoPriority;
		profilingState[CURRENT_TASK_ID] = 0;
		profilingState[QUEUE_SIZE]--;

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

		// Remove the node from the list before calling the callback. That way the
		// list is in a consistent state even if the callback throws.
		var next = firstCallbackNode.next;
		if (firstCallbackNode === next) {
		// This is the last callback in the list.
		firstCallbackNode = null;
		next = null;
		} else {
		var lastCallbackNode = firstCallbackNode.previous;
		firstCallbackNode = lastCallbackNode.next = next;
		next.previous = lastCallbackNode;
		if (eventLog !== null) {
		logEvent([TaskCancelEvent, ms * 1000, task.id]);
		}
		}
		}
		function markTaskErrored(task, ms) {
		{
		profilingState[PRIORITY] = NoPriority;
		profilingState[CURRENT_TASK_ID] = 0;
		profilingState[QUEUE_SIZE]--;

		flushedNode.next = flushedNode.previous = null;
		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;

		// Now it's safe to call the callback.
		var callback = flushedNode.callback;
		var expirationTime = flushedNode.expirationTime;
		var priorityLevel = flushedNode.priorityLevel;
		var previousPriorityLevel = currentPriorityLevel;
		var previousExpirationTime = currentExpirationTime;
		currentPriorityLevel = priorityLevel;
		currentExpirationTime = expirationTime;
		var continuationCallback;
		try {
		continuationCallback = callback();
		} finally {
		currentPriorityLevel = previousPriorityLevel;
		currentExpirationTime = previousExpirationTime;
		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;

		// A callback may return a continuation. The continuation should be scheduled
		// with the same priority and expiration as the just-finished callback.
		if (typeof continuationCallback === 'function') {
		var continuationNode = {
		callback: continuationCallback,
		priorityLevel: priorityLevel,
		expirationTime: expirationTime,
		next: null,
		previous: null
		};
		if (eventLog !== null) {
		logEvent([TaskYieldEvent, ms * 1000, task.id, runIdCounter]);
		}
		}
		}
		function markSchedulerSuspended(ms) {
		{
		mainThreadIdCounter++;

		// Insert the new callback into the list, sorted by its expiration. This is
		// almost the same as the code in `scheduleCallback`, except the callback
		// is inserted into the list before callbacks of equal expiration instead
		// of after.
		if (firstCallbackNode === null) {
		// This is the first callback in the list.
		firstCallbackNode = continuationNode.next = continuationNode.previous = continuationNode;
		} else {
		var nextAfterContinuation = null;
		var node = firstCallbackNode;
		do {
		if (node.expirationTime >= expirationTime) {
		// This callback expires at or after the continuation. We will insert
		// the continuation before this callback.
		nextAfterContinuation = node;
		break;
		}
		node = node.next;
		} while (node !== firstCallbackNode);
		if (eventLog !== null) {
		logEvent([SchedulerSuspendEvent, ms * 1000, mainThreadIdCounter]);
		}
		}
		}
		function markSchedulerUnsuspended(ms) {
		{
		if (eventLog !== null) {
		logEvent([SchedulerResumeEvent, ms * 1000, mainThreadIdCounter]);
		}
		}
		}

		if (nextAfterContinuation === null) {
		// No equal or lower priority callback was found, which means the new
		// callback is the lowest priority callback in the list.
		nextAfterContinuation = firstCallbackNode;
		} else if (nextAfterContinuation === firstCallbackNode) {
		// The new callback is the highest priority callback in the list.
		firstCallbackNode = continuationNode;
		ensureHostCallbackIsScheduled();
		/* 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 = 250;
		var NORMAL_PRIORITY_TIMEOUT = 5000;
		var LOW_PRIORITY_TIMEOUT = 10000; // Never times out

		var IDLE_PRIORITY = 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;
		}
		} else {
		// Remaining timers are pending.
		return;
		}

		var previous = nextAfterContinuation.previous;
		previous.next = nextAfterContinuation.previous = continuationNode;
		continuationNode.next = nextAfterContinuation;
		continuationNode.previous = previous;
		}
		timer = peek(timerQueue);
		}
		}

		function flushImmediateWork() {
		if (
		// Confirm we've exited the outer most event handler
		currentEventStartTime === -1 && firstCallbackNode !== null && firstCallbackNode.priorityLevel === ImmediatePriority) {
		isExecutingCallback = true;
		try {
		do {
		flushFirstCallback();
		} while (
		// Keep flushing until there are no more immediate callbacks
		firstCallbackNode !== null && firstCallbackNode.priorityLevel === ImmediatePriority);
		} finally {
		isExecutingCallback = false;
		if (firstCallbackNode !== null) {
		// There's still work remaining. Request another callback.
		ensureHostCallbackIsScheduled();
		} else {
		isHostCallbackScheduled = false;
		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);
		}
		@@ -187,51 +534,103 @@ }

		function flushWork(didTimeout) {
		// Exit right away if we're currently paused
		function flushWork(hasTimeRemaining, initialTime) {
		{
		markSchedulerUnsuspended(initialTime);
		} // We'll need a host callback the next time work is scheduled.

		if (enableSchedulerDebugging && isSchedulerPaused) {
		return;

		isHostCallbackScheduled = false;

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

		isExecutingCallback = true;
		var previousDidTimeout = currentDidTimeout;
		currentDidTimeout = didTimeout;
		isPerformingWork = true;
		var previousPriorityLevel = currentPriorityLevel;

		try {
		if (didTimeout) {
		// Flush all the expired callbacks without yielding.
		while (firstCallbackNode !== null && !(enableSchedulerDebugging && isSchedulerPaused)) {
		// TODO Wrap in feature flag
		// Read the current time. Flush all the callbacks that expire at or
		// earlier than that time. Then read the current time again and repeat.
		// This optimizes for as few performance.now calls as possible.
		var currentTime = exports.unstable_now();
		if (firstCallbackNode.expirationTime <= currentTime) {
		do {
		flushFirstCallback();
		} while (firstCallbackNode !== null && firstCallbackNode.expirationTime <= currentTime && !(enableSchedulerDebugging && isSchedulerPaused));
		continue;
		if (enableProfiling) {
		try {
		return workLoop(hasTimeRemaining, initialTime);
		} catch (error) {
		if (currentTask !== null) {
		var currentTime = exports.unstable_now();
		markTaskErrored(currentTask, currentTime);
		currentTask.isQueued = false;
		}
		break;

		throw error;
		}
		} else {
		// Keep flushing callbacks until we run out of time in the frame.
		if (firstCallbackNode !== null) {
		do {
		if (enableSchedulerDebugging && isSchedulerPaused) {
		break;
		}
		flushFirstCallback();
		} while (firstCallbackNode !== null && !shouldYieldToHost());
		}
		// No catch in prod codepath.
		return workLoop(hasTimeRemaining, initialTime);
		}
		} finally {
		isExecutingCallback = false;
		currentDidTimeout = previousDidTimeout;
		if (firstCallbackNode !== null) {
		// There's still work remaining. Request another callback.
		ensureHostCallbackIsScheduled();
		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 (callback !== null) {
		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);
		}
		}

		advanceTimers(currentTime);
		} else {
		isHostCallbackScheduled = false;
		pop(taskQueue);
		}
		// Before exiting, flush all the immediate work that was scheduled.
		flushImmediateWork();

		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;
		}
		@@ -248,2 +647,3 @@ }
		break;

		default:
		@@ -254,5 +654,3 @@ priorityLevel = NormalPriority;
		var previousPriorityLevel = currentPriorityLevel;
		var previousEventStartTime = currentEventStartTime;
		currentPriorityLevel = priorityLevel;
		currentEventStartTime = exports.unstable_now();

		@@ -263,7 +661,30 @@ try {
		currentPriorityLevel = previousPriorityLevel;
		currentEventStartTime = previousEventStartTime;
		}
		}

		// Before exiting, flush all the immediate work that was scheduled.
		flushImmediateWork();
		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;
		}
		}
		@@ -276,5 +697,3 @@
		var previousPriorityLevel = currentPriorityLevel;
		var previousEventStartTime = currentEventStartTime;
		currentPriorityLevel = parentPriorityLevel;
		currentEventStartTime = exports.unstable_now();

		@@ -285,4 +704,2 @@ try {
		currentPriorityLevel = previousPriorityLevel;
		currentEventStartTime = previousEventStartTime;
		flushImmediateWork();
		}
		@@ -292,83 +709,101 @@ };

		function unstable_scheduleCallback(callback, deprecated_options) {
		var startTime = currentEventStartTime !== -1 ? currentEventStartTime : exports.unstable_now();
		function timeoutForPriorityLevel(priorityLevel) {
		switch (priorityLevel) {
		case ImmediatePriority:
		return IMMEDIATE_PRIORITY_TIMEOUT;

		var expirationTime;
		if (typeof deprecated_options === 'object' && deprecated_options !== null && typeof deprecated_options.timeout === 'number') {
		// FIXME: Remove this branch once we lift expiration times out of React.
		expirationTime = startTime + deprecated_options.timeout;
		case UserBlockingPriority:
		return USER_BLOCKING_PRIORITY;

		case IdlePriority:
		return IDLE_PRIORITY;

		case LowPriority:
		return LOW_PRIORITY_TIMEOUT;

		case NormalPriority:
		default:
		return NORMAL_PRIORITY_TIMEOUT;
		}
		}

		function unstable_scheduleCallback(priorityLevel, callback, options) {
		var currentTime = exports.unstable_now();
		var startTime;
		var timeout;

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

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

		timeout = typeof options.timeout === 'number' ? options.timeout : timeoutForPriorityLevel(priorityLevel);
		} else {
		switch (currentPriorityLevel) {
		case ImmediatePriority:
		expirationTime = startTime + IMMEDIATE_PRIORITY_TIMEOUT;
		break;
		case UserBlockingPriority:
		expirationTime = startTime + USER_BLOCKING_PRIORITY;
		break;
		case IdlePriority:
		expirationTime = startTime + IDLE_PRIORITY;
		break;
		case LowPriority:
		expirationTime = startTime + LOW_PRIORITY_TIMEOUT;
		break;
		case NormalPriority:
		default:
		expirationTime = startTime + NORMAL_PRIORITY_TIMEOUT;
		}
		timeout = timeoutForPriorityLevel(priorityLevel);
		startTime = currentTime;
		}

		var newNode = {
		var expirationTime = startTime + timeout;
		var newTask = {
		id: taskIdCounter++,
		callback: callback,
		priorityLevel: currentPriorityLevel,
		priorityLevel: priorityLevel,
		startTime: startTime,
		expirationTime: expirationTime,
		next: null,
		previous: null
		sortIndex: -1
		};

		// Insert the new callback into the list, ordered first by expiration, then
		// by insertion. So the new callback is inserted any other callback with
		// equal expiration.
		if (firstCallbackNode === null) {
		// This is the first callback in the list.
		firstCallbackNode = newNode.next = newNode.previous = newNode;
		ensureHostCallbackIsScheduled();
		{
		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 {
		var next = null;
		var node = firstCallbackNode;
		do {
		if (node.expirationTime > expirationTime) {
		// The new callback expires before this one.
		next = node;
		break;
		}
		node = node.next;
		} while (node !== firstCallbackNode);
		newTask.sortIndex = expirationTime;
		push(taskQueue, newTask);

		if (next === null) {
		// No callback with a later expiration was found, which means the new
		// callback has the latest expiration in the list.
		next = firstCallbackNode;
		} else if (next === firstCallbackNode) {
		// The new callback has the earliest expiration in the entire list.
		firstCallbackNode = newNode;
		ensureHostCallbackIsScheduled();
		{
		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);
		}

		var previous = next.previous;
		previous.next = next.previous = newNode;
		newNode.next = next;
		newNode.previous = previous;
		}

		return newNode;
		return newTask;
		}

		function unstable_pauseExecution() {
		isSchedulerPaused = true;
		}

		function unstable_continueExecution() {
		isSchedulerPaused = false;
		if (firstCallbackNode !== null) {
		ensureHostCallbackIsScheduled();

		if (!isHostCallbackScheduled && !isPerformingWork) {
		isHostCallbackScheduled = true;
		requestHostCallback(flushWork);
		}
		@@ -378,26 +813,18 @@ }
		function unstable_getFirstCallbackNode() {
		return firstCallbackNode;
		return peek(taskQueue);
		}

		function unstable_cancelCallback(callbackNode) {
		var next = callbackNode.next;
		if (next === null) {
		// Already cancelled.
		return;
		}

		if (next === callbackNode) {
		// This is the only scheduled callback. Clear the list.
		firstCallbackNode = null;
		} else {
		// Remove the callback from its position in the list.
		if (callbackNode === firstCallbackNode) {
		firstCallbackNode = next;
		function unstable_cancelCallback(task) {
		{
		if (task.isQueued) {
		var currentTime = exports.unstable_now();
		markTaskCanceled(task, currentTime);
		task.isQueued = false;
		}
		var previous = callbackNode.previous;
		previous.next = next;
		next.previous = previous;
		}
		} // 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.)

		callbackNode.next = callbackNode.previous = null;

		task.callback = null;
		}
		@@ -410,269 +837,33 @@
		function unstable_shouldYield() {
		return !currentDidTimeout && (firstCallbackNode !== null && firstCallbackNode.expirationTime < currentExpirationTime \|\| shouldYieldToHost());
		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();
		}

		// The remaining code is essentially a polyfill for requestIdleCallback. It
		// works by scheduling a requestAnimationFrame, storing the time for the start
		// of the frame, then scheduling a postMessage which gets scheduled after paint.
		// Within the postMessage handler do as much work as possible until time + frame
		// rate. By separating the idle call into a separate event tick we ensure that
		// layout, paint and other browser work is counted against the available time.
		// The frame rate is dynamically adjusted.
		var unstable_requestPaint = requestPaint;
		var unstable_Profiling = {
		startLoggingProfilingEvents: startLoggingProfilingEvents,
		stopLoggingProfilingEvents: stopLoggingProfilingEvents,
		sharedProfilingBuffer: sharedProfilingBuffer
		} ;

		// We capture a local reference to any global, in case it gets polyfilled after
		// this module is initially evaluated. We want to be using a
		// consistent implementation.
		var localDate = Date;

		// This initialization code may run even on server environments if a component
		// just imports ReactDOM (e.g. for findDOMNode). Some environments might not
		// have setTimeout or clearTimeout. However, we always expect them to be defined
		// on the client. https://github.com/facebook/react/pull/13088
		var localSetTimeout = typeof setTimeout === 'function' ? setTimeout : undefined;
		var localClearTimeout = typeof clearTimeout === 'function' ? clearTimeout : undefined;

		// We don't expect either of these to necessarily be defined, but we will error
		// later if they are missing on the client.
		var localRequestAnimationFrame = typeof requestAnimationFrame === 'function' ? requestAnimationFrame : undefined;
		var localCancelAnimationFrame = typeof cancelAnimationFrame === 'function' ? cancelAnimationFrame : undefined;

		// requestAnimationFrame does not run when the tab is in the background. If
		// we're backgrounded we prefer for that work to happen so that the page
		// continues to load in the background. So we also schedule a 'setTimeout' as
		// a fallback.
		// TODO: Need a better heuristic for backgrounded work.
		var ANIMATION_FRAME_TIMEOUT = 100;
		var rAFID;
		var rAFTimeoutID;
		var requestAnimationFrameWithTimeout = function (callback) {
		// schedule rAF and also a setTimeout
		rAFID = localRequestAnimationFrame(function (timestamp) {
		// cancel the setTimeout
		localClearTimeout(rAFTimeoutID);
		callback(timestamp);
		});
		rAFTimeoutID = localSetTimeout(function () {
		// cancel the requestAnimationFrame
		localCancelAnimationFrame(rAFID);
		callback(exports.unstable_now());
		}, ANIMATION_FRAME_TIMEOUT);
		};

		if (hasNativePerformanceNow) {
		var Performance = performance;
		exports.unstable_now = function () {
		return Performance.now();
		};
		} else {
		exports.unstable_now = function () {
		return localDate.now();
		};
		}

		var requestHostCallback;
		var cancelHostCallback;
		var shouldYieldToHost;

		var globalValue = null;
		if (typeof window !== 'undefined') {
		globalValue = window;
		} else if (typeof global !== 'undefined') {
		globalValue = global;
		}

		if (globalValue && globalValue._schedMock) {
		// Dynamic injection, only for testing purposes.
		var globalImpl = globalValue._schedMock;
		requestHostCallback = globalImpl[0];
		cancelHostCallback = globalImpl[1];
		shouldYieldToHost = globalImpl[2];
		exports.unstable_now = globalImpl[3];
		} else 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 _flushCallback = function (didTimeout) {
		if (_callback !== null) {
		try {
		_callback(didTimeout);
		} finally {
		_callback = null;
		}
		}
		};
		requestHostCallback = function (cb, ms) {
		if (_callback !== null) {
		// Protect against re-entrancy.
		setTimeout(requestHostCallback, 0, cb);
		} else {
		_callback = cb;
		setTimeout(_flushCallback, 0, false);
		}
		};
		cancelHostCallback = function () {
		_callback = null;
		};
		shouldYieldToHost = function () {
		return false;
		};
		} else {
		if (typeof console !== 'undefined') {
		// TODO: Remove fb.me link
		if (typeof localRequestAnimationFrame !== 'function') {
		console.error("This browser doesn't support requestAnimationFrame. " + 'Make sure that you load a ' + 'polyfill in older browsers. https://fb.me/react-polyfills');
		}
		if (typeof localCancelAnimationFrame !== 'function') {
		console.error("This browser doesn't support cancelAnimationFrame. " + 'Make sure that you load a ' + 'polyfill in older browsers. https://fb.me/react-polyfills');
		}
		}

		var scheduledHostCallback = null;
		var isMessageEventScheduled = false;
		var timeoutTime = -1;

		var isAnimationFrameScheduled = false;

		var isFlushingHostCallback = false;

		var frameDeadline = 0;
		// We start out assuming that we run at 30fps but then the heuristic tracking
		// will adjust this value to a faster fps if we get more frequent animation
		// frames.
		var previousFrameTime = 33;
		var activeFrameTime = 33;

		shouldYieldToHost = function () {
		return frameDeadline <= exports.unstable_now();
		};

		// We use the postMessage trick to defer idle work until after the repaint.
		var channel = new MessageChannel();
		var port = channel.port2;
		channel.port1.onmessage = function (event) {
		isMessageEventScheduled = false;

		var prevScheduledCallback = scheduledHostCallback;
		var prevTimeoutTime = timeoutTime;
		scheduledHostCallback = null;
		timeoutTime = -1;

		var currentTime = exports.unstable_now();

		var didTimeout = false;
		if (frameDeadline - currentTime <= 0) {
		// There's no time left in this idle period. Check if the callback has
		// a timeout and whether it's been exceeded.
		if (prevTimeoutTime !== -1 && prevTimeoutTime <= currentTime) {
		// Exceeded the timeout. Invoke the callback even though there's no
		// time left.
		didTimeout = true;
		} else {
		// No timeout.
		if (!isAnimationFrameScheduled) {
		// Schedule another animation callback so we retry later.
		isAnimationFrameScheduled = true;
		requestAnimationFrameWithTimeout(animationTick);
		}
		// Exit without invoking the callback.
		scheduledHostCallback = prevScheduledCallback;
		timeoutTime = prevTimeoutTime;
		return;
		}
		}

		if (prevScheduledCallback !== null) {
		isFlushingHostCallback = true;
		try {
		prevScheduledCallback(didTimeout);
		} finally {
		isFlushingHostCallback = false;
		}
		}
		};

		var animationTick = function (rafTime) {
		if (scheduledHostCallback !== null) {
		// Eagerly schedule the next animation callback at the beginning of the
		// frame. If the scheduler queue is not empty at the end of the frame, it
		// will continue flushing inside that callback. If the queue is empty,
		// then it will exit immediately. Posting the callback at the start of the
		// frame ensures it's fired within the earliest possible frame. If we
		// waited until the end of the frame to post the callback, we risk the
		// browser skipping a frame and not firing the callback until the frame
		// after that.
		requestAnimationFrameWithTimeout(animationTick);
		} else {
		// No pending work. Exit.
		isAnimationFrameScheduled = false;
		return;
		}

		var nextFrameTime = rafTime - frameDeadline + activeFrameTime;
		if (nextFrameTime < activeFrameTime && previousFrameTime < activeFrameTime) {
		if (nextFrameTime < 8) {
		// Defensive coding. We don't support higher frame rates than 120hz.
		// If the calculated frame time gets lower than 8, it is probably a bug.
		nextFrameTime = 8;
		}
		// If one frame goes long, then the next one can be short to catch up.
		// If two frames are short in a row, then that's an indication that we
		// actually have a higher frame rate than what we're currently optimizing.
		// We adjust our heuristic dynamically accordingly. For example, if we're
		// running on 120hz display or 90hz VR display.
		// Take the max of the two in case one of them was an anomaly due to
		// missed frame deadlines.
		activeFrameTime = nextFrameTime < previousFrameTime ? previousFrameTime : nextFrameTime;
		} else {
		previousFrameTime = nextFrameTime;
		}
		frameDeadline = rafTime + activeFrameTime;
		if (!isMessageEventScheduled) {
		isMessageEventScheduled = true;
		port.postMessage(undefined);
		}
		};

		requestHostCallback = function (callback, absoluteTimeout) {
		scheduledHostCallback = callback;
		timeoutTime = absoluteTimeout;
		if (isFlushingHostCallback \|\| absoluteTimeout < 0) {
		// Don't wait for the next frame. Continue working ASAP, in a new event.
		port.postMessage(undefined);
		} else if (!isAnimationFrameScheduled) {
		// If rAF didn't already schedule one, we need to schedule a frame.
		// TODO: If this rAF doesn't materialize because the browser throttles, we
		// might want to still have setTimeout trigger rIC as a backup to ensure
		// that we keep performing work.
		isAnimationFrameScheduled = true;
		requestAnimationFrameWithTimeout(animationTick);
		}
		};

		cancelHostCallback = function () {
		scheduledHostCallback = null;
		isMessageEventScheduled = false;
		timeoutTime = -1;
		};
		}

		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_NormalPriority = NormalPriority;
		exports.unstable_IdlePriority = IdlePriority;
		exports.unstable_LowPriority = LowPriority;
		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_cancelCallback = unstable_cancelCallback;
		exports.unstable_shouldYield = unstable_shouldYield;
		exports.unstable_wrapCallback = unstable_wrapCallback;
		exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
		exports.unstable_shouldYield = unstable_shouldYield;
		exports.unstable_continueExecution = unstable_continueExecution;
		exports.unstable_pauseExecution = unstable_pauseExecution;
		exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode;
		})();
		}

cjs/scheduler.production.min.js

		@@ -1,2 +0,2 @@
		/** @license React v0.0.0-11565a207
		/** @license React v0.0.0-235a6c4af
		* scheduler.production.min.js
		@@ -10,13 +10,13 @@ *

		'use strict';Object.defineProperty(exports,"__esModule",{value:!0});var c=null,f=!1,h=3,k=-1,l=-1,m=!1,n=!1;function p(){if(!m){var a=c.expirationTime;n?q():n=!0;r(t,a)}}
		function u(){var a=c,b=c.next;if(c===b)c=null;else{var d=c.previous;c=d.next=b;b.previous=d}a.next=a.previous=null;d=a.callback;b=a.expirationTime;a=a.priorityLevel;var e=h,Q=l;h=a;l=b;try{var g=d()}finally{h=e,l=Q}if("function"===typeof g)if(g={callback:g,priorityLevel:a,expirationTime:b,next:null,previous:null},null===c)c=g.next=g.previous=g;else{d=null;a=c;do{if(a.expirationTime>=b){d=a;break}a=a.next}while(a!==c);null===d?d=c:d===c&&(c=g,p());b=d.previous;b.next=d.previous=g;g.next=d;g.previous=
		b}}function v(){if(-1===k&&null!==c&&1===c.priorityLevel){m=!0;try{do u();while(null!==c&&1===c.priorityLevel)}finally{m=!1,null!==c?p():n=!1}}}function t(a){m=!0;var b=f;f=a;try{if(a)for(;null!==c;){var d=exports.unstable_now();if(c.expirationTime<=d){do u();while(null!==c&&c.expirationTime<=d)}else break}else if(null!==c){do u();while(null!==c&&!w())}}finally{m=!1,f=b,null!==c?p():n=!1,v()}}
		var x=Date,y="function"===typeof setTimeout?setTimeout:void 0,z="function"===typeof clearTimeout?clearTimeout:void 0,A="function"===typeof requestAnimationFrame?requestAnimationFrame:void 0,B="function"===typeof cancelAnimationFrame?cancelAnimationFrame:void 0,C,D;function E(a){C=A(function(b){z(D);a(b)});D=y(function(){B(C);a(exports.unstable_now())},100)}
		if("object"===typeof performance&&"function"===typeof performance.now){var F=performance;exports.unstable_now=function(){return F.now()}}else exports.unstable_now=function(){return x.now()};var r,q,w,G=null;"undefined"!==typeof window?G=window:"undefined"!==typeof global&&(G=global);
		if(G&&G._schedMock){var H=G._schedMock;r=H[0];q=H[1];w=H[2];exports.unstable_now=H[3]}else if("undefined"===typeof window\|\|"function"!==typeof MessageChannel){var I=null,J=function(a){if(null!==I)try{I(a)}finally{I=null}};r=function(a){null!==I?setTimeout(r,0,a):(I=a,setTimeout(J,0,!1))};q=function(){I=null};w=function(){return!1}}else{"undefined"!==typeof console&&("function"!==typeof A&&console.error("This browser doesn't support requestAnimationFrame. Make sure that you load a polyfill in older browsers. https://fb.me/react-polyfills"),
		"function"!==typeof B&&console.error("This browser doesn't support cancelAnimationFrame. Make sure that you load a polyfill in older browsers. https://fb.me/react-polyfills"));var K=null,L=!1,M=-1,N=!1,O=!1,P=0,R=33,S=33;w=function(){return P<=exports.unstable_now()};var T=new MessageChannel,U=T.port2;T.port1.onmessage=function(){L=!1;var a=K,b=M;K=null;M=-1;var d=exports.unstable_now(),e=!1;if(0>=P-d)if(-1!==b&&b<=d)e=!0;else{N\|\|(N=!0,E(V));K=a;M=b;return}if(null!==a){O=!0;try{a(e)}finally{O=!1}}};
		var V=function(a){if(null!==K){E(V);var b=a-P+S;b<S&&R<S?(8>b&&(b=8),S=b<R?R:b):R=b;P=a+S;L\|\|(L=!0,U.postMessage(void 0))}else N=!1};r=function(a,b){K=a;M=b;O\|\|0>b?U.postMessage(void 0):N\|\|(N=!0,E(V))};q=function(){K=null;L=!1;M=-1}}exports.unstable_ImmediatePriority=1;exports.unstable_UserBlockingPriority=2;exports.unstable_NormalPriority=3;exports.unstable_IdlePriority=5;exports.unstable_LowPriority=4;
		exports.unstable_runWithPriority=function(a,b){switch(a){case 1:case 2:case 3:case 4:case 5:break;default:a=3}var d=h,e=k;h=a;k=exports.unstable_now();try{return b()}finally{h=d,k=e,v()}};
		exports.unstable_scheduleCallback=function(a,b){var d=-1!==k?k:exports.unstable_now();if("object"===typeof b&&null!==b&&"number"===typeof b.timeout)b=d+b.timeout;else switch(h){case 1:b=d+-1;break;case 2:b=d+250;break;case 5:b=d+1073741823;break;case 4:b=d+1E4;break;default:b=d+5E3}a={callback:a,priorityLevel:h,expirationTime:b,next:null,previous:null};if(null===c)c=a.next=a.previous=a,p();else{d=null;var e=c;do{if(e.expirationTime>b){d=e;break}e=e.next}while(e!==c);null===d?d=c:d===c&&(c=a,p());
		b=d.previous;b.next=d.previous=a;a.next=d;a.previous=b}return a};exports.unstable_cancelCallback=function(a){var b=a.next;if(null!==b){if(b===a)c=null;else{a===c&&(c=b);var d=a.previous;d.next=b;b.previous=d}a.next=a.previous=null}};exports.unstable_wrapCallback=function(a){var b=h;return function(){var d=h,e=k;h=b;k=exports.unstable_now();try{return a.apply(this,arguments)}finally{h=d,k=e,v()}}};exports.unstable_getCurrentPriorityLevel=function(){return h};
		exports.unstable_shouldYield=function(){return!f&&(null!==c&&c.expirationTime<l\|\|w())};exports.unstable_continueExecution=function(){null!==c&&p()};exports.unstable_pauseExecution=function(){};exports.unstable_getFirstCallbackNode=function(){return c};
		'use strict';var f,g,h,k,l;
		if("undefined"===typeof window\|\|"function"!==typeof MessageChannel){var p=null,q=null,t=function(){if(null!==p)try{var a=exports.unstable_now();p(!0,a);p=null}catch(b){throw setTimeout(t,0),b;}},u=Date.now();exports.unstable_now=function(){return Date.now()-u};f=function(a){null!==p?setTimeout(f,0,a):(p=a,setTimeout(t,0))};g=function(a,b){q=setTimeout(a,b)};h=function(){clearTimeout(q)};k=function(){return!1};l=exports.unstable_forceFrameRate=function(){}}else{var w=window.performance,x=window.Date,
		y=window.setTimeout,z=window.clearTimeout;if("undefined"!==typeof console){var A=window.cancelAnimationFrame;"function"!==typeof window.requestAnimationFrame&&console.error("This browser doesn't support requestAnimationFrame. Make sure that you load a polyfill in older browsers. https://fb.me/react-polyfills");"function"!==typeof A&&console.error("This browser doesn't support cancelAnimationFrame. Make sure that you load a polyfill in older browsers. https://fb.me/react-polyfills")}if("object"===
		typeof w&&"function"===typeof w.now)exports.unstable_now=function(){return w.now()};else{var B=x.now();exports.unstable_now=function(){return x.now()-B}}var C=!1,D=null,E=-1,F=5,G=0;k=function(){return exports.unstable_now()>=G};l=function(){};exports.unstable_forceFrameRate=function(a){0>a\|\|125<a?console.error("forceFrameRate takes a positive int between 0 and 125, forcing framerates higher than 125 fps is not unsupported"):F=0<a?Math.floor(1E3/a):5};var H=new MessageChannel,I=H.port2;H.port1.onmessage=
		function(){if(null!==D){var a=exports.unstable_now();G=a+F;try{D(!0,a)?I.postMessage(null):(C=!1,D=null)}catch(b){throw I.postMessage(null),b;}}else C=!1};f=function(a){D=a;C\|\|(C=!0,I.postMessage(null))};g=function(a,b){E=y(function(){a(exports.unstable_now())},b)};h=function(){z(E);E=-1}}function J(a,b){var c=a.length;a.push(b);a:for(;;){var d=c-1>>>1,e=a[d];if(void 0!==e&&0<K(e,b))a[d]=b,a[c]=e,c=d;else break a}}function L(a){a=a[0];return void 0===a?null:a}
		function M(a){var b=a[0];if(void 0!==b){var c=a.pop();if(c!==b){a[0]=c;a:for(var d=0,e=a.length;d<e;){var m=2*(d+1)-1,n=a[m],v=m+1,r=a[v];if(void 0!==n&&0>K(n,c))void 0!==r&&0>K(r,n)?(a[d]=r,a[v]=c,d=v):(a[d]=n,a[m]=c,d=m);else if(void 0!==r&&0>K(r,c))a[d]=r,a[v]=c,d=v;else break a}}return b}return null}function K(a,b){var c=a.sortIndex-b.sortIndex;return 0!==c?c:a.id-b.id}var N=[],O=[],P=1,Q=null,R=3,S=!1,T=!1,U=!1;
		function V(a){for(var b=L(O);null!==b;){if(null===b.callback)M(O);else if(b.startTime<=a)M(O),b.sortIndex=b.expirationTime,J(N,b);else break;b=L(O)}}function W(a){U=!1;V(a);if(!T)if(null!==L(N))T=!0,f(X);else{var b=L(O);null!==b&&g(W,b.startTime-a)}}
		function X(a,b){T=!1;U&&(U=!1,h());S=!0;var c=R;try{V(b);for(Q=L(N);null!==Q&&(!(Q.expirationTime>b)\|\|a&&!k());){var d=Q.callback;if(null!==d){Q.callback=null;R=Q.priorityLevel;var e=d(Q.expirationTime<=b);b=exports.unstable_now();"function"===typeof e?Q.callback=e:Q===L(N)&&M(N);V(b)}else M(N);Q=L(N)}if(null!==Q)var m=!0;else{var n=L(O);null!==n&&g(W,n.startTime-b);m=!1}return m}finally{Q=null,R=c,S=!1}}
		function Y(a){switch(a){case 1:return-1;case 2:return 250;case 5:return 1073741823;case 4:return 1E4;default:return 5E3}}var Z=l;exports.unstable_IdlePriority=5;exports.unstable_ImmediatePriority=1;exports.unstable_LowPriority=4;exports.unstable_NormalPriority=3;exports.unstable_Profiling=null;exports.unstable_UserBlockingPriority=2;exports.unstable_cancelCallback=function(a){a.callback=null};exports.unstable_continueExecution=function(){T\|\|S\|\|(T=!0,f(X))};
		exports.unstable_getCurrentPriorityLevel=function(){return R};exports.unstable_getFirstCallbackNode=function(){return L(N)};exports.unstable_next=function(a){switch(R){case 1:case 2:case 3:var b=3;break;default:b=R}var c=R;R=b;try{return a()}finally{R=c}};exports.unstable_pauseExecution=function(){};exports.unstable_requestPaint=Z;exports.unstable_runWithPriority=function(a,b){switch(a){case 1:case 2:case 3:case 4:case 5:break;default:a=3}var c=R;R=a;try{return b()}finally{R=c}};
		exports.unstable_scheduleCallback=function(a,b,c){var d=exports.unstable_now();if("object"===typeof c&&null!==c){var e=c.delay;e="number"===typeof e&&0<e?d+e:d;c="number"===typeof c.timeout?c.timeout:Y(a)}else c=Y(a),e=d;c=e+c;a={id:P++,callback:b,priorityLevel:a,startTime:e,expirationTime:c,sortIndex:-1};e>d?(a.sortIndex=e,J(O,a),null===L(N)&&a===L(O)&&(U?h():U=!0,g(W,e-d))):(a.sortIndex=c,J(N,a),T\|\|S\|\|(T=!0,f(X)));return a};
		exports.unstable_shouldYield=function(){var a=exports.unstable_now();V(a);var b=L(N);return b!==Q&&null!==Q&&null!==b&&null!==b.callback&&b.startTime<=a&&b.expirationTime<Q.expirationTime\|\|k()};exports.unstable_wrapCallback=function(a){var b=R;return function(){var c=R;R=b;try{return a.apply(this,arguments)}finally{R=c}}};

package.json

		{
		"name": "scheduler",
		"version": "0.0.0-11565a207",
		"version": "0.0.0-235a6c4af",
		"description": "Cooperative scheduler for the browser environment.",
		@@ -30,2 +30,3 @@ "main": "index.js",
		"tracing-profiling.js",
		"unstable_mock.js",
		"cjs/",
		@@ -32,0 +33,0 @@ "umd/"

umd/scheduler-tracing.development.js

		@@ -17,4 +17,4 @@ /**
		: typeof define === 'function' && define.amd // eslint-disable-line no-undef
		? define(['react'], factory) // eslint-disable-line no-undef
		: (global.SchedulerTracing = factory(global));
		? define(['react'], factory) // eslint-disable-line no-undef
		: (global.SchedulerTracing = factory(global));
		})(this, function(global) {
		@@ -21,0 +21,0 @@ function unstable_clear() {

umd/scheduler-tracing.production.min.js

		@@ -17,4 +17,4 @@ /**
		: typeof define === 'function' && define.amd // eslint-disable-line no-undef
		? define(['react'], factory) // eslint-disable-line no-undef
		: (global.SchedulerTracing = factory(global));
		? define(['react'], factory) // eslint-disable-line no-undef
		: (global.SchedulerTracing = factory(global));
		})(this, function(global) {
		@@ -21,0 +21,0 @@ function unstable_clear() {

umd/scheduler-tracing.profiling.min.js

		@@ -17,4 +17,4 @@ /**
		: typeof define === 'function' && define.amd // eslint-disable-line no-undef
		? define(['react'], factory) // eslint-disable-line no-undef
		: (global.SchedulerTracing = factory(global));
		? define(['react'], factory) // eslint-disable-line no-undef
		: (global.SchedulerTracing = factory(global));
		})(this, function(global) {
		@@ -21,0 +21,0 @@ function unstable_clear() {

umd/scheduler.development.js

		@@ -19,4 +19,4 @@ /**
		: typeof define === 'function' && define.amd // eslint-disable-line no-undef
		? define(['react'], factory) // eslint-disable-line no-undef
		: (global.Scheduler = factory(global));
		? define(['react'], factory) // eslint-disable-line no-undef
		: (global.Scheduler = factory(global));
		})(this, function(global) {
		@@ -51,2 +51,9 @@ function unstable_now() {

		function unstable_requestPaint() {
		return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Scheduler.unstable_requestPaint.apply(
		this,
		arguments
		);
		}

		function unstable_runWithPriority() {
		@@ -59,2 +66,9 @@ return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Scheduler.unstable_runWithPriority.apply(

		function unstable_next() {
		return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Scheduler.unstable_next.apply(
		this,
		arguments
		);
		}

		function unstable_wrapCallback() {
		@@ -95,2 +109,9 @@ return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Scheduler.unstable_wrapCallback.apply(

		function unstable_forceFrameRate() {
		return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Scheduler.unstable_forceFrameRate.apply(
		this,
		arguments
		);
		}

		return Object.freeze({
		@@ -101,3 +122,5 @@ unstable_now: unstable_now,
		unstable_shouldYield: unstable_shouldYield,
		unstable_requestPaint: unstable_requestPaint,
		unstable_runWithPriority: unstable_runWithPriority,
		unstable_next: unstable_next,
		unstable_wrapCallback: unstable_wrapCallback,
		@@ -108,3 +131,28 @@ unstable_getCurrentPriorityLevel: unstable_getCurrentPriorityLevel,
		unstable_getFirstCallbackNode: unstable_getFirstCallbackNode,
		unstable_forceFrameRate: unstable_forceFrameRate,
		get unstable_IdlePriority() {
		return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
		.Scheduler.unstable_IdlePriority;
		},
		get unstable_ImmediatePriority() {
		return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
		.Scheduler.unstable_ImmediatePriority;
		},
		get unstable_LowPriority() {
		return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
		.Scheduler.unstable_LowPriority;
		},
		get unstable_NormalPriority() {
		return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
		.Scheduler.unstable_NormalPriority;
		},
		get unstable_UserBlockingPriority() {
		return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
		.Scheduler.unstable_UserBlockingPriority;
		},
		get unstable_Profiling() {
		return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
		.Scheduler.unstable_Profiling;
		},
		});
		});

umd/scheduler.production.min.js

		@@ -19,4 +19,4 @@ /**
		: typeof define === 'function' && define.amd // eslint-disable-line no-undef
		? define(['react'], factory) // eslint-disable-line no-undef
		: (global.Scheduler = factory(global));
		? define(['react'], factory) // eslint-disable-line no-undef
		: (global.Scheduler = factory(global));
		})(this, function(global) {
		@@ -51,2 +51,9 @@ function unstable_now() {

		function unstable_requestPaint() {
		return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Scheduler.unstable_requestPaint.apply(
		this,
		arguments
		);
		}

		function unstable_runWithPriority() {
		@@ -59,2 +66,9 @@ return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Scheduler.unstable_runWithPriority.apply(

		function unstable_next() {
		return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Scheduler.unstable_next.apply(
		this,
		arguments
		);
		}

		function unstable_wrapCallback() {
		@@ -89,2 +103,9 @@ return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Scheduler.unstable_wrapCallback.apply(

		function unstable_forceFrameRate() {
		return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Scheduler.unstable_forceFrameRate.apply(
		this,
		arguments
		);
		}

		return Object.freeze({
		@@ -95,3 +116,5 @@ unstable_now: unstable_now,
		unstable_shouldYield: unstable_shouldYield,
		unstable_requestPaint: unstable_requestPaint,
		unstable_runWithPriority: unstable_runWithPriority,
		unstable_next: unstable_next,
		unstable_wrapCallback: unstable_wrapCallback,
		@@ -102,3 +125,28 @@ unstable_getCurrentPriorityLevel: unstable_getCurrentPriorityLevel,
		unstable_getFirstCallbackNode: unstable_getFirstCallbackNode,
		unstable_forceFrameRate: unstable_forceFrameRate,
		get unstable_IdlePriority() {
		return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
		.Scheduler.unstable_IdlePriority;
		},
		get unstable_ImmediatePriority() {
		return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
		.Scheduler.unstable_ImmediatePriority;
		},
		get unstable_LowPriority() {
		return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
		.Scheduler.unstable_LowPriority;
		},
		get unstable_NormalPriority() {
		return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
		.Scheduler.unstable_NormalPriority;
		},
		get unstable_UserBlockingPriority() {
		return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
		.Scheduler.unstable_UserBlockingPriority;
		},
		get unstable_Profiling() {
		return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
		.Scheduler.unstable_Profiling;
		},
		});
		});

umd/scheduler.profiling.min.js

		@@ -19,4 +19,4 @@ /**
		: typeof define === 'function' && define.amd // eslint-disable-line no-undef
		? define(['react'], factory) // eslint-disable-line no-undef
		: (global.Scheduler = factory(global));
		? define(['react'], factory) // eslint-disable-line no-undef
		: (global.Scheduler = factory(global));
		})(this, function(global) {
		@@ -51,2 +51,9 @@ function unstable_now() {

		function unstable_requestPaint() {
		return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Scheduler.unstable_requestPaint.apply(
		this,
		arguments
		);
		}

		function unstable_runWithPriority() {
		@@ -59,2 +66,9 @@ return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Scheduler.unstable_runWithPriority.apply(

		function unstable_next() {
		return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Scheduler.unstable_next.apply(
		this,
		arguments
		);
		}

		function unstable_wrapCallback() {
		@@ -89,2 +103,9 @@ return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Scheduler.unstable_wrapCallback.apply(

		function unstable_forceFrameRate() {
		return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.Scheduler.unstable_forceFrameRate.apply(
		this,
		arguments
		);
		}

		return Object.freeze({
		@@ -95,3 +116,5 @@ unstable_now: unstable_now,
		unstable_shouldYield: unstable_shouldYield,
		unstable_requestPaint: unstable_requestPaint,
		unstable_runWithPriority: unstable_runWithPriority,
		unstable_next: unstable_next,
		unstable_wrapCallback: unstable_wrapCallback,
		@@ -102,3 +125,28 @@ unstable_getCurrentPriorityLevel: unstable_getCurrentPriorityLevel,
		unstable_getFirstCallbackNode: unstable_getFirstCallbackNode,
		unstable_forceFrameRate: unstable_forceFrameRate,
		get unstable_IdlePriority() {
		return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
		.Scheduler.unstable_IdlePriority;
		},
		get unstable_ImmediatePriority() {
		return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
		.Scheduler.unstable_ImmediatePriority;
		},
		get unstable_LowPriority() {
		return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
		.Scheduler.unstable_LowPriority;
		},
		get unstable_NormalPriority() {
		return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
		.Scheduler.unstable_NormalPriority;
		},
		get unstable_UserBlockingPriority() {
		return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
		.Scheduler.unstable_UserBlockingPriority;
		},
		get unstable_Profiling() {
		return global.React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
		.Scheduler.unstable_Profiling;
		},
		});
		});

scheduler - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics