mutate-cow 5.0.0 → 6.0.0

package/{CowContext.mjs → CowContext.js}

@@ -5,12 +5,12 @@
  * in the file named "LICENSE" at the root directory of this distribution.
  */
 
-import clone from './clone.mjs';
+import clone from './clone.js';
 import {
   STATUS_CHANGED,
   STATUS_NONE,
   STATUS_REVOKED,
-} from './constants.mjs';
+} from './constants.js';
 
 const STALE_VALUE = Object.freeze(Object.create(null));
 

package/README.md

@@ -67,7 +67,7 @@ Passing zero arguments returns `ctx`.
 ```js
 ctx.get() === ctx;
 ctx.get('bar').read() === foo.bar;
-ctx.get('bar', 'baz').read() === '';
+ctx.get('bar', 'baz').read().length === 0;
 ```
 
 ### ctx.set(...path: [prop1, ...], value)
@@ -77,13 +77,14 @@ Sets the given `path` to `value` on the current working copy. Returns `ctx`.
 Passing zero property names (i.e., only a value) sets the current context's value.
 
 ```js
+const qux = ['qux'];
 // these all do the same thing
-ctx.set({bar: {baz: 2}});
-ctx.set('bar', {baz: 2});
-ctx.set('bar', 'baz', 2);
-ctx.get('bar').set({baz: 2});
-ctx.get('bar').set('baz', 2);
-ctx.get('bar', 'baz').set(2);
+ctx.set({bar: {baz: qux}});
+ctx.set('bar', {baz: qux});
+ctx.set('bar', 'baz', qux);
+ctx.get('bar').set({baz: qux});
+ctx.get('bar').set('baz', qux);
+ctx.get('bar', 'baz').set(qux);
 ```
 
 ### ctx.update(...path: [prop1, ...], updater)

package/{clone.mjs → clone.js}

@@ -5,12 +5,12 @@
  * in the file named "LICENSE" at the root directory of this distribution.
  */
 
-import canClone from './canClone.mjs';
+import canClone from './canClone.js';
 import {
   NON_CONFIGURABLE,
   NON_CONFIGURABLE_AND_WRITABLE,
   NON_WRITABLE,
-} from './constants.mjs';
+} from './constants.js';
 
 function isPrimitive(value) {
   switch (typeof value) {

package/{index.mjs → index.js}

@@ -5,8 +5,8 @@
  * in the file named "LICENSE" at the root directory of this distribution.
  */
 
-import canClone from './canClone.mjs';
-import CowContext from './CowContext.mjs';
+import canClone from './canClone.js';
+import CowContext from './CowContext.js';
 
 export default function mutate(source) {
   canClone(source);

package/{index.mjs.flow → index.js.flow}

@@ -101,32 +101,32 @@ declare export class CowContext<
   read(): T;
   write(): ShallowReadWrite<T>;
   get(): this;
-  get<K1: KeyType<T>>(prop1: K1): $Get1<T, K1, R, this>;
-  get<K1: KeyType<T>, K2: KeyType2<T, K1>>(prop1: K1, prop2: K2): $Get2<T, K1, K2, R, this>;
-  get<K1: KeyType<T>, K2: KeyType2<T, K1>, K3: KeyType3<T, K1, K2>>(prop1: K1, prop2: K2, prop3: K3): $Get3<T, K1, K2, K3, R, this>;
-  get<K1: KeyType<T>, K2: KeyType2<T, K1>, K3: KeyType3<T, K1, K2>, K4: KeyType4<T, K1, K2, K3>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4): $Get4<T, K1, K2, K3, K4, R, this>;
-  get<K1: KeyType<T>, K2: KeyType2<T, K1>, K3: KeyType3<T, K1, K2>, K4: KeyType4<T, K1, K2, K3>, K5: KeyType5<T, K1, K2, K3, K4>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5): $Get5<T, K1, K2, K3, K4, K5, R, this>;
-  get<K1: KeyType<T>, K2: KeyType2<T, K1>, K3: KeyType3<T, K1, K2>, K4: KeyType4<T, K1, K2, K3>, K5: KeyType5<T, K1, K2, K3, K4>, K6: KeyType6<T, K1, K2, K3, K4, K5>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, prop6: K6): $Get6<T, K1, K2, K3, K4, K5, K6, R, this>;
-  get<K1: KeyType<T>, K2: KeyType2<T, K1>, K3: KeyType3<T, K1, K2>, K4: KeyType4<T, K1, K2, K3>, K5: KeyType5<T, K1, K2, K3, K4>, K6: KeyType6<T, K1, K2, K3, K4, K5>, K7: KeyType7<T, K1, K2, K3, K4, K5, K6>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, prop6: K6, prop7: K7): $Get7<T, K1, K2, K3, K4, K5, K6, K7, R, this>;
-  get<K1: KeyType<T>, K2: KeyType2<T, K1>, K3: KeyType3<T, K1, K2>, K4: KeyType4<T, K1, K2, K3>, K5: KeyType5<T, K1, K2, K3, K4>, K6: KeyType6<T, K1, K2, K3, K4, K5>, K7: KeyType7<T, K1, K2, K3, K4, K5, K6>, K8: KeyType8<T, K1, K2, K3, K4, K5, K6, K7>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, prop6: K6, prop7: K7, prop8: K8): $Get8<T, K1, K2, K3, K4, K5, K6, K7, K8, R, this>;
+  get<const K1: KeyType<T>>(prop1: K1): $Get1<T, K1, R, this>;
+  get<const K1: KeyType<T>, const K2: KeyType2<T, K1>>(prop1: K1, prop2: K2): $Get2<T, K1, K2, R, this>;
+  get<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>>(prop1: K1, prop2: K2, prop3: K3): $Get3<T, K1, K2, K3, R, this>;
+  get<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4): $Get4<T, K1, K2, K3, K4, R, this>;
+  get<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>, const K5: KeyType5<T, K1, K2, K3, K4>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5): $Get5<T, K1, K2, K3, K4, K5, R, this>;
+  get<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>, const K5: KeyType5<T, K1, K2, K3, K4>, const K6: KeyType6<T, K1, K2, K3, K4, K5>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, prop6: K6): $Get6<T, K1, K2, K3, K4, K5, K6, R, this>;
+  get<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>, const K5: KeyType5<T, K1, K2, K3, K4>, const K6: KeyType6<T, K1, K2, K3, K4, K5>, const K7: KeyType7<T, K1, K2, K3, K4, K5, K6>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, prop6: K6, prop7: K7): $Get7<T, K1, K2, K3, K4, K5, K6, K7, R, this>;
+  get<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>, const K5: KeyType5<T, K1, K2, K3, K4>, const K6: KeyType6<T, K1, K2, K3, K4, K5>, const K7: KeyType7<T, K1, K2, K3, K4, K5, K6>, const K8: KeyType8<T, K1, K2, K3, K4, K5, K6, K7>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, prop6: K6, prop7: K7, prop8: K8): $Get8<T, K1, K2, K3, K4, K5, K6, K7, K8, R, this>;
   set(newValue: T): this;
-  set<K1: KeyType<T>>(prop1: K1, newValue: PropType<T, K1>): this;
-  set<K1: KeyType<T>, K2: KeyType2<T, K1>>(prop1: K1, prop2: K2, newValue: PropType2<T, K1, K2>): this;
-  set<K1: KeyType<T>, K2: KeyType2<T, K1>, K3: KeyType3<T, K1, K2>>(prop1: K1, prop2: K2, prop3: K3, newValue: PropType3<T, K1, K2, K3>): this;
-  set<K1: KeyType<T>, K2: KeyType2<T, K1>, K3: KeyType3<T, K1, K2>, K4: KeyType4<T, K1, K2, K3>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, newValue: PropType4<T, K1, K2, K3, K4>): this;
-  set<K1: KeyType<T>, K2: KeyType2<T, K1>, K3: KeyType3<T, K1, K2>, K4: KeyType4<T, K1, K2, K3>, K5: KeyType5<T, K1, K2, K3, K4>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, newValue: PropType5<T, K1, K2, K3, K4, K5>): this;
-  set<K1: KeyType<T>, K2: KeyType2<T, K1>, K3: KeyType3<T, K1, K2>, K4: KeyType4<T, K1, K2, K3>, K5: KeyType5<T, K1, K2, K3, K4>, K6: KeyType6<T, K1, K2, K3, K4, K5>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, prop6: K6, newValue: PropType6<T, K1, K2, K3, K4, K5, K6>): this;
-  set<K1: KeyType<T>, K2: KeyType2<T, K1>, K3: KeyType3<T, K1, K2>, K4: KeyType4<T, K1, K2, K3>, K5: KeyType5<T, K1, K2, K3, K4>, K6: KeyType6<T, K1, K2, K3, K4, K5>, K7: KeyType7<T, K1, K2, K3, K4, K5, K6>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, prop6: K6, prop7: K7, newValue: PropType7<T, K1, K2, K3, K4, K5, K6, K7>): this;
-  set<K1: KeyType<T>, K2: KeyType2<T, K1>, K3: KeyType3<T, K1, K2>, K4: KeyType4<T, K1, K2, K3>, K5: KeyType5<T, K1, K2, K3, K4>, K6: KeyType6<T, K1, K2, K3, K4, K5>, K7: KeyType7<T, K1, K2, K3, K4, K5, K6>, K8: KeyType8<T, K1, K2, K3, K4, K5, K6, K7>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, prop6: K6, prop7: K7, prop8: K8, newValue: PropType8<T, K1, K2, K3, K4, K5, K6, K7, K8>): this;
+  set<const K1: KeyType<T>>(prop1: K1, newValue: PropType<T, K1>): this;
+  set<const K1: KeyType<T>, const K2: KeyType2<T, K1>>(prop1: K1, prop2: K2, newValue: PropType2<T, K1, K2>): this;
+  set<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>>(prop1: K1, prop2: K2, prop3: K3, newValue: PropType3<T, K1, K2, K3>): this;
+  set<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, newValue: PropType4<T, K1, K2, K3, K4>): this;
+  set<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>, const K5: KeyType5<T, K1, K2, K3, K4>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, newValue: PropType5<T, K1, K2, K3, K4, K5>): this;
+  set<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>, const K5: KeyType5<T, K1, K2, K3, K4>, const K6: KeyType6<T, K1, K2, K3, K4, K5>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, prop6: K6, newValue: PropType6<T, K1, K2, K3, K4, K5, K6>): this;
+  set<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>, const K5: KeyType5<T, K1, K2, K3, K4>, const K6: KeyType6<T, K1, K2, K3, K4, K5>, const K7: KeyType7<T, K1, K2, K3, K4, K5, K6>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, prop6: K6, prop7: K7, newValue: PropType7<T, K1, K2, K3, K4, K5, K6, K7>): this;
+  set<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>, const K5: KeyType5<T, K1, K2, K3, K4>, const K6: KeyType6<T, K1, K2, K3, K4, K5>, const K7: KeyType7<T, K1, K2, K3, K4, K5, K6>, const K8: KeyType8<T, K1, K2, K3, K4, K5, K6, K7>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, prop6: K6, prop7: K7, prop8: K8, newValue: PropType8<T, K1, K2, K3, K4, K5, K6, K7, K8>): this;
   update(updater: (this) => mixed): this;
-  update<K1: KeyType<T>>(prop1: K1, updater: ($Get1<T, K1, R, this>) => mixed): this;
-  update<K1: KeyType<T>, K2: KeyType2<T, K1>>(prop1: K1, prop2: K2, updater: ($Get2<T, K1, K2, R, this>) => mixed): this;
-  update<K1: KeyType<T>, K2: KeyType2<T, K1>, K3: KeyType3<T, K1, K2>>(prop1: K1, prop2: K2, prop3: K3, updater: ($Get3<T, K1, K2, K3, R, this>) => mixed): this;
-  update<K1: KeyType<T>, K2: KeyType2<T, K1>, K3: KeyType3<T, K1, K2>, K4: KeyType4<T, K1, K2, K3>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, updater: ($Get4<T, K1, K2, K3, K4, R, this>) => mixed): this;
-  update<K1: KeyType<T>, K2: KeyType2<T, K1>, K3: KeyType3<T, K1, K2>, K4: KeyType4<T, K1, K2, K3>, K5: KeyType5<T, K1, K2, K3, K4>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, updater: ($Get5<T, K1, K2, K3, K4, K5, R, this>) => mixed): this;
-  update<K1: KeyType<T>, K2: KeyType2<T, K1>, K3: KeyType3<T, K1, K2>, K4: KeyType4<T, K1, K2, K3>, K5: KeyType5<T, K1, K2, K3, K4>, K6: KeyType6<T, K1, K2, K3, K4, K5>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, prop6: K6, updater: ($Get6<T, K1, K2, K3, K4, K5, K6, R, this>) => mixed): this;
-  update<K1: KeyType<T>, K2: KeyType2<T, K1>, K3: KeyType3<T, K1, K2>, K4: KeyType4<T, K1, K2, K3>, K5: KeyType5<T, K1, K2, K3, K4>, K6: KeyType6<T, K1, K2, K3, K4, K5>, K7: KeyType7<T, K1, K2, K3, K4, K5, K6>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, prop6: K6, prop7: K7, updater: ($Get7<T, K1, K2, K3, K4, K5, K6, K7, R, this>) => mixed): this;
-  update<K1: KeyType<T>, K2: KeyType2<T, K1>, K3: KeyType3<T, K1, K2>, K4: KeyType4<T, K1, K2, K3>, K5: KeyType5<T, K1, K2, K3, K4>, K6: KeyType6<T, K1, K2, K3, K4, K5>, K7: KeyType7<T, K1, K2, K3, K4, K5, K6>, K8: KeyType8<T, K1, K2, K3, K4, K5, K6, K7>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, prop6: K6, prop7: K7, prop8: K8, updater: ($Get8<T, K1, K2, K3, K4, K5, K6, K7, K8, R, this>) => mixed): this;
+  update<const K1: KeyType<T>>(prop1: K1, updater: ($Get1<T, K1, R, this>) => mixed): this;
+  update<const K1: KeyType<T>, const K2: KeyType2<T, K1>>(prop1: K1, prop2: K2, updater: ($Get2<T, K1, K2, R, this>) => mixed): this;
+  update<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>>(prop1: K1, prop2: K2, prop3: K3, updater: ($Get3<T, K1, K2, K3, R, this>) => mixed): this;
+  update<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, updater: ($Get4<T, K1, K2, K3, K4, R, this>) => mixed): this;
+  update<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>, const K5: KeyType5<T, K1, K2, K3, K4>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, updater: ($Get5<T, K1, K2, K3, K4, K5, R, this>) => mixed): this;
+  update<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>, const K5: KeyType5<T, K1, K2, K3, K4>, const K6: KeyType6<T, K1, K2, K3, K4, K5>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, prop6: K6, updater: ($Get6<T, K1, K2, K3, K4, K5, K6, R, this>) => mixed): this;
+  update<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>, const K5: KeyType5<T, K1, K2, K3, K4>, const K6: KeyType6<T, K1, K2, K3, K4, K5>, const K7: KeyType7<T, K1, K2, K3, K4, K5, K6>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, prop6: K6, prop7: K7, updater: ($Get7<T, K1, K2, K3, K4, K5, K6, K7, R, this>) => mixed): this;
+  update<const K1: KeyType<T>, const K2: KeyType2<T, K1>, const K3: KeyType3<T, K1, K2>, const K4: KeyType4<T, K1, K2, K3>, const K5: KeyType5<T, K1, K2, K3, K4>, const K6: KeyType6<T, K1, K2, K3, K4, K5>, const K7: KeyType7<T, K1, K2, K3, K4, K5, K6>, const K8: KeyType8<T, K1, K2, K3, K4, K5, K6, K7>>(prop1: K1, prop2: K2, prop3: K3, prop4: K4, prop5: K5, prop6: K6, prop7: K7, prop8: K8, updater: ($Get8<T, K1, K2, K3, K4, K5, K6, K7, K8, R, this>) => mixed): this;
   parent(): ParentContext;
   root(): CowRootContext<R>;
   revoke(): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mutate-cow",
-  "version": "5.0.0",
+  "version": "6.0.0",
   "description": "Update immutable objects as if they were mutable with copy-on-write",
   "keywords": [
     "immutable",
@@ -8,7 +8,7 @@
     "copy on write",
     "state management"
   ],
-  "main": "index.mjs",
+  "main": "index.js",
   "types": "index.d.ts",
   "license": "MIT",
   "author": "Michael Wiencek <mwtuea@gmail.com>",
@@ -18,11 +18,13 @@
   },
   "devDependencies": {
     "benchmark": "2.1.4",
-    "flow-bin": "0.222.0",
+    "flow-bin": "0.273.1",
     "tsd": "0.29.0"
   },
   "sideEffects": false,
+  "type": "module",
   "scripts": {
     "test": "node --test --experimental-test-coverage"
-  }
+  },
+  "packageManager": "yarn@4.9.2+sha512.1fc009bc09d13cfd0e19efa44cbfc2b9cf6ca61482725eb35bbc5e257e093ebf4130db6dfe15d604ff4b79efd8e1e8e99b25fa7d0a6197c9f9826358d4d65c3c"
 }

package/bench.mjs

@@ -1,74 +0,0 @@
-/*
- * Copyright (c) 2023 Michael Wiencek
- *
- * This source code is licensed under the MIT license. A copy can be found
- * in the file named "LICENSE" at the root directory of this distribution.
- */
-
-import Benchmark from 'benchmark';
-import mutate from './index.mjs';
-
-const root = {};
-for (let i = 65, next = root; i <= 90; i++) {
-  next = next[String.fromCharCode(i)] = {
-    prop1: 1,
-    prop2: 2,
-    prop3: 3,
-    prop4: 4,
-    prop5: 5,
-  };
-}
-
-const updater1 = () => {
-  mutate(root).set('root', true).final();
-};
-
-const updater2 = () => {
-  mutate(root)
-    .set(
-      'A',
-      'B',
-      'C',
-      'D',
-      'E',
-      'F',
-      'G',
-      'H',
-      'I',
-      'J',
-      'K',
-      'L',
-      'M',
-      'N',
-      'O',
-      'P',
-      'Q',
-      'R',
-      'S',
-      'T',
-      'U',
-      'V',
-      'W',
-      'X',
-      'Y',
-      'Z',
-      'leaf',
-      true,
-    )
-    .final();
-};
-
-function test() {
-  updater1(); // shallow update
-  updater2(); // deep update
-}
-
-new Benchmark.Suite()
-  .add('test', test)
-  .on('cycle', function (event) {
-    console.log(String(event.target));
-  })
-  .on('complete', function () {
-    console.log('Fastest is ' + this.filter('fastest').map('name'));
-  })
-  .run({async: true});

package/index.test-d.ts

@@ -1,60 +0,0 @@
-import {
-  expectType,
-  expectNotType,
-  expectError,
-} from 'tsd';
-
-import mutate, {
-  type CowContext,
-  type CowRootContext,
-} from './index';
-
-interface RoRoot {
-  readonly obj: RoValueContainer;
-  readonly arr: ReadonlyArray<RoValueContainer>;
-}
-
-interface RwRoot {
-  obj: RoValueContainer;
-  arr: ReadonlyArray<RoValueContainer>;
-}
-
-interface RoValueContainer {
-  readonly value: string;
-  readonly nested: RoValueContainer;
-}
-
-const _root: any = {
-  obj: {
-    value: '',
-    nested: null,
-  },
-  arr: [],
-};
-_root.obj.nested = _root.obj;
-const root: RoRoot = _root;
-
-const ctx = mutate(root);
-
-expectType<RoRoot>(ctx.read());
-expectNotType<RwRoot>(ctx.read());
-
-expectType<RwRoot>(ctx.write());
-expectNotType<RoRoot>(ctx.write());
-
-type ObjContext = CowContext<RoValueContainer, RoRoot, CowRootContext<RoRoot>>;
-
-expectType<CowRootContext<RoRoot>>(ctx.get());
-expectType<ObjContext>(ctx.get('obj'));
-expectType<never>(ctx.get('does', 'not', 'exist'));
-
-expectType<CowRootContext<RoRoot>>(ctx.set('obj', 'value', ''));
-expectType<CowRootContext<RoRoot>>(ctx.set('obj', 'nested', 'value', ''));
-expectError(ctx.set('obj', 'value', 0));
-expectError(ctx.set('obj', 'nested', 'value', 0));
-expectError(ctx.set('does', 'not', 'exist'));
-
-expectType<CowRootContext<RoRoot>>(ctx.update((rootCtx: CowRootContext<RoRoot>) => undefined));
-expectType<CowRootContext<RoRoot>>(ctx.update('obj', (childCtx: ObjContext) => undefined));
-expectError(ctx.update());
-expectError(ctx.update('no', 'updater'));

package/test.mjs

@@ -1,715 +0,0 @@
-/*
- * @flow strict
- * Copyright (c) 2023 Michael Wiencek
- *
- * This source code is licensed under the MIT license. A copy can be found
- * in the file named "LICENSE" at the root directory of this distribution.
- */
-
-// $FlowIssue[cannot-resolve-module]
-import assert from 'node:assert';
-// $FlowIssue[cannot-resolve-module]
-import test from 'node:test';
-
-import mutate from './index.mjs';
-
-/*:: import * as types from './index.mjs'; */
-
-const ERROR_REVOKED =
-  /^Error: This context has been revoked and can no longer be used\.$/;
-
-const ERROR_CLONE =
-  /^Error: Only plain objects, arrays, and class instances can be cloned\./;
-
-/*::
-type DatePeriod = {
-  year: number,
-};
-
-type ReadOnlyDatePeriod = {
-  +year: number,
-  +month?: number,
-  +day?: number,
-};
-
-type Person = {
-  name: string,
-  birth_date: DatePeriod,
-  death_date: DatePeriod,
-};
-
-type ReadOnlyPerson = {
-  +name: string,
-  +birth_date: ReadOnlyDatePeriod,
-  +death_date: ReadOnlyDatePeriod,
-};
-
-type People = Array<Person>;
-type ReadOnlyPeople = $ReadOnlyArray<ReadOnlyPerson>;
-*/
-
-const aliceBirthDate = Object.freeze({year: 2100});
-const aliceDeathDate = Object.freeze({year: 2330});
-
-const alice /*: ReadOnlyPerson */ = Object.freeze({
-  name: 'Alice',
-  birth_date: aliceBirthDate,
-  death_date: aliceDeathDate,
-});
-
-const people/*: ReadOnlyPeople */ = Object.freeze([alice, alice]);
-
-const unsupportedProperties/*: {
-  _value: string,
-  +getValue: string,
-  -setValue: string,
-  +func: () => string,
-  +numberObject: Number,
-  +stringObject: String,
-} */ = {
-  _value: '',
-  get getValue()/*: string */ {
-    return unsupportedProperties._value;
-  },
-  set setValue(x/*: string */) {
-    unsupportedProperties._value = x;
-  },
-  func: () => '',
-  numberObject: new Number(1),
-  stringObject: new String(''),
-};
-
-test('mutate', async (t) => {
-  await t.test('throws if you pass null', async (t) => {
-    assert.throws(() => {
-      // $FlowIgnore[incompatible-call]
-      mutate(null);
-    }, ERROR_CLONE);
-  });
-
-  await t.test('throws if you pass a derived built-in', async (t) => {
-    class FunDate extends Date {}
-    assert.throws(() => {
-      mutate(new FunDate());
-    }, ERROR_CLONE);
-  });
-
-  await t.test('throws if you pass a generator', async (t) => {
-    function* makeGenerator() {
-      yield 1;
-    }
-    assert.throws(() => {
-      mutate(makeGenerator());
-    }, ERROR_CLONE);
-  });
-});
-
-test('read', async (t) => {
-  await t.test('returns the original value if no changes were made', (t) => {
-    assert.strictEqual(mutate(people).read()[0].birth_date.year, 2100);
-  });
-
-  await t.test('returns the current changes', (t) => {
-    const ctx = mutate(people);
-    ctx.set(0, 'birth_date', 'year', 1988);
-    assert.strictEqual(ctx.read()[0].birth_date.year, 1988);
-  });
-
-  await t.test('throws if the context is revoked', (t) => {
-    const ctx = mutate(alice);
-    ctx.revoke();
-    assert.throws(() => {
-      ctx.read();
-    }, ERROR_REVOKED);
-  });
-});
-
-test('write', async (t) => {
-  await t.test('forces a copy even if no changes are made', (t) => {
-    const copy = mutate(alice).update(ctx => ctx.write()).final();
-    assert.notStrictEqual(copy, alice);
-  });
-
-  await t.test('returns the current changes', (t) => {
-    const ctx = mutate(people);
-    ctx.set(0, 'birth_date', 'year', 1988);
-    assert.strictEqual(ctx.write()[0].birth_date.year, 1988);
-  });
-
-  await t.test('allows pushing array values', (t) => {
-    const copy = mutate(people)
-      .update((ctx) => ctx.write().push(alice))
-      .final();
-    assert.strictEqual(copy[2], alice);
-  });
-
-  await t.test('can be called on child primitives', (t) => {
-    const ctx = mutate(alice);
-    ctx.get('birth_date', 'year').write();
-    // $FlowIgnore[cannot-write]
-    ctx.read().birth_date.year = 1988;
-    const copy = ctx.final();
-    assert.strictEqual(copy.birth_date.year, 1988);
-  });
-
-  await t.test('throws if the context is revoked', (t) => {
-    const ctx = mutate(people);
-    ctx.revoke();
-    assert.throws(() => {
-      ctx.write();
-    }, ERROR_REVOKED);
-  });
-});
-
-test('get', async (t) => {
-  await t.test('returns `this` if no arguments are passed', (t) => {
-    const ctx = mutate(alice);
-    assert.strictEqual(ctx.get(), ctx);
-  });
-
-  await t.test('works with one prop', (t) => {
-    assert.strictEqual(mutate(alice).get('birth_date').read(), alice.birth_date);
-  });
-
-  await t.test('works with two props', (t) => {
-    assert.strictEqual(mutate(alice).get('birth_date', 'year').read(), alice.birth_date.year);
-  });
-
-  await t.test('chains with other get calls', (t) => {
-    assert.strictEqual(mutate(alice).get('birth_date').get('year').read(), alice.birth_date.year);
-  });
-
-  await t.test('throws if the context is revoked', (t) => {
-    const ctx = mutate(alice);
-    ctx.revoke();
-    assert.throws(() => {
-      ctx.get('birth_date');
-    }, ERROR_REVOKED);
-  });
-
-  await t.test('throws on getters and setters', (t) => {
-    const ctx = mutate(unsupportedProperties);
-
-    assert.throws(() => {
-      ctx.get('getValue');
-    }, /^Error: Getters are unsupported\.$/);
-
-    assert.throws(() => {
-      ctx.get('setValue');
-    }, /^Error: Setters are unsupported\.$/);
-  });
-});
-
-test('set', async (t) => {
-  await t.test('works directly on the root (one argument)', (t) => {
-    let copy = mutate(alice)
-      .set({...alice, birth_date: {...alice.birth_date, year: 1988}})
-      .final();
-    assert.strictEqual(copy.birth_date.year, 1988);
-    assert.strictEqual(copy.death_date, aliceDeathDate);
-    copy = mutate(alice)
-      .set(alice)
-      .set('birth_date', 'year', 1999)
-      .final();
-    assert.strictEqual(copy.birth_date.year, 1999);
-    assert.strictEqual(copy.death_date, aliceDeathDate);
-  });
-
-  await t.test('works directly on a child (one argument)', (t) => {
-    let copy = mutate(alice)
-      .get('birth_date')
-      .set({...alice.birth_date, year: 1988})
-      .finalRoot();
-    assert.strictEqual(copy.birth_date.year, 1988);
-    assert.strictEqual(copy.death_date, aliceDeathDate);
-    copy = mutate(alice)
-      .get('birth_date', 'year')
-      .set(1999)
-      .finalRoot();
-    assert.strictEqual(copy.birth_date.year, 1999);
-    assert.strictEqual(copy.death_date, aliceDeathDate);
-  });
-
-  await t.test('works with one prop', (t) => {
-    const copy = mutate(alice)
-      .get('birth_date')
-      .set('year', 1988)
-      .finalRoot();
-    assert.strictEqual(copy.birth_date.year, 1988);
-    assert.strictEqual(copy.death_date, aliceDeathDate);
-  });
-
-  await t.test('works with two props', (t) => {
-    const copy = mutate(alice)
-      .set('birth_date', 'year', 1988)
-      .final();
-    assert.strictEqual(copy.birth_date.year, 1988);
-    assert.strictEqual(copy.death_date, aliceDeathDate);
-  });
-
-  await t.test('chains with other set calls', (t) => {
-    let copy = mutate(alice)
-      .set('birth_date', 'year', 1988)
-      .set('death_date', 'year', 2088)
-      .final();
-    assert.strictEqual(copy.birth_date.year, 1988);
-    assert.strictEqual(copy.death_date.year, 2088);
-    copy = mutate(alice)
-      .get('birth_date')
-      .set('year', 1990)
-      .set('month', 10)
-      .set('day', 21)
-      .parent()
-      .get('death_date')
-      .set('year', 2090)
-      .set('month', 11)
-      .set('day', 30)
-      .parent()
-      .final();
-    assert.deepStrictEqual(
-      copy.birth_date,
-      {year: 1990, month: 10, day: 21},
-    );
-    assert.deepStrictEqual(
-      copy.death_date,
-      {year: 2090, month: 11, day: 30},
-    );
-  });
-
-  await t.test('returns the same object if no changes are made', (t) => {
-    const copy1 = mutate(alice)
-      .set('name', alice.name)
-      .set('birth_date', alice.birth_date)
-      .set('death_date', alice.death_date)
-      .set('birth_date', 'year', alice.birth_date.year)
-      .set('death_date', 'year', alice.death_date.year)
-      .final();
-    assert.strictEqual(alice, copy1);
-    const copy2 = mutate(people)
-      .set(0, people[0])
-      .set(0, 'name', people[0].name)
-      .set(0, 'birth_date', people[0].birth_date)
-      .set(0, 'death_date', people[0].death_date)
-      .set(0, 'birth_date', 'year', people[0].birth_date.year)
-      .set(0, 'death_date', 'year', people[0].death_date.year)
-      .final();
-    assert.strictEqual(people, copy2);
-  });
-
-  await t.test('clones the object only once', async (t) => {
-    const ctx = mutate(alice);
-    ctx.get('birth_date').set('year', 1987);
-    const newBirthDate1 = ctx.read().birth_date;
-    ctx.get('birth_date').set('year', 1988);
-    const newBirthDate2 = ctx.read().birth_date;
-    assert.strictEqual(newBirthDate1, newBirthDate2);
-  });
-
-  await t.test('throws if the context is revoked', (t) => {
-    const ctx = mutate(alice);
-    ctx.revoke();
-    assert.throws(() => {
-      ctx.set(alice);
-    }, ERROR_REVOKED);
-  });
-
-  await t.test('throws if called on a function', async (t) => {
-    const ctx = mutate(unsupportedProperties);
-
-    assert.throws(() => {
-      // $FlowIgnore[incompatible-call]
-      ctx.get('func').set('error', null);
-    }, ERROR_CLONE);
-  });
-
-  await t.test('throws if called on a number object', async (t) => {
-    const ctx = mutate(unsupportedProperties);
-    assert.throws(() => {
-      // $FlowIgnore[incompatible-call]
-      ctx.get('numberObject').set('error', null);
-    }, ERROR_CLONE);
-  });
-
-  await t.test('can set number objects directly', async (t) => {
-    const copy = mutate(unsupportedProperties)
-      .set('numberObject', new Number(2))
-      .final();
-    assert.strictEqual(+copy.numberObject, 2);
-  });
-
-  await t.test('throws if called on a string object', async (t) => {
-    const ctx = mutate(unsupportedProperties);
-
-    assert.throws(() => {
-      // $FlowIgnore[incompatible-call]
-      ctx.get('stringObject').set('error', null);
-    }, ERROR_CLONE);
-  });
-
-  await t.test('can set string objects directly', async (t) => {
-    const copy = mutate(unsupportedProperties)
-      .set('stringObject', new String('huh'))
-      .final();
-    assert.strictEqual(String(copy.stringObject), 'huh');
-  });
-
-  await t.test('works on class instances', async (t) => {
-    class NiceBase {}
-    class NiceClass extends NiceBase {
-      /*::
-      value: string;
-      */
-      constructor() {
-        super();
-        this.value = 'nice';
-      }
-    }
-    const orig = new NiceClass();
-    const copy = mutate(orig)
-      .set('value', 'naughty')
-      .final();
-    assert.ok(copy instanceof NiceClass);
-    assert.ok(copy instanceof NiceBase);
-    assert.strictEqual(copy.value, 'naughty');
-    assert.strictEqual(orig.value, 'nice');
-  });
-
-  await t.test('can add custom properties to arrays', (t) => {
-    const copy = mutate(people)
-      // $FlowIgnore[incompatible-call]
-      .set('customProp', 10)
-      .final();
-    // $FlowIgnore[prop-missing]
-    assert.strictEqual(copy.customProp, 10);
-  });
-
-  await t.test('works on cyclic references', (t) => {
-    /*::
-    type Cyclic = {x: Cyclic | null}
-    */
-    const orig/*: Cyclic */ = {x: null};
-    orig.x = orig;
-    Object.freeze(orig);
-    const copy1 = mutate(orig)
-      .get('x')
-      .set('x', null)
-      .parent()
-      .final();
-    assert.strictEqual((copy1.x?.x), null);
-    const copy2 = mutate(orig)
-      // $FlowIgnore[incompatible-call]
-      .set('x', 'x', 'x', null)
-      .final();
-    assert.strictEqual((copy2.x?.x?.x), null);
-  });
-
-  await t.test('propagates changes to parent contexts', (t) => {
-    const ctx = mutate/*:: <ReadOnlyPerson> */(alice);
-    const birthDateContext1 = ctx.get('birth_date');
-    const yearContext1 = birthDateContext1.get('year');
-
-    birthDateContext1.set('year', 1988);
-    // Should propagate to birthDateContext1 and yearContext1
-    ctx.set('birth_date', {year: 2008});
-
-    assert.strictEqual(ctx.get('birth_date').read().year, 2008);
-    assert.strictEqual(birthDateContext1.read().year, 2008);
-    assert.strictEqual(yearContext1.read(), 2008);
-  });
-
-  await t.test('works on shared references', (t) => {
-    const shared/*: {+foo: string} */ = Object.freeze({foo: ''});
-    const object/*: {
-      +prop1: typeof shared,
-      +prop2: typeof shared,
-    } */ = Object.freeze({
-      prop1: shared,
-      prop2: shared,
-    });
-    const copy = mutate(object)
-      .set('prop1', 'foo', 'abc')
-      .set('prop2', 'foo', '123')
-      .final();
-    assert.strictEqual(copy.prop1.foo, 'abc');
-    assert.strictEqual(copy.prop2.foo, '123');
-  });
-
-  await t.test('works on externally-frozen objects', (t) => {
-    const source/*: {+ref: {+name: string} | null} */ =
-      Object.freeze({ref: null});
-    const frozenRef = Object.freeze({name: ''});
-    const copy = mutate(source)
-      .set('ref', frozenRef)
-      // $FlowIgnore[incompatible-call]
-      .set('ref', 'name', 'hi')
-      .final();
-    assert.strictEqual(copy.ref?.name, 'hi');
-  });
-});
-
-test('update', async (t) => {
-  await t.test('works directly on the root (one argument)', (t) => {
-    const ctx = mutate(alice);
-    ctx.update((ctx2) => {
-      assert.strictEqual(ctx, ctx2);
-      ctx2.set('birth_date', 'year', 1988);
-    });
-    const copy = ctx.final();
-    assert.strictEqual(copy.birth_date.year, 1988);
-    assert.strictEqual(copy.death_date, aliceDeathDate);
-  });
-
-  await t.test('works directly on a child (one argument)', (t) => {
-    const ctx = mutate(alice).get('birth_date');
-    ctx.update((ctx2) => {
-      assert.strictEqual(ctx, ctx2);
-      ctx2.set('year', 1988);
-    });
-    const copy = ctx.finalRoot();
-    assert.strictEqual(copy.birth_date.year, 1988);
-    assert.strictEqual(copy.death_date, aliceDeathDate);
-  });
-
-  await t.test('works with one prop', (t) => {
-    const ctx = mutate(alice);
-    ctx.update('birth_date', (ctx2) => {
-      assert.strictEqual(ctx.get('birth_date'), ctx2);
-      ctx2.set('year', 1988);
-    });
-    const copy = ctx.finalRoot();
-    assert.strictEqual(copy.birth_date.year, 1988);
-    assert.strictEqual(copy.death_date, aliceDeathDate);
-  });
-
-  await t.test('works with two props', (t) => {
-    const ctx = mutate(alice);
-    ctx.update('birth_date', 'year', (ctx2) => {
-      assert.strictEqual(ctx.get('birth_date', 'year'), ctx2);
-      ctx2.set(1988);
-    });
-    const copy = ctx.finalRoot();
-    assert.strictEqual(copy.birth_date.year, 1988);
-    assert.strictEqual(copy.death_date, aliceDeathDate);
-  });
-
-  await t.test('chains with other update calls', (t) => {
-    let copy = mutate(alice)
-      .update('birth_date', 'year', (ctx) => { ctx.set(1988); })
-      .update('death_date', 'year', (ctx) => { ctx.set(2088); })
-      .final();
-  });
-});
-
-test('parent', async (t) => {
-  const ctx = mutate(alice);
-
-  await t.test('returns null on the root', (t) => {
-    assert.strictEqual(ctx.parent(), null);
-  });
-
-  await t.test('returns the parent of a child context', (t) => {
-    assert.strictEqual(ctx.get('birth_date').parent(), ctx);
-  });
-
-  await t.test('returns the parent of a grandchild context', (t) => {
-    assert.strictEqual(ctx.get('birth_date', 'year').parent(), ctx.get('birth_date'));
-  });
-
-  ctx.revoke();
-});
-
-test('root', async (t) => {
-  const ctx = mutate(alice);
-
-  await t.test('returns the root on the root', (t) => {
-    assert.strictEqual(ctx.root(), ctx);
-  });
-
-  await t.test('returns the root of a child context', (t) => {
-    assert.strictEqual(ctx.get('birth_date').root(), ctx);
-  });
-
-  await t.test('returns the root of a grandchild context', (t) => {
-    assert.strictEqual(ctx.get('birth_date', 'year').root(), ctx);
-  });
-
-  ctx.revoke();
-});
-
-test('revoke', async (t) => {
-  await t.test('can revoke the root context', async (t) => {
-    const ctx = mutate/*:: <ReadOnlyPerson> */(alice);
-    const birthDateContext = ctx.get('birth_date');
-    const birthDateYearContext = birthDateContext.get('year');
-    const deathDateContext = ctx.get('death_date');
-    const deathDateYearContext = deathDateContext.get('year');
-
-    ctx.revoke();
-    // Can call revoke twice.
-    ctx.revoke();
-
-    assert.ok(ctx.isRevoked());
-
-    await t.test('revoking the root context revokes all child contexts', (t) => {
-      assert.ok(birthDateContext.isRevoked());
-      assert.ok(birthDateYearContext.isRevoked());
-      assert.ok(deathDateContext.isRevoked());
-      assert.ok(deathDateYearContext.isRevoked());
-    });
-
-    await t.test('attempting to use a revoked context throws', (t) => {
-      assert.throws(() => {
-        ctx.set('birth_date', alice.birth_date);
-      }, ERROR_REVOKED);
-    });
-  });
-});
-
-test('final', async (t) => {
-  await t.test('can be called on child contexts without affecting parent', (t) => {
-    const root = Object.freeze({
-      foo: Object.freeze({bar: ''}),
-    });
-    const rootCtx = mutate(root);
-    const fooCtx = rootCtx.get('foo');
-    const fooCopy = fooCtx.set('bar', 'a').final();
-
-    assert.ok(Object.isFrozen(fooCopy));
-    assert.strictEqual(fooCopy.bar, 'a');
-
-    const rootCopy = rootCtx
-      .set('foo', 'bar', 'b')
-      .final();
-
-    assert.ok(Object.isFrozen(rootCopy));
-    assert.strictEqual(rootCopy.foo.bar, 'b');
-  });
-
-  await t.test('preserves frozenness of objects', (t) => {
-    const copy = mutate(alice).final();
-    assert.ok(Object.isFrozen(copy));
-    assert.ok(Object.isFrozen(copy.birth_date));
-    assert.ok(Object.isFrozen(copy.death_date));
-  });
-
-  await t.test('preserves frozenness of arrays', (t) => {
-    const copy = mutate(people)
-      .set(0, 'birth_date', 'year', 1988)
-      .update((ctx) => {
-        ctx.write().push(alice);
-      })
-      .final();
-    assert.strictEqual(copy[0].birth_date.year, 1988);
-    assert.strictEqual(copy[1], alice);
-    assert.ok(Object.isFrozen(copy));
-    assert.ok(Object.isFrozen(copy[0]));
-    assert.ok(Object.isFrozen(copy[0].birth_date));
-    assert.ok(Object.isFrozen(copy[0].death_date));
-  });
-
-  await t.test('preserves sealedness of objects', (t) => {
-    const orig/*: {+name: string, +address?: string} */ =
-      Object.seal({name: ''});
-    const copy = mutate(orig)
-      .set('address', 'abc')
-      .final();
-    assert.ok(Object.isSealed(copy));
-    assert.ok(!Object.isFrozen(copy));
-  });
-
-  await t.test('preserves extensibility of objects', (t) => {
-    const orig/*: {+name: string, +address?: string} */ =
-      Object.preventExtensions({name: ''});
-    const copy = mutate(orig)
-      .set('address', 'abc')
-      .final();
-    assert.ok(!Object.isExtensible(copy));
-    assert.ok(!Object.isSealed(copy));
-    assert.ok(!Object.isFrozen(copy));
-  });
-
-  await t.test('preserves descriptors for individual properties', (t) => {
-    const orig = {};
-
-    const origDescriptors = {
-      a: {configurable: false, enumerable: false, writable: false, value: undefined},
-      b: {configurable: false, enumerable: false, writable: true, value: undefined},
-      c: {configurable: false, enumerable: true, writable: false, value: undefined},
-      d: {configurable: false, enumerable: true, writable: true, value: undefined},
-      e: {configurable: true, enumerable: false, writable: false, value: undefined},
-      f: {configurable: true, enumerable: false, writable: true, value: undefined},
-      g: {configurable: true, enumerable: true, writable: false, value: undefined},
-      h: {configurable: true, enumerable: true, writable: true, value: undefined},
-    };
-
-    // $FlowIgnore[prop-missing]
-    Object.defineProperties(orig, origDescriptors);
-    // $FlowIgnore[incompatible-call]
-    const copy = mutate(orig).set('a', '1').final();
-    const copyDescriptors = Object.getOwnPropertyDescriptors(copy);
-    assert.deepStrictEqual(copyDescriptors.a, {...origDescriptors.a, value: '1'});
-    assert.deepStrictEqual(copyDescriptors.b, origDescriptors.b);
-    assert.deepStrictEqual(copyDescriptors.c, origDescriptors.c);
-    assert.deepStrictEqual(copyDescriptors.d, origDescriptors.d);
-    assert.deepStrictEqual(copyDescriptors.e, origDescriptors.e);
-    assert.deepStrictEqual(copyDescriptors.f, origDescriptors.f);
-    assert.deepStrictEqual(copyDescriptors.g, origDescriptors.g);
-    assert.deepStrictEqual(copyDescriptors.h, origDescriptors.h);
-  });
-
-  await t.test('does not restore descriptors onto stale copies', (t) => {
-    const root = Object.freeze({
-      foo: Object.freeze({bar: ''}),
-    });
-
-    const rootCtx = mutate(root);
-    rootCtx.get('foo').set('bar', 'a');
-    const tmpFoo = rootCtx.get('foo').write();
-
-    assert.ok(!Object.isFrozen(tmpFoo));
-
-    rootCtx.set('foo', Object.freeze({bar: 'b'}));
-    rootCtx.get('foo').set('bar', 'c');
-
-    const rootCopy = rootCtx.finalRoot();
-    assert.ok(Object.isFrozen(rootCopy));
-    assert.ok(Object.isFrozen(rootCopy.foo));
-    assert.strictEqual(rootCopy.foo.bar, 'c');
-
-    // `tmpFoo` is stale
-    assert.ok(!Object.isFrozen(tmpFoo));
-    assert.strictEqual(tmpFoo.bar, 'a');
-  });
-
-  await t.test('preserves null prototypes', (t) => {
-    const orig/*: {
-      __proto__: null,
-      +value: {__proto__: null, +number: number},
-    } */ = Object.create(null, {
-      value: {
-        configurable: true,
-        enumerable: true,
-        value: Object.create(null, {
-          number: {
-            configurable: true,
-            enumerable: true,
-            value: 1,
-            writable: false,
-          },
-        }),
-        writable: false,
-      },
-    });
-
-    const copy = mutate(orig)
-      .get('value')
-      .set('number', 2)
-      .parent()
-      .final();
-
-    assert.strictEqual(orig.value.number, 1);
-    assert.strictEqual(copy.value.number, 2);
-    assert.strictEqual(Object.getPrototypeOf(copy), null);
-    assert.strictEqual(Object.getPrototypeOf(copy.value), null);
-  });
-});