effect 2.0.0-next.38 → 2.0.0-next.39

package/dist/Differ-a249bf4d.esm.js

@@ -1,975 +0,0 @@
-import { p as pipe, d as dual, i as identity, h as constant } from './Function-12511160.esm.js';
-import { e as equals } from './Equal-2a99fde3.esm.js';
-import { u as unsafeGet, d as drop, o as of, h as isNonEmpty, j as headNonEmpty, t as tailNonEmpty, n as toReadonlyArray, l as unsafeFromArray, b as appendAll, p as prepend } from './Chunk-4c1f4599.esm.js';
-import { S as Structural } from './Data-dee529b9.esm.js';
-import { a as makeContext } from './Context-149c432f.esm.js';
-import { r as reduce, g as get, c as remove, s as set } from './HashMap-6c230bde.esm.js';
-import { r as reduce$1, h as has, j as remove$1, a as add } from './HashSet-ae2856c1.esm.js';
-import { r as right, l as left } from './Either-aa46c018.esm.js';
-
-/** @internal */
-const ChunkPatchTypeId = /*#__PURE__*/Symbol.for("effect/DifferChunkPatch");
-function variance$4(a) {
-  return a;
-}
-const PatchProto$4 = {
-  ...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 = unsafeGet(i)(options.oldValue);
-    const newElement = unsafeGet(i)(options.newValue);
-    const valuePatch = options.differ.diff(oldElement, newElement);
-    if (!equals(valuePatch, options.differ.empty)) {
-      patch = pipe(patch, combine$5(makeUpdate$1(i, valuePatch)));
-    }
-    i = i + 1;
-  }
-  if (i < options.oldValue.length) {
-    patch = pipe(patch, combine$5(makeSlice(0, i)));
-  }
-  if (i < options.newValue.length) {
-    patch = pipe(patch, combine$5(makeAppend(drop(i)(options.newValue))));
-  }
-  return patch;
-};
-
-/** @internal */
-const combine$5 = /*#__PURE__*/dual(2, (self, that) => makeAndThen$4(self, that));
-
-/** @internal */
-const patch$5 = /*#__PURE__*/dual(3, (self, oldValue, differ) => {
-  let chunk = oldValue;
-  let patches = of(self);
-  while (isNonEmpty(patches)) {
-    const head = headNonEmpty(patches);
-    const tail = tailNonEmpty(patches);
-    switch (head._tag) {
-      case "Empty":
-        {
-          patches = tail;
-          break;
-        }
-      case "AndThen":
-        {
-          patches = prepend(head.first)(prepend(head.second)(tail));
-          break;
-        }
-      case "Append":
-        {
-          chunk = appendAll(head.values)(chunk);
-          patches = tail;
-          break;
-        }
-      case "Slice":
-        {
-          const array = toReadonlyArray(chunk);
-          chunk = unsafeFromArray(array.slice(head.from, head.until));
-          patches = tail;
-          break;
-        }
-      case "Update":
-        {
-          const array = toReadonlyArray(chunk);
-          array[head.index] = differ.patch(head.patch, array[head.index]);
-          chunk = 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 = {
-  ...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 (!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__*/dual(2, (self, that) => makeAndThen$3(self, that));
-
-/** @internal */
-const patch$4 = /*#__PURE__*/dual(2, (self, context) => {
-  let wasServiceUpdated = false;
-  let patches = of(self);
-  const updatedContext = new Map(context.unsafeMap);
-  while (isNonEmpty(patches)) {
-    const head = headNonEmpty(patches);
-    const tail = tailNonEmpty(patches);
-    switch (head._tag) {
-      case "Empty":
-        {
-          patches = tail;
-          break;
-        }
-      case "AddService":
-        {
-          updatedContext.set(head.tag, head.service);
-          patches = tail;
-          break;
-        }
-      case "AndThen":
-        {
-          patches = prepend(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 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 makeContext(map);
-});
-
-/** @internal */
-const HashMapPatchTypeId = /*#__PURE__*/Symbol.for("effect/DifferHashMapPatch");
-function variance$2(a) {
-  return a;
-}
-
-/** @internal */
-const PatchProto$2 = {
-  ...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] = reduce([options.oldValue, empty$3()], ([map, patch], newValue, key) => {
-    const option = get(key)(map);
-    switch (option._tag) {
-      case "Some":
-        {
-          const valuePatch = options.differ.diff(option.value, newValue);
-          if (equals(valuePatch, options.differ.empty)) {
-            return [remove(key)(map), patch];
-          }
-          return [remove(key)(map), combine$3(makeUpdate(key, valuePatch))(patch)];
-        }
-      case "None":
-        {
-          return [map, combine$3(makeAdd$1(key, newValue))(patch)];
-        }
-    }
-  })(options.newValue);
-  return reduce(patch, (patch, _, key) => combine$3(makeRemove$1(key))(patch))(removed);
-};
-
-/** @internal */
-const combine$3 = /*#__PURE__*/dual(2, (self, that) => makeAndThen$2(self, that));
-
-/** @internal */
-const patch$3 = /*#__PURE__*/dual(3, (self, oldValue, differ) => {
-  let map = oldValue;
-  let patches = of(self);
-  while (isNonEmpty(patches)) {
-    const head = headNonEmpty(patches);
-    const tail = tailNonEmpty(patches);
-    switch (head._tag) {
-      case "Empty":
-        {
-          patches = tail;
-          break;
-        }
-      case "AndThen":
-        {
-          patches = prepend(head.first)(prepend(head.second)(tail));
-          break;
-        }
-      case "Add":
-        {
-          map = set(head.key, head.value)(map);
-          patches = tail;
-          break;
-        }
-      case "Remove":
-        {
-          map = remove(head.key)(map);
-          patches = tail;
-          break;
-        }
-      case "Update":
-        {
-          const option = get(head.key)(map);
-          if (option._tag === "Some") {
-            map = 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 = {
-  ...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] = reduce$1([oldValue, empty$2()], ([set, patch], value) => {
-    if (has(value)(set)) {
-      return [remove$1(value)(set), patch];
-    }
-    return [set, combine$2(makeAdd(value))(patch)];
-  })(newValue);
-  return reduce$1(patch, (patch, value) => combine$2(makeRemove(value))(patch))(removed);
-};
-
-/** @internal */
-const combine$2 = /*#__PURE__*/dual(2, (self, that) => makeAndThen$1(self, that));
-
-/** @internal */
-const patch$2 = /*#__PURE__*/dual(2, (self, oldValue) => {
-  let set = oldValue;
-  let patches = of(self);
-  while (isNonEmpty(patches)) {
-    const head = headNonEmpty(patches);
-    const tail = tailNonEmpty(patches);
-    switch (head._tag) {
-      case "Empty":
-        {
-          patches = tail;
-          break;
-        }
-      case "AndThen":
-        {
-          patches = prepend(head.first)(prepend(head.second)(tail));
-          break;
-        }
-      case "Add":
-        {
-          set = add(head.value)(set);
-          patches = tail;
-          break;
-        }
-      case "Remove":
-        {
-          set = remove$1(head.value)(set);
-          patches = tail;
-        }
-    }
-  }
-  return set;
-});
-
-/** @internal */
-const OrPatchTypeId = /*#__PURE__*/Symbol.for("effect/DifferOrPatch");
-function variance(a) {
-  return a;
-}
-
-/** @internal */
-const PatchProto = {
-  ...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 (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 (equals(valuePatch, options.right.empty)) {
-                return empty$1();
-              }
-              return makeUpdateRight(valuePatch);
-            }
-        }
-      }
-  }
-};
-
-/** @internal */
-const combine$1 = /*#__PURE__*/dual(2, (self, that) => makeAndThen(self, that));
-
-/** @internal */
-const patch$1 = /*#__PURE__*/dual(2, (self, {
-  left: left$1,
-  oldValue,
-  right: right$1
-}) => {
-  let patches = of(self);
-  let result = oldValue;
-  while (isNonEmpty(patches)) {
-    const head = headNonEmpty(patches);
-    const tail = tailNonEmpty(patches);
-    switch (head._tag) {
-      case "Empty":
-        {
-          patches = tail;
-          break;
-        }
-      case "AndThen":
-        {
-          patches = prepend(head.first)(prepend(head.second)(tail));
-          break;
-        }
-      case "UpdateLeft":
-        {
-          if (result._tag === "Left") {
-            result = left(left$1.patch(head.patch, result.left));
-          }
-          patches = tail;
-          break;
-        }
-      case "UpdateRight":
-        {
-          if (result._tag === "Right") {
-            result = right(right$1.patch(head.patch, result.right));
-          }
-          patches = tail;
-          break;
-        }
-      case "SetLeft":
-        {
-          result = left(head.value);
-          patches = tail;
-          break;
-        }
-      case "SetRight":
-        {
-          result = right(head.value);
-          patches = tail;
-          break;
-        }
-    }
-  }
-  return result;
-});
-
-/** @internal */
-const DifferTypeId = /*#__PURE__*/Symbol.for("effect/Differ");
-
-/** @internal */
-const DifferProto = {
-  [DifferTypeId]: {
-    _P: identity,
-    _V: 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__*/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__*/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: identity,
-  combine: (first, second) => {
-    if (first === identity) {
-      return second;
-    }
-    if (second === identity) {
-      return first;
-    }
-    return a => second(first(a));
-  },
-  diff: (oldValue, newValue) => {
-    if (equals(oldValue, newValue)) {
-      return identity;
-    }
-    return constant(newValue);
-  },
-  patch: (patch, oldValue) => f(oldValue, patch(oldValue))
-});
-
-/** @internal */
-const zip$1 = /*#__PURE__*/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__*/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__*/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__*/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
-});
-
-export { Differ as D, TypeId as T, empty as a, chunk as b, combine as c, diff as d, environment as e, hashMap as f, updateWith as g, hashSet as h, make as m, orElseEither as o, patch as p, transform as t, update as u, zip as z };