@amazon-devices/react-native-worklets 1.0.0-rn-83

package/src/initializers.ts

@@ -0,0 +1,262 @@
+'use strict';
+
+import { bundleValueUnpacker } from './bundleUnpacker';
+import { setupCallGuard } from './callGuard';
+import { registerReportFatalRemoteError } from './errors';
+import { IS_JEST, SHOULD_BE_USE_WEB } from './PlatformChecker';
+import { setupSetImmediate } from './runLoop/common/setImmediatePolyfill';
+import { setupSetInterval } from './runLoop/common/setIntervalPolyfill';
+import { mockedRequestAnimationFrame } from './runLoop/uiRuntime/mockedRequestAnimationFrame';
+import { setupRequestAnimationFrame } from './runLoop/uiRuntime/requestAnimationFrame';
+import { setupSetTimeout } from './runLoop/uiRuntime/setTimeoutPolyfill';
+import { RuntimeKind } from './runtimeKind';
+import { __installUnpacker as installSynchronizableUnpacker } from './synchronizableUnpacker';
+import { executeOnUIRuntimeSync, runOnJS, setupMicrotasks } from './threads';
+import { isWorkletFunction } from './workletFunction';
+import { registerWorkletsError, WorkletsError } from './WorkletsError';
+import { WorkletsModule } from './WorkletsModule';
+import type { ValueUnpacker } from './workletTypes';
+
+let capturableConsole: typeof console;
+
+/**
+ * Currently there seems to be a bug in the JSI layer which causes a crash when
+ * we try to copy some of the console methods, i.e. `clear` or `dirxml`.
+ *
+ * The crash happens only in React Native 0.75. It's not reproducible in neither
+ * 0.76 nor 0.74. It also happens only in the configuration of a debug app and
+ * production bundle.
+ *
+ * I haven't yet discovered what exactly causes the crash. It's tied to the
+ * console methods sometimes being `HostFunction`s. Therefore, as a workaround
+ * we don't copy the methods as they are in the original console object, we copy
+ * JavaScript wrappers instead.
+ */
+export function getMemorySafeCapturableConsole(): typeof console {
+  if (capturableConsole) {
+    return capturableConsole;
+  }
+
+  const consoleCopy = Object.fromEntries(
+    Object.entries(console).map(([methodName, method]) => {
+      const methodWrapper = function methodWrapper(...args: unknown[]) {
+        return method(...args);
+      };
+      if (method.name) {
+        /**
+         * Set the original method name as the wrapper name if available.
+         *
+         * It might be unnecessary but if we want to fully mimic the console
+         * object we should take into the account the fact some code might rely
+         * on the method name.
+         */
+        Object.defineProperty(methodWrapper, 'name', {
+          value: method.name,
+          writable: false,
+        });
+      }
+      return [methodName, methodWrapper];
+    })
+  );
+
+  capturableConsole = consoleCopy as unknown as typeof console;
+
+  return consoleCopy as unknown as typeof console;
+}
+
+export function setupConsole(boundCapturableConsole: typeof console) {
+  'worklet';
+  // @ts-ignore TypeScript doesn't like that there are missing methods in console object, but we don't provide all the methods for the UI runtime console version
+  globalThis.console = {
+    assert: runOnJS(boundCapturableConsole.assert),
+    debug: runOnJS(boundCapturableConsole.debug),
+    log: runOnJS(boundCapturableConsole.log),
+    warn: runOnJS(boundCapturableConsole.warn),
+    error: runOnJS(boundCapturableConsole.error),
+    info: runOnJS(boundCapturableConsole.info),
+  };
+}
+
+let initialized = false;
+
+export function init() {
+  if (initialized) {
+    return;
+  }
+  initialized = true;
+
+  if (globalThis.__RUNTIME_KIND === undefined) {
+    // The only runtime that doesn't have `__RUNTIME_KIND` preconfigured
+    // is the RN Runtime. We must set it as soon as possible.
+    globalThis.__RUNTIME_KIND = RuntimeKind.ReactNative;
+  }
+
+  initializeRuntime();
+
+  if (SHOULD_BE_USE_WEB) {
+    initializeRuntimeOnWeb();
+  }
+
+  if (globalThis.__RUNTIME_KIND !== RuntimeKind.ReactNative) {
+    initializeWorkletRuntime();
+  } else {
+    initializeRNRuntime();
+    if (!SHOULD_BE_USE_WEB) {
+      installRNBindingsOnUIRuntime();
+    }
+  }
+}
+
+/** A function that should be run on any kind of runtime. */
+function initializeRuntime() {
+  if (globalThis._WORKLETS_BUNDLE_MODE) {
+    globalThis.__valueUnpacker = bundleValueUnpacker as ValueUnpacker;
+  }
+  installSynchronizableUnpacker();
+}
+
+/** A function that should be run only on React Native runtime. */
+function initializeRNRuntime() {
+  if (__DEV__) {
+    const testWorklet = () => {
+      'worklet';
+    };
+    if (!isWorkletFunction(testWorklet)) {
+      throw new WorkletsError(
+        `Failed to create a worklet. See https://docs.swmansion.com/react-native-reanimated/docs/guides/troubleshooting#failed-to-create-a-worklet for more details.`
+      );
+    }
+  }
+
+  registerReportFatalRemoteError();
+}
+
+/** A function that should be run only on Worklet runtimes. */
+function initializeWorkletRuntime() {
+  if (globalThis._WORKLETS_BUNDLE_MODE) {
+    setupCallGuard();
+
+    if (__DEV__) {
+      /*
+       * Temporary workaround for Metro bundler. We must implement a dummy
+       * Refresh module to prevent Metro from throwing irrelevant errors.
+       */
+      const Refresh = new Proxy(
+        {},
+        {
+          get() {
+            return () => {};
+          },
+        }
+      );
+
+      globalThis.__r.Refresh = Refresh;
+
+      /* Gracefully handle unwanted imports from React Native. */
+      // @ts-expect-error type not exposed by Metro
+      const modules = require.getModules();
+      // @ts-expect-error type not exposed by Metro
+      const ReactNativeModuleId = require.resolveWeak('react-native');
+
+      const factory = function (
+        _global: unknown,
+        _require: unknown,
+        _importDefault: unknown,
+        _importAll: unknown,
+        module: Record<string, unknown>,
+        _exports: unknown,
+        _dependencyMap: unknown
+      ) {
+        module.exports = new Proxy(
+          {},
+          {
+            get: function get(_target, prop) {
+              globalThis.console.warn(
+                `You tried to import '${String(prop)}' from 'react-native' module on a Worklet Runtime. Using 'react-native' module on a Worklet Runtime is not allowed.`
+              );
+              return {
+                get() {
+                  return undefined;
+                },
+              };
+            },
+          }
+        );
+      };
+
+      const mod = {
+        dependencyMap: [],
+        factory,
+        hasError: false,
+        importedAll: {},
+        importedDefault: {},
+        isInitialized: false,
+        publicModule: {
+          exports: {},
+        },
+      };
+
+      modules.set(ReactNativeModuleId, mod);
+    }
+  }
+}
+
+/** A function that should be run only on RN Runtime in web implementation. */
+function initializeRuntimeOnWeb() {
+  globalThis._WORKLET = false;
+  globalThis._log = console.log;
+  globalThis._getAnimationTimestamp = () => performance.now();
+  if (IS_JEST) {
+    // requestAnimationFrame react-native jest's setup is incorrect as it polyfills
+    // the method directly using setTimeout, therefore the callback doesn't get the
+    // expected timestamp as the only argument: https://github.com/facebook/react-native/blob/main/packages/react-native/jest/setup.js#L28
+    // We override this setup here to make sure that callbacks get the proper timestamps
+    // when executed. For non-jest environments we define requestAnimationFrame in setupRequestAnimationFrame
+    // @ts-ignore TypeScript uses Node definition for rAF, setTimeout, etc which returns a Timeout object rather than a number
+    globalThis.requestAnimationFrame = mockedRequestAnimationFrame;
+  }
+}
+
+/**
+ * A function that should be run on the RN Runtime to configure the UI Runtime
+ * with callback bindings.
+ */
+function installRNBindingsOnUIRuntime() {
+  if (!WorkletsModule) {
+    throw new WorkletsError(
+      'Worklets are trying to initialize the UI runtime without a valid WorkletsModule'
+    );
+  }
+
+  const runtimeBoundCapturableConsole = getMemorySafeCapturableConsole();
+
+  if (!globalThis._WORKLETS_BUNDLE_MODE) {
+    /** In bundle mode Runtimes setup their callGuard themselves. */
+    executeOnUIRuntimeSync(setupCallGuard)();
+
+    /**
+     * Register WorkletsError in the UI runtime global scope. (we are using
+     * `executeOnUIRuntimeSync` here to make sure that the changes are applied
+     * before any async operations are executed on the UI runtime).
+     *
+     * There's no need to register the error in bundle mode.
+     */
+    executeOnUIRuntimeSync(registerWorkletsError)();
+  }
+
+  executeOnUIRuntimeSync(() => {
+    'worklet';
+
+    setupConsole(runtimeBoundCapturableConsole);
+    /**
+     * TODO: Move `setupMicrotasks` and `setupRequestAnimationFrame` to a
+     * separate function once we have a better way to distinguish between
+     * Worklet Runtimes.
+     */
+    setupMicrotasks();
+    setupRequestAnimationFrame();
+    setupSetTimeout();
+    setupSetImmediate();
+    setupSetInterval();
+  })();
+}

package/src/isSynchronizable.ts

@@ -0,0 +1,13 @@
+'use strict';
+import type { Synchronizable } from './synchronizable';
+
+export function isSynchronizable<TValue>(
+  value: unknown
+): value is Synchronizable<TValue> {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    '__synchronizableRef' in value &&
+    value.__synchronizableRef === true
+  );
+}

package/src/logger.ts

@@ -0,0 +1,16 @@
+'use strict';
+
+const PREFIX = '[Worklets]';
+
+function formatMessage(message: string) {
+  return `${PREFIX} ${message}`;
+}
+
+export const logger = {
+  warn(message: string) {
+    console.warn(formatMessage(message));
+  },
+  error(message: string) {
+    console.error(formatMessage(message));
+  },
+};

package/src/privateGlobals.d.ts

@@ -0,0 +1,79 @@
+/* eslint-disable reanimated/use-global-this */
+'use strict';
+
+// This file works by accident - currently Builder Bob doesn't move `.d.ts` files to output types.
+// If it ever breaks, we should address it so we'd not pollute the user's global namespace.
+import type { callGuardDEV } from './callGuard';
+import type { reportFatalRemoteError } from './errors';
+import type { Queue } from './runLoop/workletRuntime/taskQueue';
+import type { SynchronizableUnpacker } from './synchronizableUnpacker';
+import type { IWorkletsErrorConstructor } from './WorkletsError';
+import type { WorkletsModuleProxy } from './WorkletsModule';
+import type { ValueUnpacker } from './workletTypes';
+
+declare global {
+  /** The only runtime-available require method is `__r` defined by Metro. */
+  var __r: ((moduleId: number) => Record<string, unknown>) &
+    Record<string, unknown>;
+
+  var _toString: (value: unknown) => string;
+  var __workletsModuleProxy: WorkletsModuleProxy | undefined;
+  var _WORKLETS_BUNDLE_MODE: boolean | undefined;
+  var _WORKLETS_VERSION_CPP: string | undefined;
+  var _WORKLETS_VERSION_JS: string | undefined;
+  var _createSerializable: <T>(
+    value: T,
+    nativeStateSource?: object
+  ) => FlatSerializableRef<T>;
+  var _createSerializableString: (value: string) => FlatSerializableRef<string>;
+  var _createSerializableNumber: (value: number) => FlatSerializableRef<number>;
+  var _createSerializableBoolean: (
+    value: boolean
+  ) => FlatSerializableRef<boolean>;
+  var _createSerializableBigInt: (value: bigint) => FlatSerializableRef<bigint>;
+  var _createSerializableUndefined: () => FlatSerializableRef<undefined>;
+  var _createSerializableNull: () => FlatSerializableRef<null>;
+  var _createSerializableObject: <T extends object>(
+    value: T,
+    shouldRetainRemote: boolean,
+    nativeStateSource?: object
+  ) => FlatSerializableRef<T>;
+  var _createSerializableHostObject: <T extends object>(
+    value: T
+  ) => FlatSerializableRef<T>;
+  var _createSerializableWorklet: (
+    value: object,
+    shouldPersistRemote: boolean
+  ) => FlatSerializableRef<object>;
+  var _createSerializableArray: (
+    value: unknown[]
+  ) => FlatSerializableRef<unknown[]>;
+  var _createSerializableInitializer: (
+    value: object
+  ) => FlatSerializableRef<object>;
+  var _createSerializableSynchronizable: (
+    value: object
+  ) => FlatShareableRef<object>;
+  var __callMicrotasks: () => void;
+  var _scheduleHostFunctionOnJS: (fun: (...args: A) => R, args?: A) => void;
+  var _scheduleRemoteFunctionOnJS: (fun: (...args: A) => R, args?: A) => void;
+  /** Available only on RN Runtime */
+  var __reportFatalRemoteError: typeof reportFatalRemoteError | undefined;
+  var __valueUnpacker: ValueUnpacker;
+  var __synchronizableUnpacker: SynchronizableUnpacker;
+  var __callGuardDEV: typeof callGuardDEV | undefined;
+  var __flushAnimationFrame: (timestamp: number) => void;
+  var __frameTimestamp: number | undefined;
+  var _log: (value: unknown) => void;
+  var _getAnimationTimestamp: () => number;
+  var _scheduleOnRuntime: (
+    runtime: WorkletRuntime,
+    worklet: SerializableRef<() => void>
+  ) => void;
+  var _microtaskQueueFinalizers: (() => void)[];
+  var WorkletsError: IWorkletsErrorConstructor;
+  var _scheduleTimeoutCallback: (delay: number, handlerId: number) => void;
+  var __runTimeoutCallback: (handlerId: number) => void;
+  var __flushMicrotasks: () => void;
+  var _taskQueue: Queue;
+}

package/src/publicGlobals.ts

@@ -0,0 +1,39 @@
+'use strict';
+/* eslint-disable reanimated/use-global-this */
+import type { RuntimeKind } from './runtimeKind';
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import { getRuntimeKind } from './runtimeKind';
+
+export {};
+
+declare global {
+  /**
+   * @deprecated Use {@link __RUNTIME_KIND} instead.
+   *
+   *   This global variable is a diagnostic/development tool.
+   *
+   *   It's `true` on Worklet Runtimes and `false` on React Native Runtime.
+   */
+  var _WORKLET: boolean | undefined;
+
+  /**
+   * This ArrayBuffer contains the memory address of `jsi::Runtime` which is the
+   * Reanimated UI runtime.
+   */
+  var _WORKLET_RUNTIME: ArrayBuffer;
+
+  /** @deprecated Don't use. */
+  var _IS_FABRIC: boolean | undefined;
+
+  /**
+   * This global variable is used to determine the kind of the current runtime.
+   * You can use it directly to differentiate between runtimes. However, the
+   * recommended way for differentiating is to use the {@link getRuntimeKind}
+   * function.
+   *
+   * - Value _1_: React Native Runtime
+   * - Value _2_: UI Worklet Runtime
+   * - Value _3_: Worker Worklet Runtime
+   */
+  var __RUNTIME_KIND: RuntimeKind | 1 | 2 | 3;
+}

package/src/runLoop/common/setImmediatePolyfill.ts

@@ -0,0 +1,20 @@
+'use strict';
+
+export function setupSetImmediate() {
+  'worklet';
+
+  const setImmediatePolyfill = (
+    callback: (...args: unknown[]) => void,
+    ...args: unknown[]
+  ) => {
+    return setTimeout(callback, 0, ...args);
+  };
+
+  const clearImmediatePolyfill = (immediateHandle: number) => {
+    clearTimeout(immediateHandle);
+  };
+
+  globalThis.setImmediate =
+    setImmediatePolyfill as unknown as typeof setImmediate;
+  globalThis.clearImmediate = clearImmediatePolyfill as typeof clearImmediate;
+}

package/src/runLoop/common/setIntervalPolyfill.ts

@@ -0,0 +1,38 @@
+'use strict';
+
+export function setupSetInterval() {
+  'worklet';
+
+  const intervalHandleToTimeoutHandle: Map<number, number> = new Map();
+
+  const setIntervalPolyfill = (
+    callback: (...args: unknown[]) => void,
+    delay: number = 0,
+    ...args: unknown[]
+  ) => {
+    let intervalHandle = 0;
+
+    const repeatingCallback = () => {
+      const timeoutHandle = setTimeout(
+        repeatingCallback,
+        delay
+      ) as unknown as number;
+      intervalHandleToTimeoutHandle.set(intervalHandle, timeoutHandle);
+      callback(...args);
+    };
+
+    intervalHandle = setTimeout(repeatingCallback, delay) as unknown as number;
+    intervalHandleToTimeoutHandle.set(intervalHandle, intervalHandle);
+
+    return intervalHandle;
+  };
+
+  const clearIntervalPolyfill = (intervalHandle: number) => {
+    const timeoutHandle = intervalHandleToTimeoutHandle.get(intervalHandle);
+    clearTimeout(timeoutHandle);
+    intervalHandleToTimeoutHandle.delete(intervalHandle);
+  };
+
+  globalThis.setInterval = setIntervalPolyfill as typeof setInterval;
+  globalThis.clearInterval = clearIntervalPolyfill as typeof clearInterval;
+}

package/src/runLoop/uiRuntime/mockedRequestAnimationFrame.ts

@@ -0,0 +1,11 @@
+'use strict';
+
+/**
+ * This is Jest implementation of `requestAnimationFrame` that is required by
+ * React Native for test purposes.
+ */
+export function mockedRequestAnimationFrame(
+  callback: (timestamp: number) => void
+): ReturnType<typeof setTimeout> {
+  return setTimeout(() => callback(performance.now()), 0);
+}

package/src/runLoop/uiRuntime/requestAnimationFrame.ts

@@ -0,0 +1,66 @@
+'use strict';
+
+import { callMicrotasks } from '../../threads';
+
+export function setupRequestAnimationFrame() {
+  'worklet';
+  const nativeRequestAnimationFrame = globalThis.requestAnimationFrame;
+
+  let queuedCallbacks: ((timestamp: number) => void)[] = [];
+  let queuedCallbacksBegin = 0;
+  let queuedCallbacksEnd = 0;
+
+  let flushedCallbacks = queuedCallbacks;
+  let flushedCallbacksBegin = 0;
+  let flushedCallbacksEnd = 0;
+
+  let flushRequested = false;
+
+  globalThis.__flushAnimationFrame = (timestamp: number) => {
+    flushedCallbacks = queuedCallbacks;
+    queuedCallbacks = [];
+
+    flushedCallbacksBegin = queuedCallbacksBegin;
+    flushedCallbacksEnd = queuedCallbacksEnd;
+    queuedCallbacksBegin = queuedCallbacksEnd;
+
+    for (const callback of flushedCallbacks) {
+      callback(timestamp);
+    }
+
+    flushedCallbacksBegin = flushedCallbacksEnd;
+
+    callMicrotasks();
+  };
+
+  globalThis.requestAnimationFrame = (
+    callback: (timestamp: number) => void
+  ): number => {
+    const handle = queuedCallbacksEnd++;
+
+    queuedCallbacks.push(callback);
+    if (!flushRequested) {
+      flushRequested = true;
+
+      nativeRequestAnimationFrame((timestamp) => {
+        flushRequested = false;
+        globalThis.__frameTimestamp = timestamp;
+        globalThis.__flushAnimationFrame(timestamp);
+        globalThis.__frameTimestamp = undefined;
+      });
+    }
+    return handle;
+  };
+
+  globalThis.cancelAnimationFrame = (handle: number) => {
+    if (handle < flushedCallbacksBegin || handle >= queuedCallbacksEnd) {
+      return;
+    }
+
+    if (handle < flushedCallbacksEnd) {
+      flushedCallbacks[handle - flushedCallbacksBegin] = () => {};
+    } else {
+      queuedCallbacks[handle - queuedCallbacksBegin] = () => {};
+    }
+  };
+}

package/src/runLoop/uiRuntime/setTimeoutPolyfill.ts

@@ -0,0 +1,40 @@
+'use strict';
+
+export function setupSetTimeout() {
+  'worklet';
+
+  const timeoutHandleToRafHandle: Map<number, number> = new Map();
+
+  const setTimeoutPolyfill = (
+    callback: (...args: unknown[]) => void,
+    delay: number = 0,
+    ...args: unknown[]
+  ) => {
+    const start = performance.now();
+    let timeoutHandle = 0;
+
+    const rafCallback = () => {
+      const now = performance.now();
+      if (now - start >= delay) {
+        callback(...args);
+        timeoutHandleToRafHandle.delete(timeoutHandle);
+      } else {
+        const rafHandle = requestAnimationFrame(rafCallback);
+        timeoutHandleToRafHandle.set(timeoutHandle, rafHandle);
+      }
+    };
+
+    timeoutHandle = requestAnimationFrame(rafCallback);
+    timeoutHandleToRafHandle.set(timeoutHandle, timeoutHandle);
+    return timeoutHandle;
+  };
+
+  const clearTimeoutPolyfill = (timeoutHandle: number) => {
+    const rafHandle = timeoutHandleToRafHandle.get(timeoutHandle);
+    timeoutHandleToRafHandle.delete(timeoutHandle);
+    cancelAnimationFrame(rafHandle!);
+  };
+
+  globalThis.setTimeout = setTimeoutPolyfill as typeof setTimeout;
+  globalThis.clearTimeout = clearTimeoutPolyfill as typeof clearTimeout;
+}

package/src/runLoop/workletRuntime/index.ts

@@ -0,0 +1,18 @@
+'use strict';
+
+import { setupSetImmediate } from '../common/setImmediatePolyfill';
+import { setupSetInterval } from '../common/setIntervalPolyfill';
+import { setupQueueMicrotask } from './queueMicrotask';
+import { setupRequestAnimationFrame } from './requestAnimationFramePolyfill';
+import { setupSetTimeout } from './setTimeout';
+import { setupTaskQueue } from './taskQueue';
+
+export function setupRunLoop(animationQueuePollingRate: number) {
+  'worklet';
+  setupTaskQueue();
+  setupQueueMicrotask();
+  setupSetTimeout();
+  setupRequestAnimationFrame(animationQueuePollingRate);
+  setupSetImmediate();
+  setupSetInterval();
+}

package/src/runLoop/workletRuntime/queueMicrotask.ts

@@ -0,0 +1,13 @@
+'use strict';
+
+import { pushMicrotask } from './taskQueue';
+
+export function setupQueueMicrotask() {
+  'worklet';
+  globalThis.queueMicrotask = function (
+    callback: (...args: unknown[]) => void,
+    ...args: unknown[]
+  ) {
+    pushMicrotask(() => callback(...args));
+  } as typeof queueMicrotask;
+}

package/src/runLoop/workletRuntime/requestAnimationFramePolyfill.ts

@@ -0,0 +1,61 @@
+'use strict';
+
+export function setupRequestAnimationFrame(animationQueuePollingRate: number) {
+  'worklet';
+  const timeoutInterval = animationQueuePollingRate;
+
+  let queuedCallbacks: ((timestamp: number) => void)[] = [];
+  let queuedCallbacksBegin = 0;
+  let queuedCallbacksEnd = 0;
+
+  let flushedCallbacks = queuedCallbacks;
+  let flushedCallbacksBegin = 0;
+  let flushedCallbacksEnd = 0;
+
+  let flushRequested = false;
+
+  function flushAnimationFrame() {
+    flushRequested = false;
+    const timestamp = performance.now();
+
+    flushedCallbacks = queuedCallbacks;
+    queuedCallbacks = [];
+
+    flushedCallbacksBegin = queuedCallbacksBegin;
+    flushedCallbacksEnd = queuedCallbacksEnd;
+    queuedCallbacksBegin = queuedCallbacksEnd;
+
+    for (const callback of flushedCallbacks) {
+      callback(timestamp);
+      globalThis.__flushMicrotasks();
+    }
+
+    flushedCallbacksBegin = flushedCallbacksEnd;
+  }
+
+  globalThis.requestAnimationFrame = (
+    callback: (timestamp: number) => void
+  ): number => {
+    const handle = queuedCallbacksEnd++;
+
+    queuedCallbacks.push(callback);
+    if (!flushRequested) {
+      flushRequested = true;
+
+      setTimeout(flushAnimationFrame, timeoutInterval);
+    }
+    return handle;
+  };
+
+  globalThis.cancelAnimationFrame = (handle: number) => {
+    if (handle < flushedCallbacksBegin || handle >= queuedCallbacksEnd) {
+      return;
+    }
+
+    if (handle < flushedCallbacksEnd) {
+      flushedCallbacks[handle - flushedCallbacksBegin] = () => {};
+    } else {
+      queuedCallbacks[handle - queuedCallbacksBegin] = () => {};
+    }
+  };
+}