@vincentgraul/react-components 1.0.2 → 1.0.4

package/build/esm/node_modules/scheduler/cjs/scheduler.development.js

@@ -0,0 +1,632 @@
+import { __exports as scheduler_development } from '../../../_virtual/scheduler.development.js';
+
+/**
+ * @license React
+ * scheduler.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredScheduler_development;
+
+function requireScheduler_development () {
+	if (hasRequiredScheduler_development) return scheduler_development;
+	hasRequiredScheduler_development = 1;
+	(function (exports) {
+
+		if (process.env.NODE_ENV !== "production") {
+		  (function() {
+
+		/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+		if (
+		  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
+		  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart ===
+		    'function'
+		) {
+		  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
+		}
+		          var enableSchedulerDebugging = false;
+		var enableProfiling = false;
+		var frameYieldMs = 5;
+
+		function push(heap, node) {
+		  var index = heap.length;
+		  heap.push(node);
+		  siftUp(heap, node, index);
+		}
+		function peek(heap) {
+		  return heap.length === 0 ? null : heap[0];
+		}
+		function pop(heap) {
+		  if (heap.length === 0) {
+		    return null;
+		  }
+
+		  var first = heap[0];
+		  var last = heap.pop();
+
+		  if (last !== first) {
+		    heap[0] = last;
+		    siftDown(heap, last, 0);
+		  }
+
+		  return first;
+		}
+
+		function siftUp(heap, node, i) {
+		  var index = i;
+
+		  while (index > 0) {
+		    var parentIndex = index - 1 >>> 1;
+		    var parent = heap[parentIndex];
+
+		    if (compare(parent, node) > 0) {
+		      // The parent is larger. Swap positions.
+		      heap[parentIndex] = node;
+		      heap[index] = parent;
+		      index = parentIndex;
+		    } else {
+		      // The parent is smaller. Exit.
+		      return;
+		    }
+		  }
+		}
+
+		function siftDown(heap, node, i) {
+		  var index = i;
+		  var length = heap.length;
+		  var halfLength = length >>> 1;
+
+		  while (index < halfLength) {
+		    var leftIndex = (index + 1) * 2 - 1;
+		    var left = heap[leftIndex];
+		    var rightIndex = leftIndex + 1;
+		    var right = heap[rightIndex]; // If the left or right node is smaller, swap with the smaller of those.
+
+		    if (compare(left, node) < 0) {
+		      if (rightIndex < length && compare(right, left) < 0) {
+		        heap[index] = right;
+		        heap[rightIndex] = node;
+		        index = rightIndex;
+		      } else {
+		        heap[index] = left;
+		        heap[leftIndex] = node;
+		        index = leftIndex;
+		      }
+		    } else if (rightIndex < length && compare(right, node) < 0) {
+		      heap[index] = right;
+		      heap[rightIndex] = node;
+		      index = rightIndex;
+		    } else {
+		      // Neither child is smaller. Exit.
+		      return;
+		    }
+		  }
+		}
+
+		function compare(a, b) {
+		  // Compare sort index first, then task id.
+		  var diff = a.sortIndex - b.sortIndex;
+		  return diff !== 0 ? diff : a.id - b.id;
+		}
+
+		// TODO: Use symbols?
+		var ImmediatePriority = 1;
+		var UserBlockingPriority = 2;
+		var NormalPriority = 3;
+		var LowPriority = 4;
+		var IdlePriority = 5;
+
+		function markTaskErrored(task, ms) {
+		}
+
+		/* eslint-disable no-var */
+
+		var hasPerformanceNow = typeof performance === 'object' && typeof performance.now === 'function';
+
+		if (hasPerformanceNow) {
+		  var localPerformance = performance;
+
+		  exports.unstable_now = function () {
+		    return localPerformance.now();
+		  };
+		} else {
+		  var localDate = Date;
+		  var initialTime = localDate.now();
+
+		  exports.unstable_now = function () {
+		    return localDate.now() - initialTime;
+		  };
+		} // Max 31 bit integer. The max integer size in V8 for 32-bit systems.
+		// Math.pow(2, 30) - 1
+		// 0b111111111111111111111111111111
+
+
+		var maxSigned31BitInt = 1073741823; // Times out immediately
+
+		var IMMEDIATE_PRIORITY_TIMEOUT = -1; // Eventually times out
+
+		var USER_BLOCKING_PRIORITY_TIMEOUT = 250;
+		var NORMAL_PRIORITY_TIMEOUT = 5000;
+		var LOW_PRIORITY_TIMEOUT = 10000; // Never times out
+
+		var IDLE_PRIORITY_TIMEOUT = maxSigned31BitInt; // Tasks are stored on a min heap
+
+		var taskQueue = [];
+		var timerQueue = []; // Incrementing id counter. Used to maintain insertion order.
+
+		var taskIdCounter = 1; // Pausing the scheduler is useful for debugging.
+		var currentTask = null;
+		var currentPriorityLevel = NormalPriority; // This is set while performing work, to prevent re-entrance.
+
+		var isPerformingWork = false;
+		var isHostCallbackScheduled = false;
+		var isHostTimeoutScheduled = false; // Capture local references to native APIs, in case a polyfill overrides them.
+
+		var localSetTimeout = typeof setTimeout === 'function' ? setTimeout : null;
+		var localClearTimeout = typeof clearTimeout === 'function' ? clearTimeout : null;
+		var localSetImmediate = typeof setImmediate !== 'undefined' ? setImmediate : null; // IE and Node.js + jsdom
+
+		typeof navigator !== 'undefined' && navigator.scheduling !== undefined && navigator.scheduling.isInputPending !== undefined ? navigator.scheduling.isInputPending.bind(navigator.scheduling) : null;
+
+		function advanceTimers(currentTime) {
+		  // Check for tasks that are no longer delayed and add them to the queue.
+		  var timer = peek(timerQueue);
+
+		  while (timer !== null) {
+		    if (timer.callback === null) {
+		      // Timer was cancelled.
+		      pop(timerQueue);
+		    } else if (timer.startTime <= currentTime) {
+		      // Timer fired. Transfer to the task queue.
+		      pop(timerQueue);
+		      timer.sortIndex = timer.expirationTime;
+		      push(taskQueue, timer);
+		    } else {
+		      // Remaining timers are pending.
+		      return;
+		    }
+
+		    timer = peek(timerQueue);
+		  }
+		}
+
+		function handleTimeout(currentTime) {
+		  isHostTimeoutScheduled = false;
+		  advanceTimers(currentTime);
+
+		  if (!isHostCallbackScheduled) {
+		    if (peek(taskQueue) !== null) {
+		      isHostCallbackScheduled = true;
+		      requestHostCallback(flushWork);
+		    } else {
+		      var firstTimer = peek(timerQueue);
+
+		      if (firstTimer !== null) {
+		        requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
+		      }
+		    }
+		  }
+		}
+
+		function flushWork(hasTimeRemaining, initialTime) {
+
+
+		  isHostCallbackScheduled = false;
+
+		  if (isHostTimeoutScheduled) {
+		    // We scheduled a timeout but it's no longer needed. Cancel it.
+		    isHostTimeoutScheduled = false;
+		    cancelHostTimeout();
+		  }
+
+		  isPerformingWork = true;
+		  var previousPriorityLevel = currentPriorityLevel;
+
+		  try {
+		    var currentTime; if (enableProfiling) ; else {
+		      // No catch in prod code path.
+		      return workLoop(hasTimeRemaining, initialTime);
+		    }
+		  } finally {
+		    currentTask = null;
+		    currentPriorityLevel = previousPriorityLevel;
+		    isPerformingWork = false;
+		  }
+		}
+
+		function workLoop(hasTimeRemaining, initialTime) {
+		  var currentTime = initialTime;
+		  advanceTimers(currentTime);
+		  currentTask = peek(taskQueue);
+
+		  while (currentTask !== null && !(enableSchedulerDebugging )) {
+		    if (currentTask.expirationTime > currentTime && (!hasTimeRemaining || shouldYieldToHost())) {
+		      // This currentTask hasn't expired, and we've reached the deadline.
+		      break;
+		    }
+
+		    var callback = currentTask.callback;
+
+		    if (typeof callback === 'function') {
+		      currentTask.callback = null;
+		      currentPriorityLevel = currentTask.priorityLevel;
+		      var didUserCallbackTimeout = currentTask.expirationTime <= currentTime;
+
+		      var continuationCallback = callback(didUserCallbackTimeout);
+		      currentTime = exports.unstable_now();
+
+		      if (typeof continuationCallback === 'function') {
+		        currentTask.callback = continuationCallback;
+		      } else {
+
+		        if (currentTask === peek(taskQueue)) {
+		          pop(taskQueue);
+		        }
+		      }
+
+		      advanceTimers(currentTime);
+		    } else {
+		      pop(taskQueue);
+		    }
+
+		    currentTask = peek(taskQueue);
+		  } // Return whether there's additional work
+
+
+		  if (currentTask !== null) {
+		    return true;
+		  } else {
+		    var firstTimer = peek(timerQueue);
+
+		    if (firstTimer !== null) {
+		      requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
+		    }
+
+		    return false;
+		  }
+		}
+
+		function unstable_runWithPriority(priorityLevel, eventHandler) {
+		  switch (priorityLevel) {
+		    case ImmediatePriority:
+		    case UserBlockingPriority:
+		    case NormalPriority:
+		    case LowPriority:
+		    case IdlePriority:
+		      break;
+
+		    default:
+		      priorityLevel = NormalPriority;
+		  }
+
+		  var previousPriorityLevel = currentPriorityLevel;
+		  currentPriorityLevel = priorityLevel;
+
+		  try {
+		    return eventHandler();
+		  } finally {
+		    currentPriorityLevel = previousPriorityLevel;
+		  }
+		}
+
+		function unstable_next(eventHandler) {
+		  var priorityLevel;
+
+		  switch (currentPriorityLevel) {
+		    case ImmediatePriority:
+		    case UserBlockingPriority:
+		    case NormalPriority:
+		      // Shift down to normal priority
+		      priorityLevel = NormalPriority;
+		      break;
+
+		    default:
+		      // Anything lower than normal priority should remain at the current level.
+		      priorityLevel = currentPriorityLevel;
+		      break;
+		  }
+
+		  var previousPriorityLevel = currentPriorityLevel;
+		  currentPriorityLevel = priorityLevel;
+
+		  try {
+		    return eventHandler();
+		  } finally {
+		    currentPriorityLevel = previousPriorityLevel;
+		  }
+		}
+
+		function unstable_wrapCallback(callback) {
+		  var parentPriorityLevel = currentPriorityLevel;
+		  return function () {
+		    // This is a fork of runWithPriority, inlined for performance.
+		    var previousPriorityLevel = currentPriorityLevel;
+		    currentPriorityLevel = parentPriorityLevel;
+
+		    try {
+		      return callback.apply(this, arguments);
+		    } finally {
+		      currentPriorityLevel = previousPriorityLevel;
+		    }
+		  };
+		}
+
+		function unstable_scheduleCallback(priorityLevel, callback, options) {
+		  var currentTime = exports.unstable_now();
+		  var startTime;
+
+		  if (typeof options === 'object' && options !== null) {
+		    var delay = options.delay;
+
+		    if (typeof delay === 'number' && delay > 0) {
+		      startTime = currentTime + delay;
+		    } else {
+		      startTime = currentTime;
+		    }
+		  } else {
+		    startTime = currentTime;
+		  }
+
+		  var timeout;
+
+		  switch (priorityLevel) {
+		    case ImmediatePriority:
+		      timeout = IMMEDIATE_PRIORITY_TIMEOUT;
+		      break;
+
+		    case UserBlockingPriority:
+		      timeout = USER_BLOCKING_PRIORITY_TIMEOUT;
+		      break;
+
+		    case IdlePriority:
+		      timeout = IDLE_PRIORITY_TIMEOUT;
+		      break;
+
+		    case LowPriority:
+		      timeout = LOW_PRIORITY_TIMEOUT;
+		      break;
+
+		    case NormalPriority:
+		    default:
+		      timeout = NORMAL_PRIORITY_TIMEOUT;
+		      break;
+		  }
+
+		  var expirationTime = startTime + timeout;
+		  var newTask = {
+		    id: taskIdCounter++,
+		    callback: callback,
+		    priorityLevel: priorityLevel,
+		    startTime: startTime,
+		    expirationTime: expirationTime,
+		    sortIndex: -1
+		  };
+
+		  if (startTime > currentTime) {
+		    // This is a delayed task.
+		    newTask.sortIndex = startTime;
+		    push(timerQueue, newTask);
+
+		    if (peek(taskQueue) === null && newTask === peek(timerQueue)) {
+		      // All tasks are delayed, and this is the task with the earliest delay.
+		      if (isHostTimeoutScheduled) {
+		        // Cancel an existing timeout.
+		        cancelHostTimeout();
+		      } else {
+		        isHostTimeoutScheduled = true;
+		      } // Schedule a timeout.
+
+
+		      requestHostTimeout(handleTimeout, startTime - currentTime);
+		    }
+		  } else {
+		    newTask.sortIndex = expirationTime;
+		    push(taskQueue, newTask);
+		    // wait until the next time we yield.
+
+
+		    if (!isHostCallbackScheduled && !isPerformingWork) {
+		      isHostCallbackScheduled = true;
+		      requestHostCallback(flushWork);
+		    }
+		  }
+
+		  return newTask;
+		}
+
+		function unstable_pauseExecution() {
+		}
+
+		function unstable_continueExecution() {
+
+		  if (!isHostCallbackScheduled && !isPerformingWork) {
+		    isHostCallbackScheduled = true;
+		    requestHostCallback(flushWork);
+		  }
+		}
+
+		function unstable_getFirstCallbackNode() {
+		  return peek(taskQueue);
+		}
+
+		function unstable_cancelCallback(task) {
+		  // remove from the queue because you can't remove arbitrary nodes from an
+		  // array based heap, only the first one.)
+
+
+		  task.callback = null;
+		}
+
+		function unstable_getCurrentPriorityLevel() {
+		  return currentPriorityLevel;
+		}
+
+		var isMessageLoopRunning = false;
+		var scheduledHostCallback = null;
+		var taskTimeoutID = -1; // Scheduler periodically yields in case there is other work on the main
+		// thread, like user events. By default, it yields multiple times per frame.
+		// It does not attempt to align with frame boundaries, since most tasks don't
+		// need to be frame aligned; for those that do, use requestAnimationFrame.
+
+		var frameInterval = frameYieldMs;
+		var startTime = -1;
+
+		function shouldYieldToHost() {
+		  var timeElapsed = exports.unstable_now() - startTime;
+
+		  if (timeElapsed < frameInterval) {
+		    // The main thread has only been blocked for a really short amount of time;
+		    // smaller than a single frame. Don't yield yet.
+		    return false;
+		  } // The main thread has been blocked for a non-negligible amount of time. We
+
+
+		  return true;
+		}
+
+		function requestPaint() {
+
+		}
+
+		function forceFrameRate(fps) {
+		  if (fps < 0 || fps > 125) {
+		    // Using console['error'] to evade Babel and ESLint
+		    console['error']('forceFrameRate takes a positive int between 0 and 125, ' + 'forcing frame rates higher than 125 fps is not supported');
+		    return;
+		  }
+
+		  if (fps > 0) {
+		    frameInterval = Math.floor(1000 / fps);
+		  } else {
+		    // reset the framerate
+		    frameInterval = frameYieldMs;
+		  }
+		}
+
+		var performWorkUntilDeadline = function () {
+		  if (scheduledHostCallback !== null) {
+		    var currentTime = exports.unstable_now(); // Keep track of the start time so we can measure how long the main thread
+		    // has been blocked.
+
+		    startTime = currentTime;
+		    var hasTimeRemaining = true; // If a scheduler task throws, exit the current browser task so the
+		    // error can be observed.
+		    //
+		    // Intentionally not using a try-catch, since that makes some debugging
+		    // techniques harder. Instead, if `scheduledHostCallback` errors, then
+		    // `hasMoreWork` will remain true, and we'll continue the work loop.
+
+		    var hasMoreWork = true;
+
+		    try {
+		      hasMoreWork = scheduledHostCallback(hasTimeRemaining, currentTime);
+		    } finally {
+		      if (hasMoreWork) {
+		        // If there's more work, schedule the next message event at the end
+		        // of the preceding one.
+		        schedulePerformWorkUntilDeadline();
+		      } else {
+		        isMessageLoopRunning = false;
+		        scheduledHostCallback = null;
+		      }
+		    }
+		  } else {
+		    isMessageLoopRunning = false;
+		  } // Yielding to the browser will give it a chance to paint, so we can
+		};
+
+		var schedulePerformWorkUntilDeadline;
+
+		if (typeof localSetImmediate === 'function') {
+		  // Node.js and old IE.
+		  // There's a few reasons for why we prefer setImmediate.
+		  //
+		  // Unlike MessageChannel, it doesn't prevent a Node.js process from exiting.
+		  // (Even though this is a DOM fork of the Scheduler, you could get here
+		  // with a mix of Node.js 15+, which has a MessageChannel, and jsdom.)
+		  // https://github.com/facebook/react/issues/20756
+		  //
+		  // But also, it runs earlier which is the semantic we want.
+		  // If other browsers ever implement it, it's better to use it.
+		  // Although both of these would be inferior to native scheduling.
+		  schedulePerformWorkUntilDeadline = function () {
+		    localSetImmediate(performWorkUntilDeadline);
+		  };
+		} else if (typeof MessageChannel !== 'undefined') {
+		  // DOM and Worker environments.
+		  // We prefer MessageChannel because of the 4ms setTimeout clamping.
+		  var channel = new MessageChannel();
+		  var port = channel.port2;
+		  channel.port1.onmessage = performWorkUntilDeadline;
+
+		  schedulePerformWorkUntilDeadline = function () {
+		    port.postMessage(null);
+		  };
+		} else {
+		  // We should only fallback here in non-browser environments.
+		  schedulePerformWorkUntilDeadline = function () {
+		    localSetTimeout(performWorkUntilDeadline, 0);
+		  };
+		}
+
+		function requestHostCallback(callback) {
+		  scheduledHostCallback = callback;
+
+		  if (!isMessageLoopRunning) {
+		    isMessageLoopRunning = true;
+		    schedulePerformWorkUntilDeadline();
+		  }
+		}
+
+		function requestHostTimeout(callback, ms) {
+		  taskTimeoutID = localSetTimeout(function () {
+		    callback(exports.unstable_now());
+		  }, ms);
+		}
+
+		function cancelHostTimeout() {
+		  localClearTimeout(taskTimeoutID);
+		  taskTimeoutID = -1;
+		}
+
+		var unstable_requestPaint = requestPaint;
+		var unstable_Profiling =  null;
+
+		exports.unstable_IdlePriority = IdlePriority;
+		exports.unstable_ImmediatePriority = ImmediatePriority;
+		exports.unstable_LowPriority = LowPriority;
+		exports.unstable_NormalPriority = NormalPriority;
+		exports.unstable_Profiling = unstable_Profiling;
+		exports.unstable_UserBlockingPriority = UserBlockingPriority;
+		exports.unstable_cancelCallback = unstable_cancelCallback;
+		exports.unstable_continueExecution = unstable_continueExecution;
+		exports.unstable_forceFrameRate = forceFrameRate;
+		exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
+		exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode;
+		exports.unstable_next = unstable_next;
+		exports.unstable_pauseExecution = unstable_pauseExecution;
+		exports.unstable_requestPaint = unstable_requestPaint;
+		exports.unstable_runWithPriority = unstable_runWithPriority;
+		exports.unstable_scheduleCallback = unstable_scheduleCallback;
+		exports.unstable_shouldYield = shouldYieldToHost;
+		exports.unstable_wrapCallback = unstable_wrapCallback;
+		          /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+		if (
+		  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
+		  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop ===
+		    'function'
+		) {
+		  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+		}
+		        
+		  })();
+		}
+} (scheduler_development));
+	return scheduler_development;
+}
+
+export { requireScheduler_development as __require };

package/build/esm/node_modules/scheduler/cjs/scheduler.production.min.js

@@ -0,0 +1,33 @@
+import { __exports as scheduler_production_min } from '../../../_virtual/scheduler.production.min.js';
+
+/**
+ * @license React
+ * scheduler.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredScheduler_production_min;
+
+function requireScheduler_production_min () {
+	if (hasRequiredScheduler_production_min) return scheduler_production_min;
+	hasRequiredScheduler_production_min = 1;
+	(function (exports) {
+function f(a,b){var c=a.length;a.push(b);a:for(;0<c;){var d=c-1>>>1,e=a[d];if(0<g(e,b))a[d]=b,a[c]=e,c=d;else break a}}function h(a){return 0===a.length?null:a[0]}function k(a){if(0===a.length)return null;var b=a[0],c=a.pop();if(c!==b){a[0]=c;a:for(var d=0,e=a.length,w=e>>>1;d<w;){var m=2*(d+1)-1,C=a[m],n=m+1,x=a[n];if(0>g(C,c))n<e&&0>g(x,C)?(a[d]=x,a[n]=c,d=n):(a[d]=C,a[m]=c,d=m);else if(n<e&&0>g(x,c))a[d]=x,a[n]=c,d=n;else break a}}return b}
+		function g(a,b){var c=a.sortIndex-b.sortIndex;return 0!==c?c:a.id-b.id}if("object"===typeof performance&&"function"===typeof performance.now){var l=performance;exports.unstable_now=function(){return l.now()};}else {var p=Date,q=p.now();exports.unstable_now=function(){return p.now()-q};}var r=[],t=[],u=1,v=null,y=3,z=!1,A=!1,B=!1,D="function"===typeof setTimeout?setTimeout:null,E="function"===typeof clearTimeout?clearTimeout:null,F="undefined"!==typeof setImmediate?setImmediate:null;
+		"undefined"!==typeof navigator&&void 0!==navigator.scheduling&&void 0!==navigator.scheduling.isInputPending&&navigator.scheduling.isInputPending.bind(navigator.scheduling);function G(a){for(var b=h(t);null!==b;){if(null===b.callback)k(t);else if(b.startTime<=a)k(t),b.sortIndex=b.expirationTime,f(r,b);else break;b=h(t);}}function H(a){B=!1;G(a);if(!A)if(null!==h(r))A=!0,I(J);else {var b=h(t);null!==b&&K(H,b.startTime-a);}}
+		function J(a,b){A=!1;B&&(B=!1,E(L),L=-1);z=!0;var c=y;try{G(b);for(v=h(r);null!==v&&(!(v.expirationTime>b)||a&&!M());){var d=v.callback;if("function"===typeof d){v.callback=null;y=v.priorityLevel;var e=d(v.expirationTime<=b);b=exports.unstable_now();"function"===typeof e?v.callback=e:v===h(r)&&k(r);G(b);}else k(r);v=h(r);}if(null!==v)var w=!0;else {var m=h(t);null!==m&&K(H,m.startTime-b);w=!1;}return w}finally{v=null,y=c,z=!1;}}var N=!1,O=null,L=-1,P=5,Q=-1;
+		function M(){return exports.unstable_now()-Q<P?!1:!0}function R(){if(null!==O){var a=exports.unstable_now();Q=a;var b=!0;try{b=O(!0,a);}finally{b?S():(N=!1,O=null);}}else N=!1;}var S;if("function"===typeof F)S=function(){F(R);};else if("undefined"!==typeof MessageChannel){var T=new MessageChannel,U=T.port2;T.port1.onmessage=R;S=function(){U.postMessage(null);};}else S=function(){D(R,0);};function I(a){O=a;N||(N=!0,S());}function K(a,b){L=D(function(){a(exports.unstable_now());},b);}
+		exports.unstable_IdlePriority=5;exports.unstable_ImmediatePriority=1;exports.unstable_LowPriority=4;exports.unstable_NormalPriority=3;exports.unstable_Profiling=null;exports.unstable_UserBlockingPriority=2;exports.unstable_cancelCallback=function(a){a.callback=null;};exports.unstable_continueExecution=function(){A||z||(A=!0,I(J));};
+		exports.unstable_forceFrameRate=function(a){0>a||125<a?console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported"):P=0<a?Math.floor(1E3/a):5;};exports.unstable_getCurrentPriorityLevel=function(){return y};exports.unstable_getFirstCallbackNode=function(){return h(r)};exports.unstable_next=function(a){switch(y){case 1:case 2:case 3:var b=3;break;default:b=y;}var c=y;y=b;try{return a()}finally{y=c;}};exports.unstable_pauseExecution=function(){};
+		exports.unstable_requestPaint=function(){};exports.unstable_runWithPriority=function(a,b){switch(a){case 1:case 2:case 3:case 4:case 5:break;default:a=3;}var c=y;y=a;try{return b()}finally{y=c;}};
+		exports.unstable_scheduleCallback=function(a,b,c){var d=exports.unstable_now();"object"===typeof c&&null!==c?(c=c.delay,c="number"===typeof c&&0<c?d+c:d):c=d;switch(a){case 1:var e=-1;break;case 2:e=250;break;case 5:e=1073741823;break;case 4:e=1E4;break;default:e=5E3;}e=c+e;a={id:u++,callback:b,priorityLevel:a,startTime:c,expirationTime:e,sortIndex:-1};c>d?(a.sortIndex=c,f(t,a),null===h(r)&&a===h(t)&&(B?(E(L),L=-1):B=!0,K(H,c-d))):(a.sortIndex=e,f(r,a),A||z||(A=!0,I(J)));return a};
+		exports.unstable_shouldYield=M;exports.unstable_wrapCallback=function(a){var b=y;return function(){var c=y;y=b;try{return a.apply(this,arguments)}finally{y=c;}}};
+} (scheduler_production_min));
+	return scheduler_production_min;
+}
+
+export { requireScheduler_production_min as __require };

package/build/esm/node_modules/scheduler/index.js

@@ -0,0 +1,21 @@
+import { s as scheduler } from '../../_virtual/index5.js';
+import { __require as requireScheduler_production_min } from './cjs/scheduler.production.min.js';
+import { __require as requireScheduler_development } from './cjs/scheduler.development.js';
+
+var hasRequiredScheduler;
+
+function requireScheduler () {
+	if (hasRequiredScheduler) return scheduler.exports;
+	hasRequiredScheduler = 1;
+	(function (module) {
+
+		if (process.env.NODE_ENV === 'production') {
+		  module.exports = requireScheduler_production_min();
+		} else {
+		  module.exports = requireScheduler_development();
+		}
+} (scheduler));
+	return scheduler.exports;
+}
+
+export { requireScheduler as __require };