@vve/immer 9.0.0-alpha.3 → 9.0.0-alpha.5

package/lib/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","names":["NOTHING","Symbol","exports","DRAFTABLE","for","DRAFT_STATE","isDraft","value","isDraftable","Array","isArray","proto","Object","getPrototypeOf","prototype","constructor","original","base","assign","target","key","has","ownKeys","Reflect","getOwnPropertySymbols","obj","getOwnPropertyNames","concat","shallowCopy","invokeGetters","arguments","length","undefined","slice","clone","create","forEach","desc","getOwnPropertyDescriptor","get","Error","call","enumerable","defineProperty","writable","configurable","each","cb","i","isEnumerable","prop","thing","hasOwnProperty","is","x","y"],"sources":["../common.js"],"sourcesContent":["export const NOTHING =\n    typeof Symbol !== \"undefined\"\n        ? Symbol(\"immer-nothing\")\n        : {[\"immer-nothing\"]: true}\n\nexport const DRAFTABLE =\n    typeof Symbol !== \"undefined\" && Symbol.for\n        ? Symbol.for(\"immer-draftable\")\n        : \"__$immer_draftable\"\n\nexport const DRAFT_STATE =\n    typeof Symbol !== \"undefined\" && Symbol.for\n        ? Symbol.for(\"immer-state\")\n        : \"__$immer_state\"\n\nexport function isDraft(value) {\n    return !!value && !!value[DRAFT_STATE]\n}\n\nexport function isDraftable(value) {\n    if (!value || typeof value !== \"object\") return false\n    if (Array.isArray(value)) return true\n    const proto = Object.getPrototypeOf(value)\n    if (!proto || proto === Object.prototype) return true\n    return !!value[DRAFTABLE] || !!value.constructor[DRAFTABLE]\n}\n\nexport function original(value) {\n    if (value && value[DRAFT_STATE]) {\n        return value[DRAFT_STATE].base\n    }\n    // otherwise return undefined\n}\n\nexport const assign =\n    Object.assign ||\n    function assign(target, value) {\n        for (let key in value) {\n            if (has(value, key)) {\n                target[key] = value[key]\n            }\n        }\n        return target\n    }\n\nexport const ownKeys =\n    typeof Reflect !== \"undefined\" && Reflect.ownKeys\n        ? Reflect.ownKeys\n        : typeof Object.getOwnPropertySymbols !== \"undefined\"\n        ? obj =>\n              Object.getOwnPropertyNames(obj).concat(\n                  Object.getOwnPropertySymbols(obj)\n              )\n        : Object.getOwnPropertyNames\n\nexport function shallowCopy(base, invokeGetters = false) {\n    if (Array.isArray(base)) return base.slice()\n    const clone = Object.create(Object.getPrototypeOf(base))\n    ownKeys(base).forEach(key => {\n        if (key === DRAFT_STATE) {\n            return // Never copy over draft state.\n        }\n        const desc = Object.getOwnPropertyDescriptor(base, key)\n        let {value} = desc\n        if (desc.get) {\n            if (!invokeGetters) {\n                throw new Error(\"Immer drafts cannot have computed properties\")\n            }\n            value = desc.get.call(base)\n        }\n        if (desc.enumerable) {\n            clone[key] = value\n        } else {\n            Object.defineProperty(clone, key, {\n                value,\n                writable: true,\n                configurable: true\n            })\n        }\n    })\n    return clone\n}\n\nexport function each(value, cb) {\n    if (Array.isArray(value)) {\n        for (let i = 0; i < value.length; i++) cb(i, value[i], value)\n    } else {\n        ownKeys(value).forEach(key => cb(key, value[key], value))\n    }\n}\n\nexport function isEnumerable(base, prop) {\n    const desc = Object.getOwnPropertyDescriptor(base, prop)\n    return !!desc && desc.enumerable\n}\n\nexport function has(thing, prop) {\n    return Object.prototype.hasOwnProperty.call(thing, prop)\n}\n\nexport function is(x, y) {\n    // From: https://github.com/facebook/fbjs/blob/c69904a511b900266935168223063dd8772dfc40/packages/fbjs/src/core/shallowEqual.js\n    if (x === y) {\n        return x !== 0 || 1 / x === 1 / y\n    } else {\n        return x !== x && y !== y\n    }\n}\n"],"mappings":"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"}

package/lib/es5.js

@@ -0,0 +1,246 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createProxy = createProxy;
+exports.willFinalize = willFinalize;
+var _common = require("./common");
+var _scope = require("./scope");
+// property descriptors are recycled to make sure we don't create a get and set closure per property,
+// but share them all instead
+var descriptors = {};
+var noop = () => {};
+function willFinalize(scope, result, isReplaced) {
+  scope.drafts.forEach(draft => {
+    draft[_common.DRAFT_STATE].finalizing = true;
+  });
+  if (!isReplaced) {
+    if (scope.patches) {
+      markChangesRecursively(scope.drafts[0]);
+    }
+    // This is faster when we don't care about which attributes changed.
+    markChangesSweep(scope.drafts);
+  }
+  // When a child draft is returned, look for changes.
+  else if ((0, _common.isDraft)(result) && result[_common.DRAFT_STATE].scope === scope) {
+    markChangesSweep(scope.drafts);
+  }
+}
+function createProxy(base, parent) {
+  var isArray = Array.isArray(base);
+  var draft = clonePotentialDraft(base);
+  (0, _common.each)(draft, prop => {
+    proxyProperty(draft, prop, isArray || (0, _common.isEnumerable)(base, prop));
+  });
+
+  // See "proxy.js" for property documentation.
+  var scope = parent ? parent.scope : _scope.ImmerScope.current;
+  var state = {
+    scope,
+    modified: false,
+    finalizing: false,
+    // es5 only
+    finalized: false,
+    assigned: {},
+    parent,
+    base,
+    draft,
+    copy: null,
+    revoke,
+    revoked: false // es5 only
+  };
+
+  createHiddenProperty(draft, _common.DRAFT_STATE, state);
+  scope.drafts.push(draft);
+  return draft;
+}
+function revoke() {
+  this.revoked = true;
+}
+function source(state) {
+  return state.copy || state.base;
+}
+
+// Access a property without creating an Immer draft.
+function peek(draft, prop) {
+  var state = draft[_common.DRAFT_STATE];
+  if (state && !state.finalizing) {
+    state.finalizing = true;
+    var value = draft[prop];
+    state.finalizing = false;
+    return value;
+  }
+  return draft[prop];
+}
+function get(state, prop) {
+  assertUnrevoked(state);
+  var value = peek(source(state), prop);
+  if (state.finalizing) return value;
+  // Create a draft if the value is unmodified.
+  if (value === peek(state.base, prop) && (0, _common.isDraftable)(value)) {
+    prepareCopy(state);
+    return state.copy[prop] = createProxy(value, state);
+  }
+  return value;
+}
+function set(state, prop, value) {
+  assertUnrevoked(state);
+  state.assigned[prop] = true;
+  if (!state.modified) {
+    if ((0, _common.is)(value, peek(source(state), prop))) return;
+    markChanged(state);
+    prepareCopy(state);
+  }
+  state.copy[prop] = value;
+}
+function markChanged(state) {
+  if (!state.modified) {
+    state.modified = true;
+    if (state.parent) markChanged(state.parent);
+  }
+}
+function prepareCopy(state) {
+  if (!state.copy) state.copy = clonePotentialDraft(state.base);
+}
+function clonePotentialDraft(base) {
+  var state = base && base[_common.DRAFT_STATE];
+  if (state) {
+    state.finalizing = true;
+    var draft = (0, _common.shallowCopy)(state.draft, true);
+    state.finalizing = false;
+    return draft;
+  }
+  return (0, _common.shallowCopy)(base);
+}
+function proxyProperty(draft, prop, enumerable) {
+  var desc = descriptors[prop];
+  if (desc) {
+    desc.enumerable = enumerable;
+  } else {
+    descriptors[prop] = desc = {
+      configurable: true,
+      enumerable,
+      get() {
+        return get(this[_common.DRAFT_STATE], prop);
+      },
+      set(value) {
+        set(this[_common.DRAFT_STATE], prop, value);
+      }
+    };
+  }
+  Object.defineProperty(draft, prop, desc);
+}
+function assertUnrevoked(state) {
+  if (state.revoked === true) throw new Error("Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + JSON.stringify(source(state)));
+}
+
+// This looks expensive, but only proxies are visited, and only objects without known changes are scanned.
+function markChangesSweep(drafts) {
+  // The natural order of drafts in the `scope` array is based on when they
+  // were accessed. By processing drafts in reverse natural order, we have a
+  // better chance of processing leaf nodes first. When a leaf node is known to
+  // have changed, we can avoid any traversal of its ancestor nodes.
+  for (var i = drafts.length - 1; i >= 0; i--) {
+    var state = drafts[i][_common.DRAFT_STATE];
+    if (!state.modified) {
+      if (Array.isArray(state.base)) {
+        if (hasArrayChanges(state)) markChanged(state);
+      } else if (hasObjectChanges(state)) markChanged(state);
+    }
+  }
+}
+function markChangesRecursively(object) {
+  if (!object || typeof object !== "object") return;
+  var state = object[_common.DRAFT_STATE];
+  if (!state) return;
+  var base = state.base,
+    draft = state.draft,
+    assigned = state.assigned;
+  if (!Array.isArray(object)) {
+    // Look for added keys.
+    Object.keys(draft).forEach(key => {
+      // The `undefined` check is a fast path for pre-existing keys.
+      if (base[key] === undefined && !(0, _common.has)(base, key)) {
+        assigned[key] = true;
+        markChanged(state);
+      } else if (!assigned[key]) {
+        // Only untouched properties trigger recursion.
+        markChangesRecursively(draft[key]);
+      }
+    });
+    // Look for removed keys.
+    Object.keys(base).forEach(key => {
+      // The `undefined` check is a fast path for pre-existing keys.
+      if (draft[key] === undefined && !(0, _common.has)(draft, key)) {
+        assigned[key] = false;
+        markChanged(state);
+      }
+    });
+  } else if (hasArrayChanges(state)) {
+    markChanged(state);
+    assigned.length = true;
+    if (draft.length < base.length) {
+      for (var i = draft.length; i < base.length; i++) assigned[i] = false;
+    } else {
+      for (var _i = base.length; _i < draft.length; _i++) assigned[_i] = true;
+    }
+    for (var _i2 = 0; _i2 < draft.length; _i2++) {
+      // Only untouched indices trigger recursion.
+      if (assigned[_i2] === undefined) markChangesRecursively(draft[_i2]);
+    }
+  }
+}
+function hasObjectChanges(state) {
+  var base = state.base,
+    draft = state.draft;
+
+  // Search for added keys and changed keys. Start at the back, because
+  // non-numeric keys are ordered by time of definition on the object.
+  var keys = Object.keys(draft);
+  for (var i = keys.length - 1; i >= 0; i--) {
+    var key = keys[i];
+    var baseValue = base[key];
+    // The `undefined` check is a fast path for pre-existing keys.
+    if (baseValue === undefined && !(0, _common.has)(base, key)) {
+      return true;
+    }
+    // Once a base key is deleted, future changes go undetected, because its
+    // descriptor is erased. This branch detects any missed changes.
+    else {
+      var value = draft[key];
+      var _state = value && value[_common.DRAFT_STATE];
+      if (_state ? _state.base !== baseValue : !(0, _common.is)(value, baseValue)) {
+        return true;
+      }
+    }
+  }
+
+  // At this point, no keys were added or changed.
+  // Compare key count to determine if keys were deleted.
+  return keys.length !== Object.keys(base).length;
+}
+function hasArrayChanges(state) {
+  var draft = state.draft;
+  if (draft.length !== state.base.length) return true;
+  // See #116
+  // If we first shorten the length, our array interceptors will be removed.
+  // If after that new items are added, result in the same original length,
+  // those last items will have no intercepting property.
+  // So if there is no own descriptor on the last position, we know that items were removed and added
+  // N.B.: splice, unshift, etc only shift values around, but not prop descriptors, so we only have to check
+  // the last one
+  var descriptor = Object.getOwnPropertyDescriptor(draft, draft.length - 1);
+  // descriptor can be null, but only for newly created sparse arrays, eg. new Array(10)
+  if (descriptor && !descriptor.get) return true;
+  // For all other cases, we don't have to compare, as they would have been picked up by the index setters
+  return false;
+}
+function createHiddenProperty(target, prop, value) {
+  Object.defineProperty(target, prop, {
+    value: value,
+    enumerable: false,
+    writable: true
+  });
+}
+//# sourceMappingURL=es5.js.map

package/lib/es5.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"es5.js","names":["Object","defineProperty","exports","value","createProxy","willFinalize","_common","require","_scope","descriptors","noop","scope","result","isReplaced","drafts","forEach","draft","DRAFT_STATE","finalizing","patches","markChangesRecursively","markChangesSweep","isDraft","base","parent","isArray","Array","clonePotentialDraft","each","prop","proxyProperty","isEnumerable","ImmerScope","current","state","modified","finalized","assigned","copy","revoke","revoked","createHiddenProperty","push","source","peek","get","assertUnrevoked","isDraftable","prepareCopy","set","is","markChanged","shallowCopy","enumerable","desc","configurable","Error","JSON","stringify","i","length","hasArrayChanges","hasObjectChanges","object","keys","key","undefined","has","baseValue","descriptor","getOwnPropertyDescriptor","target","writable"],"sources":["../es5.js"],"sourcesContent":["\"use strict\"\nimport {\n    each,\n    has,\n    is,\n    isDraft,\n    isDraftable,\n    isEnumerable,\n    shallowCopy,\n    DRAFT_STATE\n} from \"./common\"\nimport {ImmerScope} from \"./scope\"\n\n// property descriptors are recycled to make sure we don't create a get and set closure per property,\n// but share them all instead\nconst descriptors = {}\nconst noop = () => {}\n\nexport function willFinalize(scope, result, isReplaced) {\n    scope.drafts.forEach(draft => {\n        draft[DRAFT_STATE].finalizing = true\n    })\n    if (!isReplaced) {\n        if (scope.patches) {\n            markChangesRecursively(scope.drafts[0])\n        }\n        // This is faster when we don't care about which attributes changed.\n        markChangesSweep(scope.drafts)\n    }\n    // When a child draft is returned, look for changes.\n    else if (isDraft(result) && result[DRAFT_STATE].scope === scope) {\n        markChangesSweep(scope.drafts)\n    }\n}\n\nexport function createProxy(base, parent) {\n    const isArray = Array.isArray(base)\n    const draft = clonePotentialDraft(base)\n    each(draft, prop => {\n        proxyProperty(draft, prop, isArray || isEnumerable(base, prop))\n    })\n\n    // See \"proxy.js\" for property documentation.\n    const scope = parent ? parent.scope : ImmerScope.current\n    const state = {\n        scope,\n        modified: false,\n        finalizing: false, // es5 only\n        finalized: false,\n        assigned: {},\n        parent,\n        base,\n        draft,\n        copy: null,\n        revoke,\n        revoked: false // es5 only\n    }\n\n    createHiddenProperty(draft, DRAFT_STATE, state)\n    scope.drafts.push(draft)\n    return draft\n}\n\nfunction revoke() {\n    this.revoked = true\n}\n\nfunction source(state) {\n    return state.copy || state.base\n}\n\n// Access a property without creating an Immer draft.\nfunction peek(draft, prop) {\n    const state = draft[DRAFT_STATE]\n    if (state && !state.finalizing) {\n        state.finalizing = true\n        const value = draft[prop]\n        state.finalizing = false\n        return value\n    }\n    return draft[prop]\n}\n\nfunction get(state, prop) {\n    assertUnrevoked(state)\n    const value = peek(source(state), prop)\n    if (state.finalizing) return value\n    // Create a draft if the value is unmodified.\n    if (value === peek(state.base, prop) && isDraftable(value)) {\n        prepareCopy(state)\n        return (state.copy[prop] = createProxy(value, state))\n    }\n    return value\n}\n\nfunction set(state, prop, value) {\n    assertUnrevoked(state)\n    state.assigned[prop] = true\n    if (!state.modified) {\n        if (is(value, peek(source(state), prop))) return\n        markChanged(state)\n        prepareCopy(state)\n    }\n    state.copy[prop] = value\n}\n\nfunction markChanged(state) {\n    if (!state.modified) {\n        state.modified = true\n        if (state.parent) markChanged(state.parent)\n    }\n}\n\nfunction prepareCopy(state) {\n    if (!state.copy) state.copy = clonePotentialDraft(state.base)\n}\n\nfunction clonePotentialDraft(base) {\n    const state = base && base[DRAFT_STATE]\n    if (state) {\n        state.finalizing = true\n        const draft = shallowCopy(state.draft, true)\n        state.finalizing = false\n        return draft\n    }\n    return shallowCopy(base)\n}\n\nfunction proxyProperty(draft, prop, enumerable) {\n    let desc = descriptors[prop]\n    if (desc) {\n        desc.enumerable = enumerable\n    } else {\n        descriptors[prop] = desc = {\n            configurable: true,\n            enumerable,\n            get() {\n                return get(this[DRAFT_STATE], prop)\n            },\n            set(value) {\n                set(this[DRAFT_STATE], prop, value)\n            }\n        }\n    }\n    Object.defineProperty(draft, prop, desc)\n}\n\nfunction assertUnrevoked(state) {\n    if (state.revoked === true)\n        throw new Error(\n            \"Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? \" +\n                JSON.stringify(source(state))\n        )\n}\n\n// This looks expensive, but only proxies are visited, and only objects without known changes are scanned.\nfunction markChangesSweep(drafts) {\n    // The natural order of drafts in the `scope` array is based on when they\n    // were accessed. By processing drafts in reverse natural order, we have a\n    // better chance of processing leaf nodes first. When a leaf node is known to\n    // have changed, we can avoid any traversal of its ancestor nodes.\n    for (let i = drafts.length - 1; i >= 0; i--) {\n        const state = drafts[i][DRAFT_STATE]\n        if (!state.modified) {\n            if (Array.isArray(state.base)) {\n                if (hasArrayChanges(state)) markChanged(state)\n            } else if (hasObjectChanges(state)) markChanged(state)\n        }\n    }\n}\n\nfunction markChangesRecursively(object) {\n    if (!object || typeof object !== \"object\") return\n    const state = object[DRAFT_STATE]\n    if (!state) return\n    const {base, draft, assigned} = state\n    if (!Array.isArray(object)) {\n        // Look for added keys.\n        Object.keys(draft).forEach(key => {\n            // The `undefined` check is a fast path for pre-existing keys.\n            if (base[key] === undefined && !has(base, key)) {\n                assigned[key] = true\n                markChanged(state)\n            } else if (!assigned[key]) {\n                // Only untouched properties trigger recursion.\n                markChangesRecursively(draft[key])\n            }\n        })\n        // Look for removed keys.\n        Object.keys(base).forEach(key => {\n            // The `undefined` check is a fast path for pre-existing keys.\n            if (draft[key] === undefined && !has(draft, key)) {\n                assigned[key] = false\n                markChanged(state)\n            }\n        })\n    } else if (hasArrayChanges(state)) {\n        markChanged(state)\n        assigned.length = true\n        if (draft.length < base.length) {\n            for (let i = draft.length; i < base.length; i++) assigned[i] = false\n        } else {\n            for (let i = base.length; i < draft.length; i++) assigned[i] = true\n        }\n        for (let i = 0; i < draft.length; i++) {\n            // Only untouched indices trigger recursion.\n            if (assigned[i] === undefined) markChangesRecursively(draft[i])\n        }\n    }\n}\n\nfunction hasObjectChanges(state) {\n    const {base, draft} = state\n\n    // Search for added keys and changed keys. Start at the back, because\n    // non-numeric keys are ordered by time of definition on the object.\n    const keys = Object.keys(draft)\n    for (let i = keys.length - 1; i >= 0; i--) {\n        const key = keys[i]\n        const baseValue = base[key]\n        // The `undefined` check is a fast path for pre-existing keys.\n        if (baseValue === undefined && !has(base, key)) {\n            return true\n        }\n        // Once a base key is deleted, future changes go undetected, because its\n        // descriptor is erased. This branch detects any missed changes.\n        else {\n            const value = draft[key]\n            const state = value && value[DRAFT_STATE]\n            if (state ? state.base !== baseValue : !is(value, baseValue)) {\n                return true\n            }\n        }\n    }\n\n    // At this point, no keys were added or changed.\n    // Compare key count to determine if keys were deleted.\n    return keys.length !== Object.keys(base).length\n}\n\nfunction hasArrayChanges(state) {\n    const {draft} = state\n    if (draft.length !== state.base.length) return true\n    // See #116\n    // If we first shorten the length, our array interceptors will be removed.\n    // If after that new items are added, result in the same original length,\n    // those last items will have no intercepting property.\n    // So if there is no own descriptor on the last position, we know that items were removed and added\n    // N.B.: splice, unshift, etc only shift values around, but not prop descriptors, so we only have to check\n    // the last one\n    const descriptor = Object.getOwnPropertyDescriptor(draft, draft.length - 1)\n    // descriptor can be null, but only for newly created sparse arrays, eg. new Array(10)\n    if (descriptor && !descriptor.get) return true\n    // For all other cases, we don't have to compare, as they would have been picked up by the index setters\n    return false\n}\n\nfunction createHiddenProperty(target, prop, value) {\n    Object.defineProperty(target, prop, {\n        value: value,\n        enumerable: false,\n        writable: true\n    })\n}\n"],"mappings":"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"}

package/lib/immer.d.ts

@@ -0,0 +1,248 @@
+type Tail<T extends any[]> = ((...t: T) => any) extends ((
+    _: any,
+    ...tail: infer TT
+) => any)
+    ? TT
+    : []
+
+/** Object types that should never be mapped */
+type AtomicObject =
+    | Function
+    | Map<any, any>
+    | WeakMap<any, any>
+    | Set<any>
+    | WeakSet<any>
+    | Promise<any>
+    | Date
+    | RegExp
+    | Boolean
+    | Number
+    | String
+
+export type Draft<T> = T extends AtomicObject
+    ? T
+    : T extends object
+    ? {-readonly [K in keyof T]: Draft<T[K]>}
+    : T
+
+/** Convert a mutable type into a readonly type */
+export type Immutable<T> = T extends AtomicObject
+    ? T
+    : T extends object
+    ? {readonly [K in keyof T]: Immutable<T[K]>}
+    : T
+
+export interface Patch {
+    op: "replace" | "remove" | "add"
+    path: (string | number)[]
+    value?: any
+}
+
+export type PatchListener = (patches: Patch[], inversePatches: Patch[]) => void
+
+/** Converts `nothing` into `undefined` */
+type FromNothing<T> = T extends Nothing ? undefined : T
+
+/** The inferred return type of `produce` */
+export type Produced<Base, Return> = Return extends void
+    ? Base
+    : Return extends Promise<infer Result>
+    ? Promise<Result extends void ? Base : FromNothing<Result>>
+    : FromNothing<Return>
+
+/**
+ * The `produce` function takes a value and a "recipe function" (whose
+ * return value often depends on the base state). The recipe function is
+ * free to mutate its first argument however it wants. All mutations are
+ * only ever applied to a __copy__ of the base state.
+ *
+ * Pass only a function to create a "curried producer" which relieves you
+ * from passing the recipe function every time.
+ *
+ * Only plain objects and arrays are made mutable. All other objects are
+ * considered uncopyable.
+ *
+ * Note: This function is __bound__ to its `Immer` instance.
+ *
+ * @param {any} base - the initial state
+ * @param {Function} producer - function that receives a proxy of the base state as first argument and which can be freely modified
+ * @param {Function} patchListener - optional function that will be called with all the patches produced here
+ * @returns {any} a new state, or the initial state if nothing was modified
+ */
+export interface IProduce {
+    /** Curried producer */
+    <
+        Recipe extends (...args: any[]) => any,
+        Params extends any[] = Parameters<Recipe>,
+        T = Params[0]
+    >(
+        recipe: Recipe
+    ): <Base extends Immutable<T>>(
+        base: Base,
+        ...rest: Tail<Params>
+    ) => Produced<Base, ReturnType<Recipe>>
+    //   ^ by making the returned type generic, the actual type of the passed in object is preferred
+    //     over the type used in the recipe. However, it does have to satisfy the immutable version used in the recipe
+    //     Note: the type of S is the widened version of T, so it can have more props than T, but that is technically actually correct!
+
+    /** Curried producer with initial state */
+    <
+        Recipe extends (...args: any[]) => any,
+        Params extends any[] = Parameters<Recipe>,
+        T = Params[0]
+    >(
+        recipe: Recipe,
+        initialState: Immutable<T>
+    ): <Base extends Immutable<T>>(
+        base?: Base,
+        ...rest: Tail<Params>
+    ) => Produced<Base, ReturnType<Recipe>>
+
+    /** Normal producer */
+    <Base, D = Draft<Base>, Return = void>(
+        base: Base,
+        recipe: (draft: D) => Return,
+        listener?: PatchListener
+    ): Produced<Base, Return>
+}
+
+export const produce: IProduce
+export default produce
+
+/** Use a class type for `nothing` so its type is unique */
+declare class Nothing {
+    // This lets us do `Exclude<T, Nothing>`
+    private _: any
+}
+
+/**
+ * The sentinel value returned by producers to replace the draft with undefined.
+ */
+export const nothing: Nothing
+
+/**
+ * To let Immer treat your class instances as plain immutable objects
+ * (albeit with a custom prototype), you must define either an instance property
+ * or a static property on each of your custom classes.
+ *
+ * Otherwise, your class instance will never be drafted, which means it won't be
+ * safe to mutate in a produce callback.
+ */
+export const immerable: unique symbol
+
+/**
+ * Pass true to automatically freeze all copies created by Immer.
+ *
+ * By default, auto-freezing is disabled in production.
+ */
+export function setAutoFreeze(autoFreeze: boolean): void
+
+/**
+ * Pass true to use the ES2015 `Proxy` class when creating drafts, which is
+ * always faster than using ES5 proxies.
+ *
+ * By default, feature detection is used, so calling this is rarely necessary.
+ */
+export function setUseProxies(useProxies: boolean): void
+
+/**
+ * Apply an array of Immer patches to the first argument.
+ *
+ * This function is a producer, which means copy-on-write is in effect.
+ */
+export function applyPatches<S>(base: S, patches: Patch[]): S
+
+/**
+ * Create an Immer draft from the given base state, which may be a draft itself.
+ * The draft can be modified until you finalize it with the `finishDraft` function.
+ */
+export function createDraft<T>(base: T): Draft<T>
+
+/**
+ * Finalize an Immer draft from a `createDraft` call, returning the base state
+ * (if no changes were made) or a modified copy. The draft must *not* be
+ * mutated afterwards.
+ *
+ * Pass a function as the 2nd argument to generate Immer patches based on the
+ * changes that were made.
+ */
+export function finishDraft<T>(draft: T, listener?: PatchListener): Immutable<T>
+
+/** Get the underlying object that is represented by the given draft */
+export function original<T>(value: T): T | void
+
+/** Returns true if the given value is an Immer draft */
+export function isDraft(value: any): boolean
+
+/** Returns true if the given value can be drafted by Immer */
+export function isDraftable(value: any): boolean
+
+export class Immer {
+    constructor(config: {
+        useProxies?: boolean
+        autoFreeze?: boolean
+        onAssign?: (
+            state: ImmerState,
+            prop: string | number,
+            value: unknown
+        ) => void
+        onDelete?: (state: ImmerState, prop: string | number) => void
+        onCopy?: (state: ImmerState) => void
+    })
+    /**
+     * The `produce` function takes a value and a "recipe function" (whose
+     * return value often depends on the base state). The recipe function is
+     * free to mutate its first argument however it wants. All mutations are
+     * only ever applied to a __copy__ of the base state.
+     *
+     * Pass only a function to create a "curried producer" which relieves you
+     * from passing the recipe function every time.
+     *
+     * Only plain objects and arrays are made mutable. All other objects are
+     * considered uncopyable.
+     *
+     * Note: This function is __bound__ to its `Immer` instance.
+     *
+     * @param {any} base - the initial state
+     * @param {Function} producer - function that receives a proxy of the base state as first argument and which can be freely modified
+     * @param {Function} patchListener - optional function that will be called with all the patches produced here
+     * @returns {any} a new state, or the initial state if nothing was modified
+     */
+    produce: IProduce
+    /**
+     * When true, `produce` will freeze the copies it creates.
+     */
+    readonly autoFreeze: boolean
+    /**
+     * When true, drafts are ES2015 proxies.
+     */
+    readonly useProxies: boolean
+    /**
+     * Pass true to automatically freeze all copies created by Immer.
+     *
+     * By default, auto-freezing is disabled in production.
+     */
+    setAutoFreeze(autoFreeze: boolean): void
+    /**
+     * Pass true to use the ES2015 `Proxy` class when creating drafts, which is
+     * always faster than using ES5 proxies.
+     *
+     * By default, feature detection is used, so calling this is rarely necessary.
+     */
+    setUseProxies(useProxies: boolean): void
+}
+
+export interface ImmerState<T = any> {
+    parent?: ImmerState
+    base: T
+    copy: T
+    assigned: {[prop: string]: boolean; [index: number]: boolean}
+}
+
+// Backward compatibility with --target es5
+declare global {
+    interface Set<T> {}
+    interface Map<K, V> {}
+    interface WeakSet<T> {}
+    interface WeakMap<K extends object, V> {}
+}