@astrogate/sdk 0.0.0-stage → 0.1.0-rc.1

package/node_modules/mutative/src/draft.ts

@@ -0,0 +1,489 @@
+import {
+  DraftType,
+  Finalities,
+  Patches,
+  ProxyDraft,
+  Options,
+  Operation,
+} from './interface';
+import { dataTypes, PROXY_DRAFT } from './constant';
+import { mapHandler, mapHandlerKeys } from './map';
+import { setHandler, setHandlerKeys } from './set';
+import {
+  arrayMethods,
+  baseIndex,
+  isMovedElement,
+  resized,
+  trackArrayMethod,
+} from './array';
+import { internal } from './internal';
+import {
+  deepFreeze,
+  ensureShallowCopy,
+  getDescriptor,
+  getProxyDraft,
+  getType,
+  isEqual,
+  isDraftable,
+  latest,
+  markChanged,
+  revokeProxy,
+  markFinalization,
+  finalizeNode,
+} from './utils';
+import { checkReadable } from './unsafe';
+import { generatePatches } from './patch';
+import { die, ErrorCode } from './error';
+
+/**
+ * Accepts the keys the array set trap has always accepted: canonical
+ * non-negative integer strings via an allocation-free scan, and other
+ * spellings such as '-0' via the original numeric round trip.
+ */
+function isArrayIndexKey(key: string | number | symbol) {
+  if (typeof key === 'string' && key.length < 16) {
+    let index = 0;
+    while (index < key.length) {
+      const code = key.charCodeAt(index);
+      if (code < 48 || code > 57) break;
+      index += 1;
+    }
+    if (
+      index > 0 &&
+      index === key.length &&
+      (index === 1 || key.charCodeAt(0) !== 48)
+    ) {
+      return true;
+    }
+  }
+  let _key: number;
+  return (
+    Number.isInteger((_key = Number(key))) &&
+    _key >= 0 &&
+    (key === 0 || _key === 0 || String(_key) === String(key))
+  );
+}
+
+const hasOwn = Object.prototype.hasOwnProperty;
+
+function getTrap(
+  target: ProxyDraft,
+  key: string | number | symbol,
+  receiver: any
+) {
+  if (key === PROXY_DRAFT) return target;
+  const { options, type } = target;
+  const source = latest(target);
+  let markResult: any;
+  if (options.mark) {
+    // The mark classifies the value the draft holds now, so a value the
+    // recipe assigned is read back as assigned. `size` is read without the
+    // proxy as receiver: the Map and Set getters reject any other receiver.
+    const value =
+      key === 'size' && (source instanceof Map || source instanceof Set)
+        ? Reflect.get(source, key)
+        : Reflect.get(source, key, receiver);
+    markResult = options.mark(value, dataTypes);
+    if (markResult === dataTypes.mutable) {
+      if (options.strict) {
+        checkReadable(value, options, true);
+      }
+      return value;
+    }
+  }
+
+  if (type === DraftType.Map) {
+    if (mapHandlerKeys.includes(key as any)) {
+      if (key === 'size') {
+        return Object.getOwnPropertyDescriptor(mapHandler, 'size')!.get!.call(
+          target.proxy
+        );
+      }
+      const handle = mapHandler[key as keyof typeof mapHandler] as Function;
+      return handle.bind(target.proxy);
+    }
+  } else if (type === DraftType.Set) {
+    if (setHandlerKeys.includes(key as any)) {
+      if (key === 'size') {
+        return Object.getOwnPropertyDescriptor(setHandler, 'size')!.get!.call(
+          target.proxy
+        );
+      }
+      const handle = setHandler[key as keyof typeof setHandler] as Function;
+      return handle.bind(target.proxy);
+    }
+  }
+
+  if (
+    type === DraftType.Map
+      ? !(source as Map<any, any>).has(key)
+      : !hasOwn.call(source, key)
+  ) {
+    if (
+      type === DraftType.Array &&
+      Object.getPrototypeOf(target.original) === Array.prototype
+    ) {
+      // Methods of plain arrays that can run natively on the copy; see
+      // `arrayMethods`. Subclasses resolve their own methods below.
+      const method = arrayMethods[key as any];
+      if (method !== undefined) {
+        trackArrayMethod(target);
+        return method;
+      }
+    }
+    const desc = getDescriptor(source, key);
+    return desc
+      ? `value` in desc
+        ? desc.value
+        : // !case: support for getter
+          desc.get?.call(target.proxy)
+      : undefined;
+  }
+  const value = source[key];
+  if (options.strict) {
+    checkReadable(value, options);
+  }
+  if (target.finalized || typeof value !== 'object' || value === null) {
+    return value;
+  }
+  // This draft's own child at this key is returned without a proxy round
+  // trip and without reading the original object. The first child is kept
+  // inline; further children are registered per draft.
+  if (value === target.child && key === target.childKey) return value;
+  const children = target.children;
+  if (
+    children !== undefined &&
+    (type === DraftType.Array ? children[key as number] : children.get(key)) ===
+      value
+  ) {
+    return value;
+  }
+  // Non-draftable values never reach the original object either, so an
+  // accessor that returns a Date or similar is not re-invoked for a copy.
+  if (!isDraftable(value, options)) return value;
+  // Reassigned values, and fresh objects produced by an accessor on the
+  // original, differ from the original at this key and are not drafted. After
+  // a native array operation moved elements, an original element may sit at
+  // any index, so membership in the original array decides instead, except
+  // for a value the recipe assigned at this index; see `baseIndex`.
+  let draftKey: any = key;
+  if (value !== target.original[key]) {
+    draftKey = baseIndex(target, value, key as number);
+    if (draftKey === -1) return value;
+  }
+  ensureShallowCopy(target);
+  const draft = createDraft(
+    value,
+    target,
+    type === DraftType.Array ? Number(draftKey) : draftKey,
+    target.finalities,
+    options
+  );
+  target.copy![key] = draft;
+  // A moved element keeps its original index as key for patch paths and is
+  // finalized into its current index through a callback.
+  if (draftKey !== key) markFinalization(target, key, draft);
+  if (target.child === null || target.childKey === key) {
+    target.child = draft;
+    target.childKey = key;
+  } else if (type === DraftType.Array) {
+    (target.children ??= [])[key as any] = draft;
+  } else {
+    (target.children ??= new Map()).set(key, draft);
+  }
+  // !case: support for custom shallow copy function
+  if (typeof markResult === 'function') {
+    const subProxyDraft = getProxyDraft(draft)!;
+    ensureShallowCopy(subProxyDraft);
+    // Trigger a custom shallow copy to update to a new copy
+    markChanged(subProxyDraft);
+    return subProxyDraft.copy;
+  }
+  return draft;
+}
+
+function setTrap(
+  target: ProxyDraft,
+  key: string | number | symbol,
+  value: any
+) {
+  if (target.type === DraftType.Set || target.type === DraftType.Map) {
+    die(ErrorCode.CannotAssignToMapOrSet);
+  }
+  if (
+    target.type === DraftType.Array &&
+    key !== 'length' &&
+    !isArrayIndexKey(key)
+  ) {
+    die(ErrorCode.InvalidArrayIndex);
+  }
+  const source = latest(target);
+  // An own data property shadows any prototype setter, so the prototype
+  // chain only needs to be searched for keys the source does not own.
+  if (!hasOwn.call(source, key)) {
+    const desc = getDescriptor(source, key);
+    if (desc?.set) {
+      // !case: cover the case of setter
+      desc.set.call(target.proxy, value);
+      return true;
+    }
+  }
+  const current = source[key];
+  const currentProxyDraft = getProxyDraft(current);
+  const original = target.original;
+  if (currentProxyDraft && isEqual(currentProxyDraft.original, value)) {
+    // !case: assigning the original object of the draft at this key drops
+    // the draft. The key holds its original value again unless the draft
+    // was moved here from another key, in which case it is an assignment.
+    target.copy![key] = value;
+    target.assignedMap = target.assignedMap ?? new Map();
+    if (hasOwn.call(original, key) && isEqual(value, original[key])) {
+      target.assignedMap.delete(key);
+    } else {
+      markChanged(target);
+      target.assignedMap.set(key, true);
+      markFinalization(target, key, value);
+    }
+    return true;
+  }
+  // !case: handle new props with value 'undefined'
+  // The current copy decides whether the key exists: a key removed from the
+  // copy, by delete or by a shrinking array method, is added back by this
+  // assignment even when the original still has it.
+  if (
+    isEqual(value, current) &&
+    (value !== undefined || hasOwn.call(source, key)) &&
+    (target.arrayState === null || !isMovedElement(target, value, key))
+  )
+    return true;
+  ensureShallowCopy(target);
+  markChanged(target);
+  const arrayState = target.arrayState;
+  if (
+    arrayState !== null &&
+    ((typeof value === 'object' && value !== null) ||
+      typeof value === 'function')
+  ) {
+    arrayState.inert = null;
+  }
+  if (hasOwn.call(original, key) && isEqual(value, original[key])) {
+    // !case: handle the case of assigning the original non-draftable value to a draft
+    target.assignedMap!.delete(key);
+  } else {
+    target.assignedMap!.set(key, true);
+  }
+  // A longer length, or an index past the end, leaves holes behind.
+  const length = target.type === DraftType.Array ? target.copy!.length : -1;
+  target.copy![key] = value;
+  if (
+    length !== -1 &&
+    target.copy!.length > length + (key === 'length' ? 0 : 1)
+  ) {
+    resized(target, length);
+  }
+  markFinalization(target, key, value);
+  return true;
+}
+
+function hasTrap(target: ProxyDraft, key: string | symbol) {
+  return key in latest(target);
+}
+
+function ownKeysTrap(target: ProxyDraft) {
+  return Reflect.ownKeys(latest(target));
+}
+
+function getOwnPropertyDescriptorTrap(
+  target: ProxyDraft,
+  key: string | symbol
+) {
+  const source = latest(target);
+  const descriptor = Reflect.getOwnPropertyDescriptor(source, key);
+  if (!descriptor) return descriptor;
+  return {
+    writable: true,
+    configurable: target.type !== DraftType.Array || key !== 'length',
+    enumerable: descriptor.enumerable,
+    value: source[key],
+  };
+}
+
+function getPrototypeOfTrap(target: ProxyDraft) {
+  return Reflect.getPrototypeOf(target.original);
+}
+
+function setPrototypeOfTrap(): never {
+  die(ErrorCode.CannotSetPrototypeOfDraft);
+}
+
+function definePropertyTrap(): never {
+  die(ErrorCode.CannotDefinePropertyOnDraft);
+}
+
+function deletePropertyTrap(target: ProxyDraft, key: string | symbol) {
+  if (target.type === DraftType.Array) {
+    // A deleted index holds `undefined` afterwards. Deleting an index the
+    // array does not have changes nothing, as in JavaScript; assigning
+    // `undefined` to it would lengthen an array that the recipe shortened.
+    // Other keys reach the set trap, which rejects them.
+    if (!hasOwn.call(latest(target), key) && isArrayIndexKey(key)) return true;
+    return setTrap(target, key, undefined);
+  }
+  if (target.original[key] !== undefined || key in target.original) {
+    // !case: delete an existing key
+    ensureShallowCopy(target);
+    markChanged(target);
+    target.assignedMap!.set(key, false);
+  } else {
+    target.assignedMap = target.assignedMap ?? new Map();
+    // The original non-existent key has been deleted
+    target.assignedMap.delete(key);
+  }
+  if (target.copy) delete target.copy[key];
+  return true;
+}
+
+const objectHandler: ProxyHandler<ProxyDraft> = {
+  get: getTrap,
+  set: setTrap,
+  has: hasTrap,
+  ownKeys: ownKeysTrap,
+  getOwnPropertyDescriptor: getOwnPropertyDescriptorTrap,
+  getPrototypeOf: getPrototypeOfTrap,
+  setPrototypeOf: setPrototypeOfTrap,
+  defineProperty: definePropertyTrap,
+  deleteProperty: deletePropertyTrap,
+};
+
+// Array drafts use a one-element array as the proxy target so that
+// `Array.isArray(draft)` holds; these wrappers unwrap the state from it.
+const arrayHandler: ProxyHandler<[ProxyDraft]> = {};
+Object.keys(objectHandler).forEach((name) => {
+  const trap = objectHandler[name as keyof ProxyHandler<ProxyDraft>] as (
+    ...args: any[]
+  ) => any;
+  (arrayHandler as any)[name] = (target: [ProxyDraft], key: any, value: any) =>
+    trap(target[0], key, value);
+});
+
+export function createDraft<T extends object>(
+  original: T,
+  parentDraft: ProxyDraft | null,
+  key: string | number | symbol | undefined,
+  finalities: Finalities,
+  options: Options<any, any>
+): T {
+  const type = getType(original);
+  // Every field is initialized here so all draft states share one shape.
+  const proxyDraft: ProxyDraft = {
+    type,
+    finalized: false,
+    operated: false,
+    parent: parentDraft,
+    key,
+    original,
+    copy: null,
+    proxy: null,
+    finalities,
+    options,
+    // The drafts of a Set draft's items and the objects it added; see
+    // `src/set.ts`.
+    setMap: undefined,
+    assignedMap: undefined,
+    callbacks: undefined,
+    children: undefined,
+    child: null,
+    childKey: null,
+    arrayState: null,
+  };
+  const { proxy, revoke } =
+    type === DraftType.Array
+      ? Proxy.revocable<any>([proxyDraft], arrayHandler)
+      : Proxy.revocable<any>(proxyDraft, objectHandler);
+  finalities.revoke.push(revoke);
+  proxyDraft.proxy = proxy;
+  finalities.draft.push(proxyDraft);
+  return proxy;
+}
+
+internal.createDraft = createDraft;
+
+// Development builds warn once, in strict mode, when a producer leaves at
+// least this many drafts unchanged.
+const UNCHANGED_DRAFTS_WARNING_THRESHOLD = 1000;
+let unchangedDraftsWarned = false;
+
+/**
+ * Every object read through a draft becomes a draft, so a search through a
+ * large draft array creates one per element it visits. Drafts that are
+ * unchanged and still at the key they were read from count; elements that
+ * array methods drafted when removing or moving them do not. An object or
+ * array draft has a copy before it drafts a child.
+ */
+function warnUnchangedDrafts(finalities: Finalities) {
+  let count = 0;
+  for (const entry of finalities.draft) {
+    if (typeof entry !== 'function' && !entry.operated) {
+      const parent = entry.parent;
+      if (
+        parent !== null &&
+        (parent.type === DraftType.Array || parent.type === DraftType.Object) &&
+        parent.copy[entry.key!] === entry.proxy
+      ) {
+        count += 1;
+      }
+    }
+  }
+  if (count >= UNCHANGED_DRAFTS_WARNING_THRESHOLD) {
+    unchangedDraftsWarned = true;
+    console.warn(
+      `Strict mode: the recipe left ${count} drafts unchanged; every object read through a draft becomes one. For read-only scans of large arrays, search 'current(draft.list)' instead; see https://mutative.js.org/docs/api-reference/current`
+    );
+  }
+}
+
+export function finalizeDraft<T>(
+  result: T,
+  returnedValue: [T] | [],
+  patches?: Patches,
+  inversePatches?: Patches,
+  enableAutoFreeze?: boolean
+) {
+  const proxyDraft = getProxyDraft(result);
+  if (__DEV__ && proxyDraft?.options.strict && !unchangedDraftsWarned) {
+    warnUnchangedDrafts(proxyDraft.finalities);
+  }
+  const original = proxyDraft?.original ?? result;
+  const hasReturnedValue = !!returnedValue.length;
+  if (proxyDraft?.operated) {
+    const list = proxyDraft.finalities.draft;
+    while (list.length > 0) {
+      const entry = list.pop()!;
+      if (typeof entry === 'function') {
+        entry(patches, inversePatches);
+      } else {
+        finalizeNode(entry, generatePatches, patches, inversePatches);
+      }
+    }
+  }
+  const state = hasReturnedValue
+    ? returnedValue[0]
+    : proxyDraft
+      ? proxyDraft.operated
+        ? proxyDraft.copy
+        : proxyDraft.original
+      : result;
+  if (proxyDraft) revokeProxy(proxyDraft.finalities);
+  if (enableAutoFreeze) {
+    deepFreeze(state);
+  }
+  return [
+    state,
+    patches && hasReturnedValue
+      ? [{ op: Operation.Replace, path: [], value: returnedValue[0] }]
+      : patches,
+    inversePatches && hasReturnedValue
+      ? [{ op: Operation.Replace, path: [], value: original }]
+      : inversePatches,
+  ] as [T, Patches | undefined, Patches | undefined];
+}

package/node_modules/mutative/src/draftify.ts

@@ -0,0 +1,57 @@
+import {
+  Finalities,
+  Options,
+  Patches,
+  PatchesOptions,
+  Result,
+} from './interface';
+import { createDraft, finalizeDraft } from './draft';
+import { isDraftable } from './utils';
+import { dataTypes } from './constant';
+
+export function draftify<
+  T extends object,
+  O extends PatchesOptions = false,
+  F extends boolean = false,
+>(
+  baseState: T,
+  options: Options<O, F>
+): [T, (returnedValue: [T] | []) => Result<T, O, F>, Finalities] {
+  const finalities: Finalities = {
+    draft: [],
+    revoke: [],
+    handledSet: new WeakSet<any>(),
+    scoped: true,
+  };
+  let patches: Patches | undefined;
+  let inversePatches: Patches | undefined;
+  if (options.enablePatches) {
+    patches = [];
+    inversePatches = [];
+  }
+  const isMutable =
+    options.mark?.(baseState, dataTypes) === dataTypes.mutable ||
+    !isDraftable(baseState, options);
+  const draft = isMutable
+    ? baseState
+    : createDraft(baseState, null, undefined, finalities, options);
+  return [
+    draft,
+    (returnedValue: [T] | [] = []) => {
+      const [finalizedState, finalizedPatches, finalizedInversePatches] =
+        finalizeDraft(
+          draft,
+          returnedValue,
+          patches,
+          inversePatches,
+          options.enableAutoFreeze
+        );
+      return (
+        options.enablePatches
+          ? [finalizedState, finalizedPatches, finalizedInversePatches]
+          : finalizedState
+      ) as Result<T, O, F>;
+    },
+    finalities,
+  ];
+}

package/node_modules/mutative/src/error.ts

@@ -0,0 +1,129 @@
+/**
+ * Error codes are kept as a const enum so production builds can inline them.
+ * Verify that production bundles contain neither an `ErrorCode` object nor
+ * the member names when changing the build toolchain.
+ * Keep numeric codes stable; retired codes must not be reassigned.
+ */
+export const enum ErrorCode {
+  InvalidBaseState = 0,
+  CannotAssignToMapOrSet = 1,
+  InvalidArrayIndex = 2,
+  CannotSetPrototypeOfDraft = 3,
+  CannotDefinePropertyOnDraft = 4,
+  MutateAndReturn = 5,
+  CannotReturnModifiedChildDraft = 6,
+  CurrentOnNonDraft = 7,
+  StrictModeAccess = 8,
+  UnsupportedMarkResult = 9,
+  InvalidMark = 10,
+  CannotModifyFrozenObject = 11,
+  // 12 was InvalidPatchPath and is reserved for historical errors.
+  ReservedPatchAttribute = 13,
+  CannotApplyPatch = 14,
+  ReplacePatchOnSet = 15,
+  UnsupportedPatchOperation = 16,
+  ApplyOptionsToDraft = 17,
+  OriginalOnNonDraft = 18,
+  RawReturnWithoutValue = 19,
+  RawReturnWithExtraArguments = 20,
+  ReplaceMutableRoot = 21,
+}
+
+type ErrorArguments = {
+  [ErrorCode.InvalidBaseState]: [];
+  [ErrorCode.CannotAssignToMapOrSet]: [];
+  [ErrorCode.InvalidArrayIndex]: [];
+  [ErrorCode.CannotSetPrototypeOfDraft]: [];
+  [ErrorCode.CannotDefinePropertyOnDraft]: [];
+  [ErrorCode.MutateAndReturn]: [];
+  [ErrorCode.CannotReturnModifiedChildDraft]: [];
+  [ErrorCode.CurrentOnNonDraft]: [target: any];
+  [ErrorCode.StrictModeAccess]: [];
+  [ErrorCode.UnsupportedMarkResult]: [markResult: any];
+  [ErrorCode.InvalidMark]: [];
+  [ErrorCode.CannotModifyFrozenObject]: [];
+  [ErrorCode.ReservedPatchAttribute]: [];
+  [ErrorCode.CannotApplyPatch]: [path: (string | number)[]];
+  [ErrorCode.ReplacePatchOnSet]: [];
+  [ErrorCode.UnsupportedPatchOperation]: [op: string];
+  [ErrorCode.ApplyOptionsToDraft]: [];
+  [ErrorCode.OriginalOnNonDraft]: [target: any];
+  [ErrorCode.RawReturnWithoutValue]: [];
+  [ErrorCode.RawReturnWithExtraArguments]: [];
+  [ErrorCode.ReplaceMutableRoot]: [];
+};
+
+type ErrorBuilders = {
+  [Code in ErrorCode]: (...args: ErrorArguments[Code]) => string;
+};
+
+const errors: ErrorBuilders = __DEV__
+  ? [
+      // ErrorCode.InvalidBaseState
+      () =>
+        `Invalid base state: create() only supports plain objects, arrays, Set, Map or using mark() to mark the state as immutable.`,
+      // ErrorCode.CannotAssignToMapOrSet
+      () => `Map/Set draft does not support any property assignment.`,
+      // ErrorCode.InvalidArrayIndex
+      () => `Only supports setting array indices and the 'length' property.`,
+      // ErrorCode.CannotSetPrototypeOfDraft
+      () => `Cannot call 'setPrototypeOf()' on drafts`,
+      // ErrorCode.CannotDefinePropertyOnDraft
+      () => `Cannot call 'defineProperty()' on drafts`,
+      // ErrorCode.MutateAndReturn
+      () =>
+        `Either the value is returned as a new non-draft value, or only the draft is modified without returning any value.`,
+      // ErrorCode.CannotReturnModifiedChildDraft
+      () => `Cannot return a modified child draft.`,
+      // ErrorCode.CurrentOnNonDraft
+      (target) => `current() is only used for Draft, parameter: ${target}`,
+      // ErrorCode.StrictModeAccess
+      () =>
+        `Strict mode: Mutable data cannot be accessed directly, please use 'unsafe(callback)' wrap.`,
+      // ErrorCode.UnsupportedMarkResult
+      (markResult) => `Unsupported mark result: ${markResult}`,
+      // ErrorCode.InvalidMark
+      () =>
+        `Please check mark() to ensure that it is a stable marker draftable function.`,
+      // ErrorCode.CannotModifyFrozenObject
+      () => `Cannot modify frozen object`,
+      // Retired InvalidPatchPath (12).
+      undefined,
+      // ErrorCode.ReservedPatchAttribute
+      () =>
+        `Patching reserved attributes like __proto__ and constructor is not allowed.`,
+      // ErrorCode.CannotApplyPatch
+      (path) => `Cannot apply patch at '${path.join('/')}'.`,
+      // ErrorCode.ReplacePatchOnSet
+      () => `Cannot apply replace patch to set.`,
+      // ErrorCode.UnsupportedPatchOperation
+      (op) => `Unsupported patch operation: ${op}.`,
+      // ErrorCode.ApplyOptionsToDraft
+      () => `Cannot apply patches with options to a draft.`,
+      // ErrorCode.OriginalOnNonDraft
+      (target) => `original() is only used for a draft, parameter: ${target}`,
+      // ErrorCode.RawReturnWithoutValue
+      () => 'rawReturn() must be called with a value.',
+      // ErrorCode.RawReturnWithExtraArguments
+      () => 'rawReturn() must be called with one argument.',
+      // ErrorCode.ReplaceMutableRoot
+      () =>
+        'apply() with the mutable option changes the state in place, so a patch cannot replace the root state with another value.',
+    ]
+  : ([] as unknown as ErrorBuilders);
+
+export function die<Code extends ErrorCode>(
+  error: Code,
+  ...args: ErrorArguments[Code]
+): never {
+  if (__DEV__) {
+    throw new Error(
+      (errors[error] as (...builderArgs: ErrorArguments[Code]) => string)(
+        ...args
+      )
+    );
+  }
+  throw new Error(
+    `Minified Mutative error #${error}; visit https://mutative.js.org/docs/extra-topics/errors`
+  );
+}

package/node_modules/mutative/src/index.ts

@@ -0,0 +1,21 @@
+export { makeCreator } from './makeCreator';
+export { create } from './create';
+export { apply } from './apply';
+export { original } from './original';
+export { current } from './current';
+export { unsafe } from './unsafe';
+export { rawReturn } from './rawReturn';
+export { isDraft } from './utils/draft';
+export { isDraftable } from './utils/draft';
+export { markSimpleObject } from './utils/marker';
+
+export { castDraft, castImmutable, castMutable } from './utils/cast';
+export type {
+  Immutable,
+  Draft,
+  Patches,
+  Patch,
+  ExternalOptions as Options,
+  PatchesOptions,
+  DraftedObject,
+} from './interface';