@astrogate/sdk 0.0.0-stage → 0.1.0

package/node_modules/mutative/src/interface.ts

@@ -0,0 +1,321 @@
+import { dataTypes } from './constant';
+
+export const enum DraftType {
+  Object,
+  Array,
+  Map,
+  Set,
+}
+
+export const Operation = {
+  Remove: 'remove',
+  Replace: 'replace',
+  Add: 'add',
+} as const;
+
+export type DataType = keyof typeof dataTypes;
+
+/**
+ * The `enablePatches` option: `true` or an object generates patches, `false`
+ * does not.
+ */
+export type PatchesOptions =
+  | boolean
+  | {
+      /**
+       * Whether a patch path is an array of keys, as by default, or a JSON
+       * Pointer string, such as `/list/0`.
+       */
+      pathAsArray?: boolean;
+      /**
+       * Whether an array that gets shorter gets a `replace` patch of its
+       * `length`, as by default, or a `remove` patch for each index that it
+       * loses, as JSON Patch requires.
+       * Recreating holes in a sparse array still uses length patches;
+       * JSON cannot represent holes.
+       */
+      arrayLengthAssignment?: boolean;
+    };
+
+export type FinalizeCallback = (
+  patches?: Patches,
+  inversePatches?: Patches
+) => void;
+
+export interface Finalities {
+  // Draft nodes and deferred callbacks, finalized in reverse order.
+  draft: (ProxyDraft | FinalizeCallback)[];
+  revoke: (() => void)[];
+  handledSet: WeakSet<any>;
+  // Whether the producer runs a recipe inside `create`, which then sees it end
+  // and releases module-level references to its drafts. False for drafts
+  // returned by `create(base)` without a recipe.
+  scoped: boolean;
+}
+
+export interface ProxyDraft<T = any> {
+  type: DraftType;
+  operated: boolean;
+  finalized: boolean;
+  original: T;
+  copy: T | null;
+  proxy: T | null;
+  finalities: Finalities;
+  options: Options<any, any>;
+  parent: ProxyDraft | null;
+  key: string | number | symbol | undefined;
+  // The drafts of a Set draft's items and the objects it added, with its items
+  // in order once finalization rebuilt it.
+  setMap: (Map<any, any> & { items?: any[] }) | undefined;
+  assignedMap: Map<any, boolean> | undefined;
+  callbacks: FinalizeCallback[] | undefined;
+  // Child drafts created by this draft, by key.
+  children: any;
+  child: any;
+  childKey: any;
+  // Bookkeeping of array methods that ran natively, created on demand.
+  arrayState: ArrayState | null;
+}
+
+export interface ArrayState {
+  // Elements may have moved away from their original index.
+  relocated: boolean;
+  // Index range whose contents may have changed; patch generation compares
+  // it in full.
+  diffStart: number;
+  diffEnd: number;
+  // Original index by element of the original array, built lazily.
+  baseRefs: Map<any, number> | null;
+  // How far the last native move shifted the elements it moved, when it
+  // shifted all of them alike.
+  delta: number | undefined;
+  // Original indices looked up by searching before `baseRefs` is built.
+  lookups: number;
+  // Whether no element can be drafted; null until checked.
+  inert: boolean | null;
+  // Whether the array has no holes; null until checked.
+  dense: boolean | null;
+}
+
+export interface IPatch {
+  op: (typeof Operation)[keyof typeof Operation];
+  value?: any;
+}
+
+/**
+ * An `add`, `remove` or `replace` operation at a path, as `create()` generates
+ * it with `enablePatches` and `apply()` applies it. The path is an array of
+ * keys, or a JSON Pointer string with `pathAsArray: false`.
+ */
+export type Patch<P extends PatchesOptions = any> = P extends {
+  pathAsArray: false;
+}
+  ? IPatch & {
+      path: string;
+    }
+  : P extends true | object
+    ? IPatch & {
+        path: (string | number)[];
+      }
+    : IPatch & {
+        path: string | (string | number)[];
+      };
+
+/**
+ * Patches in the order in which `apply()` applies them.
+ */
+export type Patches<P extends PatchesOptions = any> = Patch<P>[];
+
+export type Result<
+  T extends any,
+  O extends PatchesOptions,
+  F extends boolean,
+> = O extends true | object
+  ? [F extends true ? Immutable<T> : T, Patches<O>, Patches<O>]
+  : F extends true
+    ? Immutable<T>
+    : T;
+
+export type CreateResult<
+  T extends any,
+  O extends PatchesOptions,
+  F extends boolean,
+  R extends void | Promise<void> | T | Promise<T>,
+> = R extends Promise<void> | Promise<T>
+  ? Promise<Result<T, O, F>>
+  : Result<T, O, F>;
+
+type BaseMark = null | undefined | DataType;
+type MarkWithCopy = BaseMark | (() => any);
+
+export type Mark<O extends PatchesOptions, F extends boolean> = (
+  target: any,
+  types: typeof dataTypes
+) => O extends true | object
+  ? BaseMark
+  : F extends true
+    ? BaseMark
+    : MarkWithCopy;
+
+export interface ApplyMutableOptions {
+  /**
+   * If it's `true`, the state will be mutated directly.
+   */
+  mutable?: boolean;
+}
+
+export interface Options<O extends PatchesOptions, F extends boolean> {
+  /**
+   * In strict mode, reading an object that cannot be drafted from a draft,
+   * such as a class instance that no mark makes draftable, or a value that
+   * `mark` makes mutable, throws unless the read happens inside `unsafe()`.
+   * A value returned with `rawReturn()` is still searched for drafts, which
+   * development builds report with a warning. Development builds also warn
+   * once when a recipe leaves 1,000 or more drafts unchanged.
+   */
+  strict?: boolean;
+  /**
+   * Generate patches: the result is then
+   * `[state, patches, inversePatches]`.
+   */
+  enablePatches?: O;
+  /**
+   * Freeze the next state deeply, also the parts that it shares with the base
+   * state. Development builds also throw for an object that holds itself.
+   */
+  enableAutoFreeze?: F;
+  /**
+   * Decide how values are drafted: a mark returns `immutable` to make a value
+   * draftable, such as a class instance, `mutable` to keep it out of drafts so
+   * that the recipe changes it in place, or a function that returns a shallow
+   * copy of the value, which needs patches and auto-freeze off. With several
+   * marks, the first one that returns a value decides.
+   */
+  mark?: Mark<O, F>;
+}
+
+export interface ExternalOptions<O extends PatchesOptions, F extends boolean> {
+  /**
+   * In strict mode, reading an object that cannot be drafted from a draft,
+   * such as a class instance that no mark makes draftable, or a value that
+   * `mark` makes mutable, throws unless the read happens inside `unsafe()`.
+   * A value returned with `rawReturn()` is still searched for drafts, which
+   * development builds report with a warning. Development builds also warn
+   * once when a recipe leaves 1,000 or more drafts unchanged.
+   */
+  strict?: boolean;
+  /**
+   * Generate patches: the result is then
+   * `[state, patches, inversePatches]`.
+   */
+  enablePatches?: O;
+  /**
+   * Freeze the next state deeply, also the parts that it shares with the base
+   * state. Development builds also throw for an object that holds itself.
+   */
+  enableAutoFreeze?: F;
+  /**
+   * Decide how values are drafted: a mark returns `immutable` to make a value
+   * draftable, such as a class instance, `mutable` to keep it out of drafts so
+   * that the recipe changes it in place, or a function that returns a shallow
+   * copy of the value, which needs patches and auto-freeze off. With several
+   * marks, the first one that returns a value decides.
+   */
+  mark?: Mark<O, F>[] | Mark<O, F>;
+}
+
+// Exclude `symbol`
+type Primitive = string | number | bigint | boolean | null | undefined;
+
+type ImmutableMap<K, V> = ReadonlyMap<Immutable<K>, Immutable<V>>;
+type ImmutableSet<T> = ReadonlySet<Immutable<T>>;
+type ImmutableObject<T> = { readonly [K in keyof T]: Immutable<T[K]> };
+
+export type IfAvailable<T, Fallback = void> = true | false extends (
+  T extends never ? true : false
+)
+  ? Fallback
+  : keyof T extends never
+    ? Fallback
+    : T;
+type WeakReferences =
+  | IfAvailable<WeakMap<any, any>>
+  | IfAvailable<WeakSet<any>>;
+type AtomicObject = Function | Promise<any> | Date | RegExp;
+
+/**
+ * A deeply readonly `T`, the type of a state that `enableAutoFreeze` freezes:
+ * Maps and Sets become `ReadonlyMap` and `ReadonlySet`, and functions,
+ * Promises, dates and regular expressions keep their types.
+ */
+export type Immutable<T> = T extends Primitive | AtomicObject
+  ? T
+  : T extends IfAvailable<ReadonlyMap<infer K, infer V>>
+    ? ImmutableMap<K, V>
+    : T extends IfAvailable<ReadonlySet<infer V>>
+      ? ImmutableSet<V>
+      : T extends WeakReferences
+        ? T
+        : T extends object
+          ? ImmutableObject<T>
+          : T;
+
+type DraftedMap<K, V> = Map<K, Draft<V>>;
+type DraftedSet<T> = Set<Draft<T>>;
+/**
+ * The draft of an object type: writable properties whose values are drafts.
+ */
+export type DraftedObject<T> = {
+  -readonly [K in keyof T]: Draft<T[K]>;
+};
+
+/**
+ * The type of a draft of `T`: its objects, arrays, Maps and Sets without
+ * `readonly`, deeply, so that a recipe can change them. Functions, Promises,
+ * dates and regular expressions keep their types.
+ */
+export type Draft<T> = T extends Primitive | AtomicObject
+  ? T
+  : T extends IfAvailable<ReadonlyMap<infer K, infer V>>
+    ? DraftedMap<K, V>
+    : T extends IfAvailable<ReadonlySet<infer V>>
+      ? DraftedSet<V>
+      : T extends WeakReferences
+        ? T
+        : T extends object
+          ? DraftedObject<T>
+          : T;
+
+export type ApplyImmutableOptions<F extends boolean> = Pick<
+  Options<boolean, F>,
+  Exclude<keyof Options<boolean, F>, 'enablePatches'>
+> & { mutable?: false };
+
+export type ApplyOptions<F extends boolean> =
+  | ApplyImmutableOptions<F>
+  | ApplyMutableOptions;
+
+// Distribute over boolean and undefined so optional or widened freeze flags
+// keep both possible states instead of silently promising a writable result.
+type ApplyFrozenState<T, F> = F extends true ? Immutable<T> : T;
+
+type ApplyState<T, F extends boolean, A> = F extends true
+  ? Immutable<T>
+  : 'enableAutoFreeze' extends keyof A
+    ? ApplyFrozenState<T, A['enableAutoFreeze']>
+    : T;
+
+// `apply()` changes the state in place and returns nothing with `mutable`,
+// and returns a frozen state with `enableAutoFreeze`, as `create()` does.
+// A boolean or optional `mutable` flag can also select the void result.
+export type ApplyResult<
+  T extends object,
+  F extends boolean = false,
+  A extends ApplyOptions<boolean> | undefined = ApplyImmutableOptions<F>,
+> = A extends { mutable: true }
+  ? void
+  : 'mutable' extends keyof A
+    ? true extends A['mutable']
+      ? ApplyState<T, F, A> | void
+      : ApplyState<T, F, A>
+    : ApplyState<T, F, A>;

package/node_modules/mutative/src/internal.ts

@@ -0,0 +1,5 @@
+import { createDraft } from './draft';
+
+export const internal = {} as {
+  createDraft: typeof createDraft;
+};

package/node_modules/mutative/src/makeCreator.ts

@@ -0,0 +1,382 @@
+import {
+  CreateResult,
+  Draft,
+  Mark,
+  Options,
+  ExternalOptions,
+  PatchesOptions,
+  Result,
+} from './interface';
+import { draftify } from './draftify';
+import { releaseArrayMethods } from './array';
+import {
+  getProxyDraft,
+  isDraft,
+  isDraftable,
+  isEqual,
+  revokeProxy,
+} from './utils';
+import { current, handleReturnValue } from './current';
+import { RAW_RETURN_SYMBOL, dataTypes } from './constant';
+import { die, ErrorCode } from './error';
+
+// TypeScript infers no type parameter from this deferred indexed access, so T
+// keeps its default, never, unless the call supplies the state type.
+type ExplicitState<T> = [T][T extends any ? 0 : never];
+
+type ExplicitReturn<T> = void | ExplicitState<T> | Draft<ExplicitState<T>>;
+
+// An async recipe widens the literals it returns unless a Promise is among
+// the return types of the first overload that checks it, and a literal that
+// it returns directly needs a Promise as the whole return type. Actual
+// Promises lack the impossible field and still select the async overload.
+type AsyncRecipeContext<T> = Promise<ExplicitReturn<T>> & {
+  readonly __mutativeAsyncContext: never;
+};
+
+type IsExplicitPrimitive<T> = [ExplicitState<T>] extends [
+  string | number | bigint | boolean | symbol | null | undefined,
+]
+  ? true
+  : false;
+
+type ExplicitSyncReturn<T> =
+  IsExplicitPrimitive<T> extends true
+    ? AsyncRecipeContext<T>
+    : ExplicitReturn<T> | AsyncRecipeContext<T>;
+
+type ExplicitRecipe<T, P extends any[], R> = [T] extends [never]
+  ? never
+  : (draft: Draft<ExplicitState<T>>, ...args: P) => R;
+
+// The first overload only gives the async recipes of a primitive state their
+// context, so its synchronous recipes take this one, which comes before the
+// overload of a recipe that may or may not return a Promise.
+type ExplicitPrimitiveRecipe<T, P extends any[]> =
+  IsExplicitPrimitive<T> extends true
+    ? ExplicitRecipe<T, P, ExplicitReturn<T>>
+    : never;
+
+/** @inline */ type MakeCreator = <
+  _F extends boolean = false,
+  _O extends PatchesOptions = false,
+>(
+  options?: ExternalOptions<_O, _F>
+) => {
+  // With an explicit state type, TypeScript infers no other type argument, and
+  // the default return type `void` of the overloads below also accepts an
+  // async recipe. These overloads tell async recipes apart by their return
+  // type; an inferred call leaves T at never and skips them.
+  <T = never, F extends boolean = _F, O extends PatchesOptions = _O>(
+    base: ExplicitState<T>,
+    mutate: ExplicitRecipe<T, [], ExplicitSyncReturn<T>>,
+    options?: ExternalOptions<O, F>
+  ): Result<ExplicitState<T>, O, F>;
+  <T = never, F extends boolean = _F, O extends PatchesOptions = _O>(
+    base: ExplicitState<T>,
+    mutate: ExplicitRecipe<T, [], Promise<ExplicitReturn<T>>>,
+    options?: ExternalOptions<O, F>
+  ): Promise<Result<ExplicitState<T>, O, F>>;
+  // A synchronous recipe of a primitive state.
+  <T = never, F extends boolean = _F, O extends PatchesOptions = _O>(
+    base: ExplicitState<T>,
+    mutate: ExplicitPrimitiveRecipe<T, []>,
+    options?: ExternalOptions<O, F>
+  ): Result<ExplicitState<T>, O, F>;
+  // A recipe that may or may not return a Promise gives either result.
+  <T = never, F extends boolean = _F, O extends PatchesOptions = _O>(
+    base: ExplicitState<T>,
+    mutate: ExplicitRecipe<
+      T,
+      [],
+      ExplicitReturn<T> | Promise<ExplicitReturn<T>>
+    >,
+    options?: ExternalOptions<O, F>
+  ): Result<ExplicitState<T>, O, F> | Promise<Result<ExplicitState<T>, O, F>>;
+  <
+    T extends any,
+    F extends boolean = _F,
+    O extends PatchesOptions = _O,
+    R extends void | Promise<void> | T | Promise<T> = void,
+  >(
+    base: T,
+    mutate: (draft: Draft<T>) => R,
+    options?: ExternalOptions<O, F>
+  ): CreateResult<T, O, F, R>;
+  <
+    T extends any,
+    F extends boolean = _F,
+    O extends PatchesOptions = _O,
+    R extends void | Promise<void> = void,
+  >(
+    base: T,
+    mutate: (draft: T) => R,
+    options?: ExternalOptions<O, F>
+  ): CreateResult<T, O, F, R>;
+  <
+    T = never,
+    P extends any[] = [],
+    F extends boolean = _F,
+    O extends PatchesOptions = _O,
+  >(
+    mutate: ExplicitRecipe<T, P, ExplicitSyncReturn<T>>,
+    options?: ExternalOptions<O, F>
+  ): (base: ExplicitState<T>, ...args: P) => Result<ExplicitState<T>, O, F>;
+  <
+    T = never,
+    P extends any[] = [],
+    F extends boolean = _F,
+    O extends PatchesOptions = _O,
+  >(
+    mutate: ExplicitRecipe<T, P, Promise<ExplicitReturn<T>>>,
+    options?: ExternalOptions<O, F>
+  ): (
+    base: ExplicitState<T>,
+    ...args: P
+  ) => Promise<Result<ExplicitState<T>, O, F>>;
+  <
+    T = never,
+    P extends any[] = [],
+    F extends boolean = _F,
+    O extends PatchesOptions = _O,
+  >(
+    mutate: ExplicitPrimitiveRecipe<T, P>,
+    options?: ExternalOptions<O, F>
+  ): (base: ExplicitState<T>, ...args: P) => Result<ExplicitState<T>, O, F>;
+  <
+    T = never,
+    P extends any[] = [],
+    F extends boolean = _F,
+    O extends PatchesOptions = _O,
+  >(
+    mutate: ExplicitRecipe<
+      T,
+      P,
+      ExplicitReturn<T> | Promise<ExplicitReturn<T>>
+    >,
+    options?: ExternalOptions<O, F>
+  ): (
+    base: ExplicitState<T>,
+    ...args: P
+  ) => Result<ExplicitState<T>, O, F> | Promise<Result<ExplicitState<T>, O, F>>;
+  <
+    T extends any,
+    P extends any[] = [],
+    F extends boolean = _F,
+    O extends PatchesOptions = _O,
+    R extends void | Promise<void> | T | Promise<T> = void,
+  >(
+    mutate: (draft: Draft<T>, ...args: P) => R,
+    options?: ExternalOptions<O, F>
+  ): (base: T, ...args: P) => CreateResult<T, O, F, R>;
+  // A recipe that annotates its draft with the state type itself, such as a
+  // type parameter, which TypeScript cannot match against `Draft<T>`.
+  <
+    T extends any,
+    P extends any[] = [],
+    F extends boolean = _F,
+    O extends PatchesOptions = _O,
+    R extends void | Promise<void> | T | Promise<T> = void,
+  >(
+    mutate: (draft: T, ...args: P) => R,
+    options?: ExternalOptions<O, F>
+  ): (base: T, ...args: P) => CreateResult<T, O, F, R>;
+  <T extends any, O extends PatchesOptions = _O, F extends boolean = _F>(
+    base: T,
+    options?: ExternalOptions<O, F>
+  ): [Draft<T>, () => Result<T, O, F>];
+};
+
+// Development builds warn once about a draft base, see `makeCreator`.
+let draftBaseWarned = false;
+
+/**
+ * `makeCreator(options)` to make a creator function.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { makeCreator } from 'mutative';
+ *
+ * const baseState = { foo: { bar: 'str' }, arr: [] };
+ * const create = makeCreator({ enableAutoFreeze: true });
+ * const state = create(
+ *   baseState,
+ *   (draft) => {
+ *     draft.foo.bar = 'str2';
+ *   },
+ * );
+ *
+ * expect(state).toEqual({ foo: { bar: 'str2' }, arr: [] });
+ * expect(state).not.toBe(baseState);
+ * expect(state.foo).not.toBe(baseState.foo);
+ * expect(state.arr).toBe(baseState.arr);
+ * expect(Object.isFrozen(state)).toBeTruthy();
+ * ```
+ */
+export const makeCreator: MakeCreator = (arg) => {
+  if (
+    __DEV__ &&
+    arg !== undefined &&
+    Object.prototype.toString.call(arg) !== '[object Object]'
+  ) {
+    throw new Error(
+      `Invalid options: ${String(arg)}, 'options' should be an object.`
+    );
+  }
+  return function create(arg0: any, arg1: any, arg2?: any): any {
+    if (typeof arg0 === 'function' && typeof arg1 !== 'function') {
+      return function (this: any, base: any, ...args: any[]) {
+        return create(
+          base,
+          (draft: any) => arg0.call(this, draft, ...args),
+          arg1
+        );
+      };
+    }
+    const base = arg0;
+    const mutate = arg1 as (...args: any[]) => any;
+    let options = arg2;
+    if (typeof arg1 !== 'function') {
+      options = arg1;
+    }
+    if (
+      __DEV__ &&
+      options !== undefined &&
+      Object.prototype.toString.call(options) !== '[object Object]'
+    ) {
+      throw new Error(
+        `Invalid options: ${options}, 'options' should be an object.`
+      );
+    }
+    options = {
+      ...arg,
+      ...options,
+    };
+    const draftBase = isDraft(base);
+    // A draft base is drafted as `current(draft)`, so the values that the
+    // recipe leaves unchanged are objects of the base state.
+    if (
+      __DEV__ &&
+      draftBase &&
+      typeof arg1 === 'function' &&
+      !draftBaseWarned
+    ) {
+      draftBaseWarned = true;
+      console.warn(
+        `create() received a draft as its base and drafts current(draft), unlike Immer's produce: the values that its recipe leaves unchanged are objects of the base state, so changing them after the result is assigned back changes the base state. Make such changes in the recipe or before calling create(); see https://mutative.js.org/docs/api-reference/create#create-on-a-draft`
+      );
+    }
+    const state = draftBase ? current(base) : base;
+    const mark = Array.isArray(options.mark)
+      ? (((value: unknown, types: typeof dataTypes) => {
+          for (const mark of options.mark as Mark<any, any>[]) {
+            if (__DEV__ && typeof mark !== 'function') {
+              throw new Error(
+                `Invalid mark: ${mark}, 'mark' should be a function.`
+              );
+            }
+            const result = mark(value, types);
+            if (result) {
+              return result;
+            }
+          }
+          return;
+        }) as Mark<any, any>)
+      : options.mark;
+    const enablePatches = options.enablePatches ?? false;
+    const strict = options.strict ?? false;
+    const enableAutoFreeze = options.enableAutoFreeze ?? false;
+    const _options: Options<any, any> = {
+      enableAutoFreeze,
+      mark,
+      strict,
+      enablePatches,
+    };
+    if (
+      !isDraftable(state, _options) &&
+      typeof state === 'object' &&
+      state !== null
+    ) {
+      die(ErrorCode.InvalidBaseState);
+    }
+    const [draft, finalize, finalities] = draftify(state, _options);
+    if (typeof arg1 !== 'function') {
+      if (!isDraftable(state, _options)) {
+        die(ErrorCode.InvalidBaseState);
+      }
+      finalities.scoped = false;
+      return [draft, finalize];
+    }
+    // A failed producer revokes its drafts, without reading the root draft,
+    // which finalization may already have revoked, and releases the array
+    // method cache, which must not keep it alive.
+    function fail(error: unknown): never {
+      revokeProxy(finalities);
+      releaseArrayMethods(finalities.revoke);
+      throw error;
+    }
+    let result: any;
+    try {
+      result = mutate(draft);
+    } catch (error) {
+      fail(error);
+    }
+    const returnValue = (value: any) => {
+      const proxyDraft = getProxyDraft(draft)!;
+      if (!isDraft(value)) {
+        if (
+          value !== undefined &&
+          !isEqual(value, draft) &&
+          proxyDraft?.operated
+        ) {
+          die(ErrorCode.MutateAndReturn);
+        }
+        const rawReturnValue = value?.[RAW_RETURN_SYMBOL] as [any] | undefined;
+        if (rawReturnValue) {
+          const _value = rawReturnValue[0];
+          if (_options.strict && typeof value === 'object' && value !== null) {
+            handleReturnValue(proxyDraft, value, true);
+          }
+          return finalize([_value]);
+        }
+        if (value !== undefined) {
+          if (typeof value === 'object' && value !== null) {
+            handleReturnValue(proxyDraft, value);
+          }
+          return finalize([value]);
+        }
+      }
+      if (value === draft || value === undefined) {
+        return finalize([]);
+      }
+      const returnedProxyDraft = getProxyDraft(value)!;
+      if (_options === returnedProxyDraft.options) {
+        if (returnedProxyDraft.operated) {
+          die(ErrorCode.CannotReturnModifiedChildDraft);
+        }
+        return finalize([current(value)]);
+      }
+      return finalize([value]);
+    };
+    // Returned values are checked and finalized after the recipe, and a
+    // failure there ends the producer like an error in the recipe does.
+    const finish = (value: any) => {
+      try {
+        return returnValue(value);
+      } catch (error) {
+        return fail(error);
+      } finally {
+        releaseArrayMethods(finalities.revoke);
+      }
+    };
+    try {
+      // Classifying a returned Proxy, or reading/calling an overridden then,
+      // can throw before a Promise has registered the failure handler.
+      if (result instanceof Promise) return result.then(finish, fail);
+    } catch (error) {
+      return fail(error);
+    }
+    return finish(result);
+  };
+};