MZC/KnowMathBot/frontend/node_modules/scheduler/cjs/scheduler-unstable_mock.development.js

/**
 * @license React
 * scheduler-unstable_mock.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 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), (scheduledCallback = flushWork);
        else {
          var firstTimer = peek(timerQueue);
          null !== firstTimer &&
            ((currentTime = firstTimer.startTime - currentTime),
            (scheduledTimeout = handleTimeout),
            (timeoutTime = currentMockTime + currentTime));
        }
    }
    function flushWork(hasTimeRemaining, initialTime) {
      isHostCallbackScheduled = !1;
      isHostTimeoutScheduled &&
        ((isHostTimeoutScheduled = !1),
        (scheduledTimeout = null),
        (timeoutTime = -1));
      isPerformingWork = !0;
      var previousPriorityLevel = currentPriorityLevel;
      try {
        a: {
          advanceTimers(initialTime);
          for (
            currentTask = peek(taskQueue);
            null !== currentTask &&
            (!(currentTask.expirationTime > initialTime) ||
              (hasTimeRemaining && !shouldYieldToHost()));

          ) {
            var callback = currentTask.callback;
            if ("function" === typeof callback) {
              currentTask.callback = null;
              currentPriorityLevel = currentTask.priorityLevel;
              var continuationCallback = callback(
                currentTask.expirationTime <= initialTime
              );
              initialTime = currentMockTime;
              if ("function" === typeof continuationCallback) {
                if (
                  ((currentTask.callback = continuationCallback),
                  advanceTimers(initialTime),
                  shouldYieldForPaint)
                ) {
                  var JSCompiler_inline_result = (needsPaint = !0);
                  break a;
                }
              } else
                currentTask === peek(taskQueue) && pop(taskQueue),
                  advanceTimers(initialTime);
            } else pop(taskQueue);
            currentTask = peek(taskQueue);
          }
          if (null !== currentTask) JSCompiler_inline_result = !0;
          else {
            var firstTimer = peek(timerQueue);
            if (null !== firstTimer) {
              var ms = firstTimer.startTime - initialTime;
              scheduledTimeout = handleTimeout;
              timeoutTime = currentMockTime + ms;
            }
            JSCompiler_inline_result = !1;
          }
        }
        return JSCompiler_inline_result;
      } finally {
        (currentTask = null),
          (currentPriorityLevel = previousPriorityLevel),
          (isPerformingWork = !1);
      }
    }
    function shouldYieldToHost() {
      return (0 === expectedNumberOfYields && null === yieldedValues) ||
        (-1 !== expectedNumberOfYields &&
          null !== yieldedValues &&
          yieldedValues.length >= expectedNumberOfYields) ||
        (shouldYieldForPaint && needsPaint)
        ? (didStop = !0)
        : !1;
    }
    function unstable_flushAllWithoutAsserting() {
      if (isFlushing) throw Error("Already flushing work.");
      if (null !== scheduledCallback) {
        var cb = scheduledCallback;
        isFlushing = !0;
        try {
          var hasMoreWork = !0;
          do hasMoreWork = cb(!0, currentMockTime);
          while (hasMoreWork);
          hasMoreWork || (scheduledCallback = null);
          return !0;
        } finally {
          isFlushing = !1;
        }
      } else return !1;
    }
    var taskQueue = [],
      timerQueue = [],
      taskIdCounter = 1,
      currentTask = null,
      currentPriorityLevel = 3,
      isPerformingWork = !1,
      isHostCallbackScheduled = !1,
      isHostTimeoutScheduled = !1,
      currentMockTime = 0,
      scheduledCallback = null,
      scheduledTimeout = null,
      timeoutTime = -1,
      yieldedValues = null,
      expectedNumberOfYields = -1,
      didStop = !1,
      isFlushing = !1,
      needsPaint = !1,
      shouldYieldForPaint = !1,
      disableYieldValue = !1;
    exports.log = function (value) {
      "disabledLog" === console.log.name ||
        disableYieldValue ||
        (null === yieldedValues
          ? (yieldedValues = [value])
          : yieldedValues.push(value));
    };
    exports.reset = function () {
      if (isFlushing) throw Error("Cannot reset while already flushing work.");
      currentMockTime = 0;
      scheduledTimeout = scheduledCallback = null;
      timeoutTime = -1;
      yieldedValues = null;
      expectedNumberOfYields = -1;
      needsPaint = isFlushing = didStop = !1;
    };
    exports.unstable_IdlePriority = 5;
    exports.unstable_ImmediatePriority = 1;
    exports.unstable_LowPriority = 4;
    exports.unstable_NormalPriority = 3;
    exports.unstable_Profiling = null;
    exports.unstable_UserBlockingPriority = 2;
    exports.unstable_advanceTime = function (ms) {
      "disabledLog" === console.log.name ||
        disableYieldValue ||
        ((currentMockTime += ms),
        null !== scheduledTimeout &&
          timeoutTime <= currentMockTime &&
          (scheduledTimeout(currentMockTime),
          (timeoutTime = -1),
          (scheduledTimeout = null)));
    };
    exports.unstable_cancelCallback = function (task) {
      task.callback = null;
    };
    exports.unstable_clearLog = function () {
      if (null === yieldedValues) return [];
      var values = yieldedValues;
      yieldedValues = null;
      return values;
    };
    exports.unstable_flushAll = function () {
      if (null !== yieldedValues)
        throw Error(
          "Log is not empty. Assert on the log of yielded values before flushing additional work."
        );
      unstable_flushAllWithoutAsserting();
      if (null !== yieldedValues)
        throw Error(
          "While flushing work, something yielded a value. Use an assertion helper to assert on the log of yielded values, e.g. expect(Scheduler).toFlushAndYield([...])"
        );
    };
    exports.unstable_flushAllWithoutAsserting =
      unstable_flushAllWithoutAsserting;
    exports.unstable_flushExpired = function () {
      if (isFlushing) throw Error("Already flushing work.");
      if (null !== scheduledCallback) {
        isFlushing = !0;
        try {
          scheduledCallback(!1, currentMockTime) || (scheduledCallback = null);
        } finally {
          isFlushing = !1;
        }
      }
    };
    exports.unstable_flushNumberOfYields = function (count) {
      if (isFlushing) throw Error("Already flushing work.");
      if (null !== scheduledCallback) {
        var cb = scheduledCallback;
        expectedNumberOfYields = count;
        isFlushing = !0;
        try {
          count = !0;
          do count = cb(!0, currentMockTime);
          while (count && !didStop);
          count || (scheduledCallback = null);
        } finally {
          (expectedNumberOfYields = -1), (isFlushing = didStop = !1);
        }
      }
    };
    exports.unstable_flushUntilNextPaint = function () {
      if (isFlushing) throw Error("Already flushing work.");
      if (null !== scheduledCallback) {
        var cb = scheduledCallback;
        shouldYieldForPaint = !0;
        needsPaint = !1;
        isFlushing = !0;
        try {
          var hasMoreWork = !0;
          do hasMoreWork = cb(!0, currentMockTime);
          while (hasMoreWork && !didStop);
          hasMoreWork || (scheduledCallback = null);
        } finally {
          isFlushing = didStop = shouldYieldForPaint = !1;
        }
      }
      return !1;
    };
    exports.unstable_forceFrameRate = function () {};
    exports.unstable_getCurrentPriorityLevel = function () {
      return currentPriorityLevel;
    };
    exports.unstable_hasPendingWork = function () {
      return null !== scheduledCallback;
    };
    exports.unstable_next = function (eventHandler) {
      switch (currentPriorityLevel) {
        case 1:
        case 2:
        case 3:
          var priorityLevel = 3;
          break;
        default:
          priorityLevel = currentPriorityLevel;
      }
      var previousPriorityLevel = currentPriorityLevel;
      currentPriorityLevel = priorityLevel;
      try {
        return eventHandler();
      } finally {
        currentPriorityLevel = previousPriorityLevel;
      }
    };
    exports.unstable_now = function () {
      return currentMockTime;
    };
    exports.unstable_requestPaint = function () {
      needsPaint = !0;
    };
    exports.unstable_runWithPriority = function (priorityLevel, eventHandler) {
      switch (priorityLevel) {
        case 1:
        case 2:
        case 3:
        case 4:
        case 5:
          break;
        default:
          priorityLevel = 3;
      }
      var previousPriorityLevel = currentPriorityLevel;
      currentPriorityLevel = priorityLevel;
      try {
        return eventHandler();
      } finally {
        currentPriorityLevel = previousPriorityLevel;
      }
    };
    exports.unstable_scheduleCallback = function (
      priorityLevel,
      callback,
      options
    ) {
      var currentTime = currentMockTime;
      "object" === typeof options && null !== options
        ? ((options = options.delay),
          (options =
            "number" === typeof options && 0 < options
              ? currentTime + options
              : currentTime))
        : (options = currentTime);
      switch (priorityLevel) {
        case 1:
          var timeout = -1;
          break;
        case 2:
          timeout = 250;
          break;
        case 5:
          timeout = 1073741823;
          break;
        case 4:
          timeout = 1e4;
          break;
        default:
          timeout = 5e3;
      }
      timeout = options + timeout;
      priorityLevel = {
        id: taskIdCounter++,
        callback: callback,
        priorityLevel: priorityLevel,
        startTime: options,
        expirationTime: timeout,
        sortIndex: -1
      };
      options > currentTime
        ? ((priorityLevel.sortIndex = options),
          push(timerQueue, priorityLevel),
          null === peek(taskQueue) &&
            priorityLevel === peek(timerQueue) &&
            (isHostTimeoutScheduled
              ? ((scheduledTimeout = null), (timeoutTime = -1))
              : (isHostTimeoutScheduled = !0),
            (scheduledTimeout = handleTimeout),
            (timeoutTime = currentMockTime + (options - currentTime))))
        : ((priorityLevel.sortIndex = timeout),
          push(taskQueue, priorityLevel),
          isHostCallbackScheduled ||
            isPerformingWork ||
            ((isHostCallbackScheduled = !0), (scheduledCallback = flushWork)));
      return priorityLevel;
    };
    exports.unstable_setDisableYieldValue = function (newValue) {
      disableYieldValue = newValue;
    };
    exports.unstable_shouldYield = shouldYieldToHost;
    exports.unstable_wrapCallback = function (callback) {
      var parentPriorityLevel = currentPriorityLevel;
      return function () {
        var previousPriorityLevel = currentPriorityLevel;
        currentPriorityLevel = parentPriorityLevel;
        try {
          return callback.apply(this, arguments);
        } finally {
          currentPriorityLevel = previousPriorityLevel;
        }
      };
    };
  })();