@astrogate/sdk 0.0.0-stage → 0.1.0

package/node_modules/mutative/dist/apply.d.ts

@@ -0,0 +1,31 @@
+import type { Patches, ApplyImmutableOptions, ApplyMutableOptions, ApplyOptions, ApplyResult } from './interface';
+/**
+ * `apply(state, patches)` to apply patches to state
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { create, apply } from 'mutative';
+ *
+ * const baseState = { foo: { bar: 'str' }, arr: [] };
+ * const [state, patches] = create(
+ *   baseState,
+ *   (draft) => {
+ *     draft.foo.bar = 'str2';
+ *   },
+ *   { enablePatches: true }
+ * );
+ * expect(state).toEqual({ foo: { bar: 'str2' }, arr: [] });
+ * expect(patches).toEqual([{ op: 'replace', path: ['foo', 'bar'], value: 'str2' }]);
+ * expect(state).toEqual(apply(baseState, patches));
+ * ```
+ */
+export declare function apply<T extends object, F extends boolean = false, _A extends ApplyOptions<boolean> | undefined = ApplyImmutableOptions<F>>(state: T, patches: Patches, applyOptions?: undefined): ApplyResult<T, F, undefined>;
+export declare function apply<T extends object, F extends boolean = false, A extends ApplyOptions<boolean> | undefined = ApplyImmutableOptions<F>>(state: T, patches: Patches, applyOptions: A): ApplyResult<T, F, A>;
+export declare function apply<T extends object, F extends boolean = false, A extends ApplyOptions<boolean> | undefined = ApplyImmutableOptions<F>>(state: T, patches: Patches, applyOptions?: A): ApplyResult<T, F, A | undefined>;
+export declare function apply<T extends object, F extends boolean = false>(state: T, patches: Patches, applyOptions: {
+    mutable: true;
+}): ApplyResult<T, F, {
+    mutable: true;
+}>;
+export declare function apply<T extends object, F extends boolean = false>(state: T, patches: Patches, applyOptions: ApplyMutableOptions | undefined): ApplyResult<T, F, ApplyMutableOptions | undefined>;

package/node_modules/mutative/dist/array.d.ts

@@ -0,0 +1,45 @@
+import type { ProxyDraft } from './interface';
+/**
+ * Records that the get trap handed out an optimized method of `target`. Only
+ * a switch between arrays of a live producer adds a weak-collection entry, so
+ * the common case of one array per producer allocates nothing.
+ */
+export declare function trackArrayMethod(target: ProxyDraft): void;
+/**
+ * Called by `create` whenever a producer ends, normally or by an error, so
+ * this module keeps no reference to its drafts. Another producer's entry, such
+ * as an outer producer's, is left in place.
+ */
+export declare function releaseArrayMethods(revoke: unknown[]): void;
+/**
+ * The original index under which a read of `value` at `index` drafts it, or
+ * -1 when the read hands it out as is: an element at its original index, or,
+ * once native operations moved elements, any element of the original array
+ * except a value the recipe assigned at `index`, whose record moves along
+ * with it. Reads, searches and removals all decide by it.
+ */
+export declare function baseIndex(target: ProxyDraft, value: any, index: number): number;
+/**
+ * After the proxy lengthened an array draft, by its length or by an assignment
+ * past its end, holes follow. An index that the array exposes again below the
+ * original length lost its element to a shorter length earlier; no assignment
+ * records such an index, and a native move may have dropped one, so patches
+ * compare it. Marking the range as moved leaves reads as they are: an exposed
+ * index holds a hole, and an assigned value is handed out as it is.
+ */
+export declare function resized(target: ProxyDraft, previous: number): void;
+type Native = (...args: any[]) => any;
+/**
+ * Whether `value`, which the array already holds at `index`, is an element of
+ * the base state that native methods moved there. The proxy path moves
+ * elements by reading them, so it holds a draft there, and assigning the raw
+ * element replaces the draft and records an assignment; the set trap records
+ * one as well instead of ignoring the assignment.
+ */
+export declare function isMovedElement(target: ProxyDraft, value: any, index: any): boolean;
+/**
+ * Array methods without callbacks run natively on the draft's copy instead
+ * of moving every element through the proxy traps.
+ */
+export declare const arrayMethods: Record<PropertyKey, Native>;
+export {};

package/node_modules/mutative/dist/constant.d.ts

@@ -0,0 +1,8 @@
+export declare const PROXY_DRAFT: unique symbol;
+export declare const RAW_RETURN_SYMBOL: unique symbol;
+export declare const iteratorSymbol: typeof Symbol.iterator;
+export declare const iteratorPrototype: any;
+export declare const dataTypes: {
+    readonly mutable: "mutable";
+    readonly immutable: "immutable";
+};

package/node_modules/mutative/dist/create.d.ts

@@ -0,0 +1,46 @@
+/**
+ * `create(baseState, callback, options)` to create the next state
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { create } from 'mutative';
+ *
+ * const baseState = { foo: { bar: 'str' }, arr: [] };
+ * 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);
+ * ```
+ */
+declare const create: {
+    <T = never, F extends boolean = false, O extends import("./interface").PatchesOptions = false>(base: [T][T extends any ? 0 : never], mutate: [T] extends [never] ? never : (draft: import("./interface").Draft<[T][T extends any ? 0 : never]>) => ([[T][T extends any ? 0 : never]] extends [string | number | bigint | boolean | symbol | null | undefined] ? true : false) extends true ? Promise<void | [T][T extends any ? 0 : never] | import("./interface").Draft<[T][T extends any ? 0 : never]>> & {
+        readonly __mutativeAsyncContext: never;
+    } : (Promise<void | [T][T extends any ? 0 : never] | import("./interface").Draft<[T][T extends any ? 0 : never]>> & {
+        readonly __mutativeAsyncContext: never;
+    }) | (void | [T][T extends any ? 0 : never] | import("./interface").Draft<[T][T extends any ? 0 : never]>), options?: import("./interface").ExternalOptions<O, F> | undefined): import("./interface").Result<[T][T extends any ? 0 : never], O, F>;
+    <T = never, F extends boolean = false, O extends import("./interface").PatchesOptions = false>(base: [T][T extends any ? 0 : never], mutate: [T] extends [never] ? never : (draft: import("./interface").Draft<[T][T extends any ? 0 : never]>) => Promise<void | [T][T extends any ? 0 : never] | import("./interface").Draft<[T][T extends any ? 0 : never]>>, options?: import("./interface").ExternalOptions<O, F> | undefined): Promise<import("./interface").Result<[T][T extends any ? 0 : never], O, F>>;
+    <T = never, F extends boolean = false, O extends import("./interface").PatchesOptions = false>(base: [T][T extends any ? 0 : never], mutate: ([[T][T extends any ? 0 : never]] extends [string | number | bigint | boolean | symbol | null | undefined] ? true : false) extends true ? [T] extends [never] ? never : (draft: import("./interface").Draft<[T][T extends any ? 0 : never]>) => void | [T][T extends any ? 0 : never] | import("./interface").Draft<[T][T extends any ? 0 : never]> : never, options?: import("./interface").ExternalOptions<O, F> | undefined): import("./interface").Result<[T][T extends any ? 0 : never], O, F>;
+    <T = never, F extends boolean = false, O extends import("./interface").PatchesOptions = false>(base: [T][T extends any ? 0 : never], mutate: [T] extends [never] ? never : (draft: import("./interface").Draft<[T][T extends any ? 0 : never]>) => (void | [T][T extends any ? 0 : never] | import("./interface").Draft<[T][T extends any ? 0 : never]>) | Promise<void | [T][T extends any ? 0 : never] | import("./interface").Draft<[T][T extends any ? 0 : never]>>, options?: import("./interface").ExternalOptions<O, F> | undefined): import("./interface").Result<[T][T extends any ? 0 : never], O, F> | Promise<import("./interface").Result<[T][T extends any ? 0 : never], O, F>>;
+    <T extends unknown, F extends boolean = false, O extends import("./interface").PatchesOptions = false, R extends void | Promise<void> | T | Promise<T> = void>(base: T, mutate: (draft: import("./interface").Draft<T>) => R, options?: import("./interface").ExternalOptions<O, F> | undefined): import("./interface").CreateResult<T, O, F, R>;
+    <T extends unknown, F extends boolean = false, O extends import("./interface").PatchesOptions = false, R extends void | Promise<void> = void>(base: T, mutate: (draft: T) => R, options?: import("./interface").ExternalOptions<O, F> | undefined): import("./interface").CreateResult<T, O, F, R>;
+    <T = never, P extends any[] = [], F extends boolean = false, O extends import("./interface").PatchesOptions = false>(mutate: [T] extends [never] ? never : (draft: import("./interface").Draft<[T][T extends any ? 0 : never]>, ...args: P) => ([[T][T extends any ? 0 : never]] extends [string | number | bigint | boolean | symbol | null | undefined] ? true : false) extends true ? Promise<void | [T][T extends any ? 0 : never] | import("./interface").Draft<[T][T extends any ? 0 : never]>> & {
+        readonly __mutativeAsyncContext: never;
+    } : (Promise<void | [T][T extends any ? 0 : never] | import("./interface").Draft<[T][T extends any ? 0 : never]>> & {
+        readonly __mutativeAsyncContext: never;
+    }) | (void | [T][T extends any ? 0 : never] | import("./interface").Draft<[T][T extends any ? 0 : never]>), options?: import("./interface").ExternalOptions<O, F> | undefined): (base: [T][T extends any ? 0 : never], ...args: P) => import("./interface").Result<[T][T extends any ? 0 : never], O, F>;
+    <T = never, P extends any[] = [], F extends boolean = false, O extends import("./interface").PatchesOptions = false>(mutate: [T] extends [never] ? never : (draft: import("./interface").Draft<[T][T extends any ? 0 : never]>, ...args: P) => Promise<void | [T][T extends any ? 0 : never] | import("./interface").Draft<[T][T extends any ? 0 : never]>>, options?: import("./interface").ExternalOptions<O, F> | undefined): (base: [T][T extends any ? 0 : never], ...args: P) => Promise<import("./interface").Result<[T][T extends any ? 0 : never], O, F>>;
+    <T = never, P extends any[] = [], F extends boolean = false, O extends import("./interface").PatchesOptions = false>(mutate: ([[T][T extends any ? 0 : never]] extends [string | number | bigint | boolean | symbol | null | undefined] ? true : false) extends true ? [T] extends [never] ? never : (draft: import("./interface").Draft<[T][T extends any ? 0 : never]>, ...args: P) => void | [T][T extends any ? 0 : never] | import("./interface").Draft<[T][T extends any ? 0 : never]> : never, options?: import("./interface").ExternalOptions<O, F> | undefined): (base: [T][T extends any ? 0 : never], ...args: P) => import("./interface").Result<[T][T extends any ? 0 : never], O, F>;
+    <T = never, P extends any[] = [], F extends boolean = false, O extends import("./interface").PatchesOptions = false>(mutate: [T] extends [never] ? never : (draft: import("./interface").Draft<[T][T extends any ? 0 : never]>, ...args: P) => (void | [T][T extends any ? 0 : never] | import("./interface").Draft<[T][T extends any ? 0 : never]>) | Promise<void | [T][T extends any ? 0 : never] | import("./interface").Draft<[T][T extends any ? 0 : never]>>, options?: import("./interface").ExternalOptions<O, F> | undefined): (base: [T][T extends any ? 0 : never], ...args: P) => import("./interface").Result<[T][T extends any ? 0 : never], O, F> | Promise<import("./interface").Result<[T][T extends any ? 0 : never], O, F>>;
+    <T extends unknown, P extends any[] = [], F extends boolean = false, O extends import("./interface").PatchesOptions = false, R extends void | Promise<void> | T | Promise<T> = void>(mutate: (draft: import("./interface").Draft<T>, ...args: P) => R, options?: import("./interface").ExternalOptions<O, F> | undefined): (base: T, ...args: P) => import("./interface").CreateResult<T, O, F, R>;
+    <T extends unknown, P extends any[] = [], F extends boolean = false, O extends import("./interface").PatchesOptions = false, R extends void | Promise<void> | T | Promise<T> = void>(mutate: (draft: T, ...args: P) => R, options?: import("./interface").ExternalOptions<O, F> | undefined): (base: T, ...args: P) => import("./interface").CreateResult<T, O, F, R>;
+    <T extends unknown, O extends import("./interface").PatchesOptions = false, F extends boolean = false>(base: T, options?: import("./interface").ExternalOptions<O, F> | undefined): [import("./interface").Draft<T>, () => import("./interface").Result<T, O, F>];
+};
+export { create };

package/node_modules/mutative/dist/current.d.ts

@@ -0,0 +1,23 @@
+import { type Draft, type ProxyDraft } from './interface';
+export declare function handleReturnValue(rootDraft: ProxyDraft<any> | undefined, value: object, useRawReturn?: boolean): void;
+/**
+ * `current(draft)` to get current state in the draft mutation function.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { create, current } from 'mutative';
+ *
+ * const baseState = { foo: { bar: 'str' }, arr: [] };
+ * const state = create(
+ *   baseState,
+ *   (draft) => {
+ *     draft.foo.bar = 'str2';
+ *     expect(current(draft.foo)).toEqual({ bar: 'str2' });
+ *   },
+ * );
+ * ```
+ */
+export declare function current<T extends object>(target: Draft<T>): T;
+/** @deprecated You should call current only on `Draft<T>` types. */
+export declare function current<T extends object>(target: T): T;

package/node_modules/mutative/dist/draft.d.ts

@@ -0,0 +1,3 @@
+import { Finalities, Patches, ProxyDraft, Options } from './interface';
+export declare function createDraft<T extends object>(original: T, parentDraft: ProxyDraft | null, key: string | number | symbol | undefined, finalities: Finalities, options: Options<any, any>): T;
+export declare function finalizeDraft<T>(result: T, returnedValue: [T] | [], patches?: Patches, inversePatches?: Patches, enableAutoFreeze?: boolean): [T, Patches | undefined, Patches | undefined];

package/node_modules/mutative/dist/draftify.d.ts

@@ -0,0 +1,2 @@
+import { Finalities, Options, PatchesOptions, Result } from './interface';
+export declare 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];

package/node_modules/mutative/dist/error.d.ts

@@ -0,0 +1,54 @@
+/**
+ * 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 declare 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,
+    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]: [];
+};
+export declare function die<Code extends ErrorCode>(error: Code, ...args: ErrorArguments[Code]): never;
+export {};

package/node_modules/mutative/dist/index.d.mts

@@ -0,0 +1 @@
+export * from './index.js';

package/node_modules/mutative/dist/index.d.ts

@@ -0,0 +1,12 @@
+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';

package/node_modules/mutative/dist/index.js

@@ -0,0 +1,8 @@
+
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./mutative.cjs.production.min.js')
+} else {
+  module.exports = require('./mutative.cjs.development.js')
+}

package/node_modules/mutative/dist/index.mjs

@@ -0,0 +1,3 @@
+import mutative from './index.js';
+
+export const { apply, castDraft, castImmutable, castMutable, create, current, isDraft, isDraftable, makeCreator, markSimpleObject, original, rawReturn, unsafe } = mutative;

package/node_modules/mutative/dist/interface.d.ts

@@ -0,0 +1,200 @@
+import { dataTypes } from './constant';
+export declare const enum DraftType {
+    Object = 0,
+    Array = 1,
+    Map = 2,
+    Set = 3
+}
+export declare const Operation: {
+    readonly Remove: "remove";
+    readonly Replace: "replace";
+    readonly Add: "add";
+};
+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: (ProxyDraft | FinalizeCallback)[];
+    revoke: (() => void)[];
+    handledSet: WeakSet<any>;
+    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;
+    setMap: (Map<any, any> & {
+        items?: any[];
+    }) | undefined;
+    assignedMap: Map<any, boolean> | undefined;
+    callbacks: FinalizeCallback[] | undefined;
+    children: any;
+    child: any;
+    childKey: any;
+    arrayState: ArrayState | null;
+}
+export interface ArrayState {
+    relocated: boolean;
+    diffStart: number;
+    diffEnd: number;
+    baseRefs: Map<any, number> | null;
+    delta: number | undefined;
+    lookups: number;
+    inert: boolean | null;
+    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>;
+}
+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;
+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;
+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>;
+export {};

package/node_modules/mutative/dist/internal.d.ts

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

package/node_modules/mutative/dist/makeCreator.d.ts

@@ -0,0 +1,54 @@
+import { CreateResult, Draft, ExternalOptions, PatchesOptions, Result } from './interface';
+type ExplicitState<T> = [T][T extends any ? 0 : never];
+type ExplicitReturn<T> = void | ExplicitState<T> | Draft<ExplicitState<T>>;
+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;
+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>) => {
+    <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>>;
+    <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>;
+    <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>;
+    <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>];
+};
+/**
+ * `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 declare const makeCreator: MakeCreator;
+export {};

package/node_modules/mutative/dist/map.d.ts

@@ -0,0 +1,15 @@
+import { iteratorSymbol } from './constant';
+export declare const mapHandler: {
+    readonly size: number;
+    has(key: any): boolean;
+    set(key: any, value: any): /*elided*/ any;
+    delete(key: any): boolean;
+    clear(): void;
+    forEach(callback: (value: any, key: any, self: any) => void, thisArg?: any): void;
+    get(key: any): any;
+    keys(): IterableIterator<any>;
+    values(): IterableIterator<any>;
+    entries(): IterableIterator<[any, any]>;
+    [Symbol.iterator](): IterableIterator<[any, any]>;
+};
+export declare const mapHandlerKeys: (string | symbol)[];