Index: node_modules/scheduler/cjs/scheduler.native.development.js
===================================================================
--- node_modules/scheduler/cjs/scheduler.native.development.js	(revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/scheduler/cjs/scheduler.native.development.js	(revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,350 @@
+/**
+ * @license React
+ * scheduler.native.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+"use strict";
+"production" !== process.env.NODE_ENV &&
+  (function () {
+    function performWorkUntilDeadline() {
+      needsPaint = !1;
+      if (isMessageLoopRunning) {
+        var currentTime = getCurrentTime();
+        startTime = currentTime;
+        var hasMoreWork = !0;
+        try {
+          a: {
+            isHostCallbackScheduled = !1;
+            isHostTimeoutScheduled &&
+              ((isHostTimeoutScheduled = !1),
+              localClearTimeout(taskTimeoutID),
+              (taskTimeoutID = -1));
+            isPerformingWork = !0;
+            var previousPriorityLevel = currentPriorityLevel;
+            try {
+              b: {
+                advanceTimers(currentTime);
+                for (
+                  currentTask = peek(taskQueue);
+                  null !== currentTask &&
+                  !(
+                    currentTask.expirationTime > currentTime &&
+                    shouldYieldToHost()
+                  );
+
+                ) {
+                  var callback = currentTask.callback;
+                  if ("function" === typeof callback) {
+                    currentTask.callback = null;
+                    currentPriorityLevel = currentTask.priorityLevel;
+                    var continuationCallback = callback(
+                      currentTask.expirationTime <= currentTime
+                    );
+                    currentTime = getCurrentTime();
+                    if ("function" === typeof continuationCallback) {
+                      currentTask.callback = continuationCallback;
+                      advanceTimers(currentTime);
+                      hasMoreWork = !0;
+                      break b;
+                    }
+                    currentTask === peek(taskQueue) && pop(taskQueue);
+                    advanceTimers(currentTime);
+                  } else pop(taskQueue);
+                  currentTask = peek(taskQueue);
+                }
+                if (null !== currentTask) hasMoreWork = !0;
+                else {
+                  var firstTimer = peek(timerQueue);
+                  null !== firstTimer &&
+                    requestHostTimeout(
+                      handleTimeout,
+                      firstTimer.startTime - currentTime
+                    );
+                  hasMoreWork = !1;
+                }
+              }
+              break a;
+            } finally {
+              (currentTask = null),
+                (currentPriorityLevel = previousPriorityLevel),
+                (isPerformingWork = !1);
+            }
+            hasMoreWork = void 0;
+          }
+        } finally {
+          hasMoreWork
+            ? schedulePerformWorkUntilDeadline()
+            : (isMessageLoopRunning = !1);
+        }
+      }
+    }
+    function push(heap, node) {
+      var index = heap.length;
+      heap.push(node);
+      a: for (; 0 < index; ) {
+        var parentIndex = (index - 1) >>> 1,
+          parent = heap[parentIndex];
+        if (0 < compare(parent, node))
+          (heap[parentIndex] = node),
+            (heap[index] = parent),
+            (index = parentIndex);
+        else break a;
+      }
+    }
+    function peek(heap) {
+      return 0 === heap.length ? null : heap[0];
+    }
+    function pop(heap) {
+      if (0 === heap.length) return null;
+      var first = heap[0],
+        last = heap.pop();
+      if (last !== first) {
+        heap[0] = last;
+        a: for (
+          var index = 0, length = heap.length, halfLength = length >>> 1;
+          index < halfLength;
+
+        ) {
+          var leftIndex = 2 * (index + 1) - 1,
+            left = heap[leftIndex],
+            rightIndex = leftIndex + 1,
+            right = heap[rightIndex];
+          if (0 > compare(left, last))
+            rightIndex < length && 0 > compare(right, left)
+              ? ((heap[index] = right),
+                (heap[rightIndex] = last),
+                (index = rightIndex))
+              : ((heap[index] = left),
+                (heap[leftIndex] = last),
+                (index = leftIndex));
+          else if (rightIndex < length && 0 > compare(right, last))
+            (heap[index] = right),
+              (heap[rightIndex] = last),
+              (index = rightIndex);
+          else break a;
+        }
+      }
+      return first;
+    }
+    function compare(a, b) {
+      var diff = a.sortIndex - b.sortIndex;
+      return 0 !== diff ? diff : a.id - b.id;
+    }
+    function advanceTimers(currentTime) {
+      for (var timer = peek(timerQueue); null !== timer; ) {
+        if (null === timer.callback) pop(timerQueue);
+        else if (timer.startTime <= currentTime)
+          pop(timerQueue),
+            (timer.sortIndex = timer.expirationTime),
+            push(taskQueue, timer);
+        else break;
+        timer = peek(timerQueue);
+      }
+    }
+    function handleTimeout(currentTime) {
+      isHostTimeoutScheduled = !1;
+      advanceTimers(currentTime);
+      if (!isHostCallbackScheduled)
+        if (null !== peek(taskQueue))
+          (isHostCallbackScheduled = !0),
+            isMessageLoopRunning ||
+              ((isMessageLoopRunning = !0), schedulePerformWorkUntilDeadline());
+        else {
+          var firstTimer = peek(timerQueue);
+          null !== firstTimer &&
+            requestHostTimeout(
+              handleTimeout,
+              firstTimer.startTime - currentTime
+            );
+        }
+    }
+    function unstable_scheduleCallback$1(priorityLevel, callback, options) {
+      var currentTime = getCurrentTime();
+      "object" === typeof options && null !== options
+        ? ((options = options.delay),
+          (options =
+            "number" === typeof options && 0 < options
+              ? currentTime + options
+              : currentTime))
+        : (options = currentTime);
+      switch (priorityLevel) {
+        case 1:
+          var timeout = -1;
+          break;
+        case 2:
+          timeout = 250;
+          break;
+        case 5:
+          timeout = 1073741823;
+          break;
+        case 4:
+          timeout = 1e4;
+          break;
+        default:
+          timeout = 5e3;
+      }
+      timeout = options + timeout;
+      priorityLevel = {
+        id: taskIdCounter++,
+        callback: callback,
+        priorityLevel: priorityLevel,
+        startTime: options,
+        expirationTime: timeout,
+        sortIndex: -1
+      };
+      options > currentTime
+        ? ((priorityLevel.sortIndex = options),
+          push(timerQueue, priorityLevel),
+          null === peek(taskQueue) &&
+            priorityLevel === peek(timerQueue) &&
+            (isHostTimeoutScheduled
+              ? (localClearTimeout(taskTimeoutID), (taskTimeoutID = -1))
+              : (isHostTimeoutScheduled = !0),
+            requestHostTimeout(handleTimeout, options - currentTime)))
+        : ((priorityLevel.sortIndex = timeout),
+          push(taskQueue, priorityLevel),
+          isHostCallbackScheduled ||
+            isPerformingWork ||
+            ((isHostCallbackScheduled = !0),
+            isMessageLoopRunning ||
+              ((isMessageLoopRunning = !0),
+              schedulePerformWorkUntilDeadline())));
+      return priorityLevel;
+    }
+    function unstable_cancelCallback$1(task) {
+      task.callback = null;
+    }
+    function unstable_getCurrentPriorityLevel$1() {
+      return currentPriorityLevel;
+    }
+    function shouldYieldToHost() {
+      return needsPaint
+        ? !0
+        : getCurrentTime() - startTime < frameInterval
+          ? !1
+          : !0;
+    }
+    function requestPaint() {
+      needsPaint = !0;
+    }
+    function requestHostTimeout(callback, ms) {
+      taskTimeoutID = localSetTimeout(function () {
+        callback(getCurrentTime());
+      }, ms);
+    }
+    function throwNotImplemented() {
+      throw Error("Not implemented.");
+    }
+    if (
+      "object" === typeof performance &&
+      "function" === typeof performance.now
+    ) {
+      var localPerformance = performance;
+      var getCurrentTime = function () {
+        return localPerformance.now();
+      };
+    } else {
+      var localDate = Date,
+        initialTime = localDate.now();
+      getCurrentTime = function () {
+        return localDate.now() - initialTime;
+      };
+    }
+    var taskQueue = [],
+      timerQueue = [],
+      taskIdCounter = 1,
+      currentTask = null,
+      currentPriorityLevel = 3,
+      isPerformingWork = !1,
+      isHostCallbackScheduled = !1,
+      isHostTimeoutScheduled = !1,
+      needsPaint = !1,
+      localSetTimeout = "function" === typeof setTimeout ? setTimeout : null,
+      localClearTimeout =
+        "function" === typeof clearTimeout ? clearTimeout : null,
+      localSetImmediate =
+        "undefined" !== typeof setImmediate ? setImmediate : null,
+      isMessageLoopRunning = !1,
+      taskTimeoutID = -1,
+      frameInterval = 5,
+      startTime = -1;
+    if ("function" === typeof localSetImmediate)
+      var schedulePerformWorkUntilDeadline = function () {
+        localSetImmediate(performWorkUntilDeadline);
+      };
+    else if ("undefined" !== typeof MessageChannel) {
+      var channel = new MessageChannel(),
+        port = channel.port2;
+      channel.port1.onmessage = performWorkUntilDeadline;
+      schedulePerformWorkUntilDeadline = function () {
+        port.postMessage(null);
+      };
+    } else
+      schedulePerformWorkUntilDeadline = function () {
+        localSetTimeout(performWorkUntilDeadline, 0);
+      };
+    channel =
+      "undefined" !== typeof nativeRuntimeScheduler
+        ? nativeRuntimeScheduler.unstable_UserBlockingPriority
+        : 2;
+    var unstable_NormalPriority =
+        "undefined" !== typeof nativeRuntimeScheduler
+          ? nativeRuntimeScheduler.unstable_NormalPriority
+          : 3,
+      unstable_LowPriority =
+        "undefined" !== typeof nativeRuntimeScheduler
+          ? nativeRuntimeScheduler.unstable_LowPriority
+          : 4,
+      unstable_ImmediatePriority =
+        "undefined" !== typeof nativeRuntimeScheduler
+          ? nativeRuntimeScheduler.unstable_ImmediatePriority
+          : 1,
+      unstable_scheduleCallback =
+        "undefined" !== typeof nativeRuntimeScheduler
+          ? nativeRuntimeScheduler.unstable_scheduleCallback
+          : unstable_scheduleCallback$1,
+      unstable_cancelCallback =
+        "undefined" !== typeof nativeRuntimeScheduler
+          ? nativeRuntimeScheduler.unstable_cancelCallback
+          : unstable_cancelCallback$1,
+      unstable_getCurrentPriorityLevel =
+        "undefined" !== typeof nativeRuntimeScheduler
+          ? nativeRuntimeScheduler.unstable_getCurrentPriorityLevel
+          : unstable_getCurrentPriorityLevel$1,
+      unstable_shouldYield =
+        "undefined" !== typeof nativeRuntimeScheduler
+          ? nativeRuntimeScheduler.unstable_shouldYield
+          : shouldYieldToHost,
+      unstable_requestPaint =
+        "undefined" !== typeof nativeRuntimeScheduler
+          ? nativeRuntimeScheduler.unstable_requestPaint
+          : requestPaint,
+      unstable_now =
+        "undefined" !== typeof nativeRuntimeScheduler
+          ? nativeRuntimeScheduler.unstable_now
+          : getCurrentTime;
+    exports.unstable_IdlePriority =
+      "undefined" !== typeof nativeRuntimeScheduler
+        ? nativeRuntimeScheduler.unstable_IdlePriority
+        : 5;
+    exports.unstable_ImmediatePriority = unstable_ImmediatePriority;
+    exports.unstable_LowPriority = unstable_LowPriority;
+    exports.unstable_NormalPriority = unstable_NormalPriority;
+    exports.unstable_Profiling = null;
+    exports.unstable_UserBlockingPriority = channel;
+    exports.unstable_cancelCallback = unstable_cancelCallback;
+    exports.unstable_forceFrameRate = throwNotImplemented;
+    exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
+    exports.unstable_next = throwNotImplemented;
+    exports.unstable_now = unstable_now;
+    exports.unstable_requestPaint = unstable_requestPaint;
+    exports.unstable_runWithPriority = throwNotImplemented;
+    exports.unstable_scheduleCallback = unstable_scheduleCallback;
+    exports.unstable_shouldYield = unstable_shouldYield;
+    exports.unstable_wrapCallback = throwNotImplemented;
+  })();