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

package/dist/Differ-0bd34066.cjs.prod.js

@@ -1,992 +0,0 @@
-'use strict';
-
-var Function_dist_effectFunction = require('./Function-2e6b0cda.cjs.prod.js');
-var Equal_dist_effectEqual = require('./Equal-ce9977a8.cjs.prod.js');
-var Chunk_dist_effectChunk = require('./Chunk-6cf5a8e6.cjs.prod.js');
-var Data_dist_effectData = require('./Data-07dc27f1.cjs.prod.js');
-var Context = require('./Context-f958cabc.cjs.prod.js');
-var HashMap_dist_effectHashMap = require('./HashMap-12668911.cjs.prod.js');
-var HashSet_dist_effectHashSet = require('./HashSet-c40a52b1.cjs.prod.js');
-var Either_dist_effectEither = require('./Either-3fab3796.cjs.prod.js');
-
-/** @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;
-
-var Differ = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  TypeId: TypeId,
-  empty: empty,
-  diff: diff,
-  combine: combine,
-  patch: patch,
-  make: make,
-  environment: environment,
-  chunk: chunk,
-  hashMap: hashMap,
-  hashSet: hashSet,
-  orElseEither: orElseEither,
-  transform: transform,
-  update: update,
-  updateWith: updateWith,
-  zip: zip
-});
-
-exports.Differ = Differ;
-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;