effect 2.0.0-next.41 → 2.0.0-next.43

package/Differ/dist/effect-Differ.cjs.prod.js

@@ -2,47 +2,990 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-require('../../dist/Function-2e6b0cda.cjs.prod.js');
-var Differ_dist_effectDiffer = require('../../dist/Differ-0bd34066.cjs.prod.js');
-require('../../dist/Equal-ce9977a8.cjs.prod.js');
-require('../../dist/Hash-1bd73210.cjs.prod.js');
-require('../../dist/GlobalValue-cb645c99.cjs.prod.js');
-require('../../dist/Utils-864e1d48.cjs.prod.js');
-require('../../dist/Predicate-daa86e61.cjs.prod.js');
-require('../../dist/Chunk-6cf5a8e6.cjs.prod.js');
-require('../../dist/Equivalence-0bc84518.cjs.prod.js');
-require('../../dist/Inspectable-3c4a0f5d.cjs.prod.js');
-require('../../dist/Option-02025c86.cjs.prod.js');
-require('../../dist/Either-d03d5f05.cjs.prod.js');
-require('../../dist/Effectable-f867d1cb.cjs.prod.js');
-require('../../dist/Data-07dc27f1.cjs.prod.js');
-require('../../dist/Pipeable-d3ec6711.cjs.prod.js');
-require('../../dist/Number-cb2ba2e8.cjs.prod.js');
-require('../../dist/Order-8a112bfb.cjs.prod.js');
-require('../../dist/ReadonlyArray-8157f697.cjs.prod.js');
-require('../../dist/Either-3fab3796.cjs.prod.js');
+var Function_dist_effectFunction = require('../../Function/dist/effect-Function.cjs.prod.js');
+var Equal_dist_effectEqual = require('../../Equal/dist/effect-Equal.cjs.prod.js');
+var Chunk_dist_effectChunk = require('../../Chunk/dist/effect-Chunk.cjs.prod.js');
+var Data_dist_effectData = require('../../Data/dist/effect-Data.cjs.prod.js');
+var Context = require('../../dist/Context-01a123ac.cjs.prod.js');
+var HashMap_dist_effectHashMap = require('../../HashMap/dist/effect-HashMap.cjs.prod.js');
+var HashSet_dist_effectHashSet = require('../../HashSet/dist/effect-HashSet.cjs.prod.js');
+var Either_dist_effectEither = require('../../Either/dist/effect-Either.cjs.prod.js');
+require('../../Hash/dist/effect-Hash.cjs.prod.js');
+require('../../GlobalValue/dist/effect-GlobalValue.cjs.prod.js');
+require('../../Utils/dist/effect-Utils.cjs.prod.js');
+require('../../Predicate/dist/effect-Predicate.cjs.prod.js');
+require('../../Equivalence/dist/effect-Equivalence.cjs.prod.js');
+require('../../Inspectable/dist/effect-Inspectable.cjs.prod.js');
+require('../../Option/dist/effect-Option.cjs.prod.js');
+require('../../dist/Either-7a881c7a.cjs.prod.js');
+require('../../dist/Effectable-cd8f3a96.cjs.prod.js');
+require('../../Pipeable/dist/effect-Pipeable.cjs.prod.js');
+require('../../Number/dist/effect-Number.cjs.prod.js');
+require('../../Order/dist/effect-Order.cjs.prod.js');
+require('../../ReadonlyArray/dist/effect-ReadonlyArray.cjs.prod.js');
 require('../../dist/ReadonlyArray-f9ed7a05.cjs.prod.js');
-require('../../dist/ReadonlyRecord-8db8bada.cjs.prod.js');
-require('../../dist/Context-f958cabc.cjs.prod.js');
-require('../../dist/HashMap-12668911.cjs.prod.js');
-require('../../dist/HashSet-6fe62df2.cjs.prod.js');
+require('../../ReadonlyRecord/dist/effect-ReadonlyRecord.cjs.prod.js');
+require('../../dist/HashSet-6257b66d.cjs.prod.js');
 require('../../dist/Stack-fc8f9fe5.cjs.prod.js');
-require('../../dist/HashSet-c40a52b1.cjs.prod.js');
-
-
-
-exports.TypeId = Differ_dist_effectDiffer.TypeId;
-exports.chunk = Differ_dist_effectDiffer.chunk;
-exports.combine = Differ_dist_effectDiffer.combine;
-exports.diff = Differ_dist_effectDiffer.diff;
-exports.empty = Differ_dist_effectDiffer.empty;
-exports.environment = Differ_dist_effectDiffer.environment;
-exports.hashMap = Differ_dist_effectDiffer.hashMap;
-exports.hashSet = Differ_dist_effectDiffer.hashSet;
-exports.make = Differ_dist_effectDiffer.make;
-exports.orElseEither = Differ_dist_effectDiffer.orElseEither;
-exports.patch = Differ_dist_effectDiffer.patch;
-exports.transform = Differ_dist_effectDiffer.transform;
-exports.update = Differ_dist_effectDiffer.update;
-exports.updateWith = Differ_dist_effectDiffer.updateWith;
-exports.zip = Differ_dist_effectDiffer.zip;
+
+/** @internal */
+const ChunkPatchTypeId = /*#__PURE__*/Symbol.for("effect/DifferChunkPatch");
+function variance$4(a) {
+  return a;
+}
+const PatchProto$4 = {
+  ...Data_dist_effectData.Structural.prototype,
+  [ChunkPatchTypeId]: {
+    _Value: variance$4,
+    _Patch: variance$4
+  }
+};
+const EmptyProto$4 = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(PatchProto$4), {
+  _tag: "Empty"
+});
+const _empty$4 = /*#__PURE__*/Object.create(EmptyProto$4);
+
+/**
+ * @internal
+ */
+const empty$5 = () => _empty$4;
+const AndThenProto$4 = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(PatchProto$4), {
+  _tag: "AndThen"
+});
+const makeAndThen$4 = (first, second) => {
+  const o = Object.create(AndThenProto$4);
+  o.first = first;
+  o.second = second;
+  return o;
+};
+const AppendProto = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(PatchProto$4), {
+  _tag: "Append"
+});
+const makeAppend = values => {
+  const o = Object.create(AppendProto);
+  o.values = values;
+  return o;
+};
+const SliceProto = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(PatchProto$4), {
+  _tag: "Slice"
+});
+const makeSlice = (from, until) => {
+  const o = Object.create(SliceProto);
+  o.from = from;
+  o.until = until;
+  return o;
+};
+const UpdateProto$1 = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(PatchProto$4), {
+  _tag: "Update"
+});
+const makeUpdate$1 = (index, patch) => {
+  const o = Object.create(UpdateProto$1);
+  o.index = index;
+  o.patch = patch;
+  return o;
+};
+/** @internal */
+const diff$5 = options => {
+  let i = 0;
+  let patch = empty$5();
+  while (i < options.oldValue.length && i < options.newValue.length) {
+    const oldElement = Chunk_dist_effectChunk.unsafeGet(i)(options.oldValue);
+    const newElement = Chunk_dist_effectChunk.unsafeGet(i)(options.newValue);
+    const valuePatch = options.differ.diff(oldElement, newElement);
+    if (!Equal_dist_effectEqual.equals(valuePatch, options.differ.empty)) {
+      patch = Function_dist_effectFunction.pipe(patch, combine$5(makeUpdate$1(i, valuePatch)));
+    }
+    i = i + 1;
+  }
+  if (i < options.oldValue.length) {
+    patch = Function_dist_effectFunction.pipe(patch, combine$5(makeSlice(0, i)));
+  }
+  if (i < options.newValue.length) {
+    patch = Function_dist_effectFunction.pipe(patch, combine$5(makeAppend(Chunk_dist_effectChunk.drop(i)(options.newValue))));
+  }
+  return patch;
+};
+
+/** @internal */
+const combine$5 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => makeAndThen$4(self, that));
+
+/** @internal */
+const patch$5 = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, oldValue, differ) => {
+  let chunk = oldValue;
+  let patches = Chunk_dist_effectChunk.of(self);
+  while (Chunk_dist_effectChunk.isNonEmpty(patches)) {
+    const head = Chunk_dist_effectChunk.headNonEmpty(patches);
+    const tail = Chunk_dist_effectChunk.tailNonEmpty(patches);
+    switch (head._tag) {
+      case "Empty":
+        {
+          patches = tail;
+          break;
+        }
+      case "AndThen":
+        {
+          patches = Chunk_dist_effectChunk.prepend(head.first)(Chunk_dist_effectChunk.prepend(head.second)(tail));
+          break;
+        }
+      case "Append":
+        {
+          chunk = Chunk_dist_effectChunk.appendAll(head.values)(chunk);
+          patches = tail;
+          break;
+        }
+      case "Slice":
+        {
+          const array = Chunk_dist_effectChunk.toReadonlyArray(chunk);
+          chunk = Chunk_dist_effectChunk.unsafeFromArray(array.slice(head.from, head.until));
+          patches = tail;
+          break;
+        }
+      case "Update":
+        {
+          const array = Chunk_dist_effectChunk.toReadonlyArray(chunk);
+          array[head.index] = differ.patch(head.patch, array[head.index]);
+          chunk = Chunk_dist_effectChunk.unsafeFromArray(array);
+          patches = tail;
+          break;
+        }
+    }
+  }
+  return chunk;
+});
+
+/** @internal */
+const ContextPatchTypeId = /*#__PURE__*/Symbol.for("effect/DifferContextPatch");
+function variance$3(a) {
+  return a;
+}
+
+/** @internal */
+const PatchProto$3 = {
+  ...Data_dist_effectData.Structural.prototype,
+  [ContextPatchTypeId]: {
+    _Value: variance$3,
+    _Patch: variance$3
+  }
+};
+const EmptyProto$3 = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(PatchProto$3), {
+  _tag: "Empty"
+});
+const _empty$3 = /*#__PURE__*/Object.create(EmptyProto$3);
+
+/**
+ * @internal
+ */
+const empty$4 = () => _empty$3;
+
+/** @internal */
+
+const AndThenProto$3 = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(PatchProto$3), {
+  _tag: "AndThen"
+});
+const makeAndThen$3 = (first, second) => {
+  const o = Object.create(AndThenProto$3);
+  o.first = first;
+  o.second = second;
+  return o;
+};
+
+/** @internal */
+
+const AddServiceProto = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(PatchProto$3), {
+  _tag: "AddService"
+});
+const makeAddService = (tag, service) => {
+  const o = Object.create(AddServiceProto);
+  o.tag = tag;
+  o.service = service;
+  return o;
+};
+
+/** @internal */
+
+const RemoveServiceProto = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(PatchProto$3), {
+  _tag: "RemoveService"
+});
+const makeRemoveService = tag => {
+  const o = Object.create(RemoveServiceProto);
+  o.tag = tag;
+  return o;
+};
+
+/** @internal */
+
+const UpdateServiceProto = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(PatchProto$3), {
+  _tag: "UpdateService"
+});
+const makeUpdateService = (tag, update) => {
+  const o = Object.create(UpdateServiceProto);
+  o.tag = tag;
+  o.update = update;
+  return o;
+};
+/** @internal */
+const diff$4 = (oldValue, newValue) => {
+  const missingServices = new Map(oldValue.unsafeMap);
+  let patch = empty$4();
+  for (const [tag, newService] of newValue.unsafeMap.entries()) {
+    if (missingServices.has(tag)) {
+      const old = missingServices.get(tag);
+      missingServices.delete(tag);
+      if (!Equal_dist_effectEqual.equals(old, newService)) {
+        patch = combine$4(makeUpdateService(tag, () => newService))(patch);
+      }
+    } else {
+      missingServices.delete(tag);
+      patch = combine$4(makeAddService(tag, newService))(patch);
+    }
+  }
+  for (const [tag] of missingServices.entries()) {
+    patch = combine$4(makeRemoveService(tag))(patch);
+  }
+  return patch;
+};
+
+/** @internal */
+const combine$4 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => makeAndThen$3(self, that));
+
+/** @internal */
+const patch$4 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, context) => {
+  let wasServiceUpdated = false;
+  let patches = Chunk_dist_effectChunk.of(self);
+  const updatedContext = new Map(context.unsafeMap);
+  while (Chunk_dist_effectChunk.isNonEmpty(patches)) {
+    const head = Chunk_dist_effectChunk.headNonEmpty(patches);
+    const tail = Chunk_dist_effectChunk.tailNonEmpty(patches);
+    switch (head._tag) {
+      case "Empty":
+        {
+          patches = tail;
+          break;
+        }
+      case "AddService":
+        {
+          updatedContext.set(head.tag, head.service);
+          patches = tail;
+          break;
+        }
+      case "AndThen":
+        {
+          patches = Chunk_dist_effectChunk.prepend(Chunk_dist_effectChunk.prepend(tail, head.second), head.first);
+          break;
+        }
+      case "RemoveService":
+        {
+          updatedContext.delete(head.tag);
+          patches = tail;
+          break;
+        }
+      case "UpdateService":
+        {
+          updatedContext.set(head.tag, head.update(updatedContext.get(head.tag)));
+          wasServiceUpdated = true;
+          patches = tail;
+          break;
+        }
+    }
+  }
+  if (!wasServiceUpdated) {
+    return Context.makeContext(updatedContext);
+  }
+  const map = new Map();
+  for (const [tag] of context.unsafeMap) {
+    if (updatedContext.has(tag)) {
+      map.set(tag, updatedContext.get(tag));
+      updatedContext.delete(tag);
+    }
+  }
+  for (const [tag, s] of updatedContext) {
+    map.set(tag, s);
+  }
+  return Context.makeContext(map);
+});
+
+/** @internal */
+const HashMapPatchTypeId = /*#__PURE__*/Symbol.for("effect/DifferHashMapPatch");
+function variance$2(a) {
+  return a;
+}
+
+/** @internal */
+const PatchProto$2 = {
+  ...Data_dist_effectData.Structural.prototype,
+  [HashMapPatchTypeId]: {
+    _Value: variance$2,
+    _Key: variance$2,
+    _Patch: variance$2
+  }
+};
+const EmptyProto$2 = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(PatchProto$2), {
+  _tag: "Empty"
+});
+const _empty$2 = /*#__PURE__*/Object.create(EmptyProto$2);
+
+/** @internal */
+const empty$3 = () => _empty$2;
+const AndThenProto$2 = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(PatchProto$2), {
+  _tag: "AndThen"
+});
+const makeAndThen$2 = (first, second) => {
+  const o = Object.create(AndThenProto$2);
+  o.first = first;
+  o.second = second;
+  return o;
+};
+const AddProto$1 = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(PatchProto$2), {
+  _tag: "Add"
+});
+const makeAdd$1 = (key, value) => {
+  const o = Object.create(AddProto$1);
+  o.key = key;
+  o.value = value;
+  return o;
+};
+const RemoveProto$1 = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(PatchProto$2), {
+  _tag: "Remove"
+});
+const makeRemove$1 = key => {
+  const o = Object.create(RemoveProto$1);
+  o.key = key;
+  return o;
+};
+const UpdateProto = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(PatchProto$2), {
+  _tag: "Update"
+});
+const makeUpdate = (key, patch) => {
+  const o = Object.create(UpdateProto);
+  o.key = key;
+  o.patch = patch;
+  return o;
+};
+/** @internal */
+const diff$3 = options => {
+  const [removed, patch] = HashMap_dist_effectHashMap.reduce([options.oldValue, empty$3()], ([map, patch], newValue, key) => {
+    const option = HashMap_dist_effectHashMap.get(key)(map);
+    switch (option._tag) {
+      case "Some":
+        {
+          const valuePatch = options.differ.diff(option.value, newValue);
+          if (Equal_dist_effectEqual.equals(valuePatch, options.differ.empty)) {
+            return [HashMap_dist_effectHashMap.remove(key)(map), patch];
+          }
+          return [HashMap_dist_effectHashMap.remove(key)(map), combine$3(makeUpdate(key, valuePatch))(patch)];
+        }
+      case "None":
+        {
+          return [map, combine$3(makeAdd$1(key, newValue))(patch)];
+        }
+    }
+  })(options.newValue);
+  return HashMap_dist_effectHashMap.reduce(patch, (patch, _, key) => combine$3(makeRemove$1(key))(patch))(removed);
+};
+
+/** @internal */
+const combine$3 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => makeAndThen$2(self, that));
+
+/** @internal */
+const patch$3 = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, oldValue, differ) => {
+  let map = oldValue;
+  let patches = Chunk_dist_effectChunk.of(self);
+  while (Chunk_dist_effectChunk.isNonEmpty(patches)) {
+    const head = Chunk_dist_effectChunk.headNonEmpty(patches);
+    const tail = Chunk_dist_effectChunk.tailNonEmpty(patches);
+    switch (head._tag) {
+      case "Empty":
+        {
+          patches = tail;
+          break;
+        }
+      case "AndThen":
+        {
+          patches = Chunk_dist_effectChunk.prepend(head.first)(Chunk_dist_effectChunk.prepend(head.second)(tail));
+          break;
+        }
+      case "Add":
+        {
+          map = HashMap_dist_effectHashMap.set(head.key, head.value)(map);
+          patches = tail;
+          break;
+        }
+      case "Remove":
+        {
+          map = HashMap_dist_effectHashMap.remove(head.key)(map);
+          patches = tail;
+          break;
+        }
+      case "Update":
+        {
+          const option = HashMap_dist_effectHashMap.get(head.key)(map);
+          if (option._tag === "Some") {
+            map = HashMap_dist_effectHashMap.set(head.key, differ.patch(head.patch, option.value))(map);
+          }
+          patches = tail;
+          break;
+        }
+    }
+  }
+  return map;
+});
+
+/** @internal */
+const HashSetPatchTypeId = /*#__PURE__*/Symbol.for("effect/DifferHashSetPatch");
+function variance$1(a) {
+  return a;
+}
+
+/** @internal */
+const PatchProto$1 = {
+  ...Data_dist_effectData.Structural.prototype,
+  [HashSetPatchTypeId]: {
+    _Value: variance$1,
+    _Key: variance$1,
+    _Patch: variance$1
+  }
+};
+const EmptyProto$1 = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(PatchProto$1), {
+  _tag: "Empty"
+});
+const _empty$1 = /*#__PURE__*/Object.create(EmptyProto$1);
+
+/** @internal */
+const empty$2 = () => _empty$1;
+const AndThenProto$1 = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(PatchProto$1), {
+  _tag: "AndThen"
+});
+
+/** @internal */
+const makeAndThen$1 = (first, second) => {
+  const o = Object.create(AndThenProto$1);
+  o.first = first;
+  o.second = second;
+  return o;
+};
+const AddProto = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(PatchProto$1), {
+  _tag: "Add"
+});
+
+/** @internal */
+const makeAdd = value => {
+  const o = Object.create(AddProto);
+  o.value = value;
+  return o;
+};
+const RemoveProto = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(PatchProto$1), {
+  _tag: "Remove"
+});
+
+/** @internal */
+const makeRemove = value => {
+  const o = Object.create(RemoveProto);
+  o.value = value;
+  return o;
+};
+/** @internal */
+const diff$2 = (oldValue, newValue) => {
+  const [removed, patch] = HashSet_dist_effectHashSet.reduce([oldValue, empty$2()], ([set, patch], value) => {
+    if (HashSet_dist_effectHashSet.has(value)(set)) {
+      return [HashSet_dist_effectHashSet.remove(value)(set), patch];
+    }
+    return [set, combine$2(makeAdd(value))(patch)];
+  })(newValue);
+  return HashSet_dist_effectHashSet.reduce(patch, (patch, value) => combine$2(makeRemove(value))(patch))(removed);
+};
+
+/** @internal */
+const combine$2 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => makeAndThen$1(self, that));
+
+/** @internal */
+const patch$2 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, oldValue) => {
+  let set = oldValue;
+  let patches = Chunk_dist_effectChunk.of(self);
+  while (Chunk_dist_effectChunk.isNonEmpty(patches)) {
+    const head = Chunk_dist_effectChunk.headNonEmpty(patches);
+    const tail = Chunk_dist_effectChunk.tailNonEmpty(patches);
+    switch (head._tag) {
+      case "Empty":
+        {
+          patches = tail;
+          break;
+        }
+      case "AndThen":
+        {
+          patches = Chunk_dist_effectChunk.prepend(head.first)(Chunk_dist_effectChunk.prepend(head.second)(tail));
+          break;
+        }
+      case "Add":
+        {
+          set = HashSet_dist_effectHashSet.add(head.value)(set);
+          patches = tail;
+          break;
+        }
+      case "Remove":
+        {
+          set = HashSet_dist_effectHashSet.remove(head.value)(set);
+          patches = tail;
+        }
+    }
+  }
+  return set;
+});
+
+/** @internal */
+const OrPatchTypeId = /*#__PURE__*/Symbol.for("effect/DifferOrPatch");
+function variance(a) {
+  return a;
+}
+
+/** @internal */
+const PatchProto = {
+  ...Data_dist_effectData.Structural.prototype,
+  [OrPatchTypeId]: {
+    _Value: variance,
+    _Key: variance,
+    _Patch: variance
+  }
+};
+
+/** @internal */
+
+const EmptyProto = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(PatchProto), {
+  _tag: "Empty"
+});
+const _empty = /*#__PURE__*/Object.create(EmptyProto);
+
+/** @internal */
+const empty$1 = () => _empty;
+
+/** @internal */
+
+const AndThenProto = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(PatchProto), {
+  _tag: "AndThen"
+});
+
+/** @internal */
+const makeAndThen = (first, second) => {
+  const o = Object.create(AndThenProto);
+  o.first = first;
+  o.second = second;
+  return o;
+};
+
+/** @internal */
+
+const SetLeftProto = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(PatchProto), {
+  _tag: "SetLeft"
+});
+
+/** @internal */
+const makeSetLeft = value => {
+  const o = Object.create(SetLeftProto);
+  o.value = value;
+  return o;
+};
+
+/** @internal */
+
+const SetRightProto = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(PatchProto), {
+  _tag: "SetRight"
+});
+
+/** @internal */
+const makeSetRight = value => {
+  const o = Object.create(SetRightProto);
+  o.value = value;
+  return o;
+};
+
+/** @internal */
+
+const UpdateLeftProto = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(PatchProto), {
+  _tag: "UpdateLeft"
+});
+
+/** @internal */
+const makeUpdateLeft = patch => {
+  const o = Object.create(UpdateLeftProto);
+  o.patch = patch;
+  return o;
+};
+
+/** @internal */
+
+const UpdateRightProto = /*#__PURE__*/Object.assign( /*#__PURE__*/Object.create(PatchProto), {
+  _tag: "UpdateRight"
+});
+
+/** @internal */
+const makeUpdateRight = patch => {
+  const o = Object.create(UpdateRightProto);
+  o.patch = patch;
+  return o;
+};
+/** @internal */
+const diff$1 = options => {
+  switch (options.oldValue._tag) {
+    case "Left":
+      {
+        switch (options.newValue._tag) {
+          case "Left":
+            {
+              const valuePatch = options.left.diff(options.oldValue.left, options.newValue.left);
+              if (Equal_dist_effectEqual.equals(valuePatch, options.left.empty)) {
+                return empty$1();
+              }
+              return makeUpdateLeft(valuePatch);
+            }
+          case "Right":
+            {
+              return makeSetRight(options.newValue.right);
+            }
+        }
+      }
+    case "Right":
+      {
+        switch (options.newValue._tag) {
+          case "Left":
+            {
+              return makeSetLeft(options.newValue.left);
+            }
+          case "Right":
+            {
+              const valuePatch = options.right.diff(options.oldValue.right, options.newValue.right);
+              if (Equal_dist_effectEqual.equals(valuePatch, options.right.empty)) {
+                return empty$1();
+              }
+              return makeUpdateRight(valuePatch);
+            }
+        }
+      }
+  }
+};
+
+/** @internal */
+const combine$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => makeAndThen(self, that));
+
+/** @internal */
+const patch$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, {
+  left,
+  oldValue,
+  right
+}) => {
+  let patches = Chunk_dist_effectChunk.of(self);
+  let result = oldValue;
+  while (Chunk_dist_effectChunk.isNonEmpty(patches)) {
+    const head = Chunk_dist_effectChunk.headNonEmpty(patches);
+    const tail = Chunk_dist_effectChunk.tailNonEmpty(patches);
+    switch (head._tag) {
+      case "Empty":
+        {
+          patches = tail;
+          break;
+        }
+      case "AndThen":
+        {
+          patches = Chunk_dist_effectChunk.prepend(head.first)(Chunk_dist_effectChunk.prepend(head.second)(tail));
+          break;
+        }
+      case "UpdateLeft":
+        {
+          if (result._tag === "Left") {
+            result = Either_dist_effectEither.left(left.patch(head.patch, result.left));
+          }
+          patches = tail;
+          break;
+        }
+      case "UpdateRight":
+        {
+          if (result._tag === "Right") {
+            result = Either_dist_effectEither.right(right.patch(head.patch, result.right));
+          }
+          patches = tail;
+          break;
+        }
+      case "SetLeft":
+        {
+          result = Either_dist_effectEither.left(head.value);
+          patches = tail;
+          break;
+        }
+      case "SetRight":
+        {
+          result = Either_dist_effectEither.right(head.value);
+          patches = tail;
+          break;
+        }
+    }
+  }
+  return result;
+});
+
+/** @internal */
+const DifferTypeId = /*#__PURE__*/Symbol.for("effect/Differ");
+
+/** @internal */
+const DifferProto = {
+  [DifferTypeId]: {
+    _P: Function_dist_effectFunction.identity,
+    _V: Function_dist_effectFunction.identity
+  }
+};
+
+/** @internal */
+const make$1 = params => {
+  const differ = Object.create(DifferProto);
+  differ.empty = params.empty;
+  differ.diff = params.diff;
+  differ.combine = params.combine;
+  differ.patch = params.patch;
+  return differ;
+};
+
+/** @internal */
+const environment$1 = () => make$1({
+  empty: empty$4(),
+  combine: (first, second) => combine$4(second)(first),
+  diff: (oldValue, newValue) => diff$4(oldValue, newValue),
+  patch: (patch, oldValue) => patch$4(oldValue)(patch)
+});
+
+/** @internal */
+const chunk$1 = differ => make$1({
+  empty: empty$5(),
+  combine: (first, second) => combine$5(second)(first),
+  diff: (oldValue, newValue) => diff$5({
+    oldValue,
+    newValue,
+    differ
+  }),
+  patch: (patch, oldValue) => patch$5(oldValue, differ)(patch)
+});
+
+/** @internal */
+const hashMap$1 = differ => make$1({
+  empty: empty$3(),
+  combine: (first, second) => combine$3(second)(first),
+  diff: (oldValue, newValue) => diff$3({
+    oldValue,
+    newValue,
+    differ
+  }),
+  patch: (patch, oldValue) => patch$3(oldValue, differ)(patch)
+});
+
+/** @internal */
+const hashSet$1 = () => make$1({
+  empty: empty$2(),
+  combine: (first, second) => combine$2(second)(first),
+  diff: (oldValue, newValue) => diff$2(oldValue, newValue),
+  patch: (patch, oldValue) => patch$2(oldValue)(patch)
+});
+
+/** @internal */
+const orElseEither$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => make$1({
+  empty: empty$1(),
+  combine: (first, second) => combine$1(first, second),
+  diff: (oldValue, newValue) => diff$1({
+    oldValue,
+    newValue,
+    left: self,
+    right: that
+  }),
+  patch: (patch, oldValue) => patch$1(patch, {
+    oldValue,
+    left: self,
+    right: that
+  })
+}));
+
+/** @internal */
+const transform$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, {
+  toNew,
+  toOld
+}) => make$1({
+  empty: self.empty,
+  combine: (first, second) => self.combine(first, second),
+  diff: (oldValue, newValue) => self.diff(toOld(oldValue), toOld(newValue)),
+  patch: (patch, oldValue) => toNew(self.patch(patch, toOld(oldValue)))
+}));
+
+/** @internal */
+const update$1 = () => updateWith$1((_, a) => a);
+
+/** @internal */
+const updateWith$1 = f => make$1({
+  empty: Function_dist_effectFunction.identity,
+  combine: (first, second) => {
+    if (first === Function_dist_effectFunction.identity) {
+      return second;
+    }
+    if (second === Function_dist_effectFunction.identity) {
+      return first;
+    }
+    return a => second(first(a));
+  },
+  diff: (oldValue, newValue) => {
+    if (Equal_dist_effectEqual.equals(oldValue, newValue)) {
+      return Function_dist_effectFunction.identity;
+    }
+    return Function_dist_effectFunction.constant(newValue);
+  },
+  patch: (patch, oldValue) => f(oldValue, patch(oldValue))
+});
+
+/** @internal */
+const zip$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => make$1({
+  empty: [self.empty, that.empty],
+  combine: (first, second) => [self.combine(first[0], second[0]), that.combine(first[1], second[1])],
+  diff: (oldValue, newValue) => [self.diff(oldValue[0], newValue[0]), that.diff(oldValue[1], newValue[1])],
+  patch: (patch, oldValue) => [self.patch(patch[0], oldValue[0]), that.patch(patch[1], oldValue[1])]
+}));
+
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * @since 2.0.0
+ * @category symbol
+ */
+const TypeId = DifferTypeId;
+
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * An empty patch that describes no changes.
+ *
+ * @since 2.0.0
+ * @category patch
+ */
+const empty = self => self.empty;
+
+/**
+ * @since 2.0.0
+ * @category patch
+ */
+const diff = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, oldValue, newValue) => self.diff(oldValue, newValue));
+
+/**
+ * Combines two patches to produce a new patch that describes the updates of
+ * the first patch and then the updates of the second patch. The combine
+ * operation should be associative. In addition, if the combine operation is
+ * commutative then joining multiple fibers concurrently will result in
+ * deterministic `FiberRef` values.
+ *
+ * @since 2.0.0
+ * @category patch
+ */
+const combine = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, first, second) => self.combine(first, second));
+
+/**
+ * Applies a patch to an old value to produce a new value that is equal to the
+ * old value with the updates described by the patch.
+ *
+ * @since 2.0.0
+ * @category patch
+ */
+const patch = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, patch, oldValue) => self.patch(patch, oldValue));
+
+/**
+ * Constructs a new `Differ`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const make = make$1;
+
+/**
+ * Constructs a differ that knows how to diff `Env` values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const environment = environment$1;
+
+/**
+ * Constructs a differ that knows how to diff a `Chunk` of values given a
+ * differ that knows how to diff the values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const chunk = chunk$1;
+
+/**
+ * Constructs a differ that knows how to diff a `HashMap` of keys and values given
+ * a differ that knows how to diff the values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const hashMap = hashMap$1;
+
+/**
+ * Constructs a differ that knows how to diff a `HashSet` of values.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const hashSet = hashSet$1;
+
+/**
+ * Combines this differ and the specified differ to produce a differ that
+ * knows how to diff the sum of their values.
+ *
+ * @since 2.0.0
+ */
+const orElseEither = orElseEither$1;
+
+/**
+ * Transforms the type of values that this differ knows how to differ using
+ * the specified functions that map the new and old value types to each other.
+ *
+ * @since 2.0.0
+ */
+const transform = transform$1;
+
+/**
+ * Constructs a differ that just diffs two values by returning a function that
+ * sets the value to the new value. This differ does not support combining
+ * multiple updates to the value compositionally and should only be used when
+ * there is no compositional way to update them.
+ *
+ * @since 2.0.0
+ */
+const update = update$1;
+
+/**
+ * A variant of `update` that allows specifying the function that will be used
+ * to combine old values with new values.
+ *
+ * @since 2.0.0
+ */
+const updateWith = updateWith$1;
+
+/**
+ * Combines this differ and the specified differ to produce a new differ that
+ * knows how to diff the product of their values.
+ *
+ * @since 2.0.0
+ */
+const zip = zip$1;
+
+exports.TypeId = TypeId;
+exports.chunk = chunk;
+exports.combine = combine;
+exports.diff = diff;
+exports.empty = empty;
+exports.environment = environment;
+exports.hashMap = hashMap;
+exports.hashSet = hashSet;
+exports.make = make;
+exports.orElseEither = orElseEither;
+exports.patch = patch;
+exports.transform = transform;
+exports.update = update;
+exports.updateWith = updateWith;
+exports.zip = zip;