Добавлена ДБ

node_modules/effect/dist/esm/internal/differ/chunkPatch.js

@@ -0,0 +1,130 @@
+import * as Chunk from "../../Chunk.js";
+import * as Equal from "../../Equal.js";
+import * as Dual from "../../Function.js";
+import { pipe } from "../../Function.js";
+import * as Data from "../data.js";
+/** @internal */
+export const ChunkPatchTypeId = /*#__PURE__*/Symbol.for("effect/DifferChunkPatch");
+function variance(a) {
+  return a;
+}
+const PatchProto = {
+  ...Data.Structural.prototype,
+  [ChunkPatchTypeId]: {
+    _Value: variance,
+    _Patch: variance
+  }
+};
+const EmptyProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "Empty"
+});
+const _empty = /*#__PURE__*/Object.create(EmptyProto);
+/**
+ * @internal
+ */
+export const empty = () => _empty;
+const AndThenProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "AndThen"
+});
+const makeAndThen = (first, second) => {
+  const o = Object.create(AndThenProto);
+  o.first = first;
+  o.second = second;
+  return o;
+};
+const AppendProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "Append"
+});
+const makeAppend = values => {
+  const o = Object.create(AppendProto);
+  o.values = values;
+  return o;
+};
+const SliceProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "Slice"
+});
+const makeSlice = (from, until) => {
+  const o = Object.create(SliceProto);
+  o.from = from;
+  o.until = until;
+  return o;
+};
+const UpdateProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "Update"
+});
+const makeUpdate = (index, patch) => {
+  const o = Object.create(UpdateProto);
+  o.index = index;
+  o.patch = patch;
+  return o;
+};
+/** @internal */
+export const diff = options => {
+  let i = 0;
+  let patch = empty();
+  while (i < options.oldValue.length && i < options.newValue.length) {
+    const oldElement = Chunk.unsafeGet(i)(options.oldValue);
+    const newElement = Chunk.unsafeGet(i)(options.newValue);
+    const valuePatch = options.differ.diff(oldElement, newElement);
+    if (!Equal.equals(valuePatch, options.differ.empty)) {
+      patch = pipe(patch, combine(makeUpdate(i, valuePatch)));
+    }
+    i = i + 1;
+  }
+  if (i < options.oldValue.length) {
+    patch = pipe(patch, combine(makeSlice(0, i)));
+  }
+  if (i < options.newValue.length) {
+    patch = pipe(patch, combine(makeAppend(Chunk.drop(i)(options.newValue))));
+  }
+  return patch;
+};
+/** @internal */
+export const combine = /*#__PURE__*/Dual.dual(2, (self, that) => makeAndThen(self, that));
+/** @internal */
+export const patch = /*#__PURE__*/Dual.dual(3, (self, oldValue, differ) => {
+  if (self._tag === "Empty") {
+    return oldValue;
+  }
+  let chunk = oldValue;
+  let patches = Chunk.of(self);
+  while (Chunk.isNonEmpty(patches)) {
+    const head = Chunk.headNonEmpty(patches);
+    const tail = Chunk.tailNonEmpty(patches);
+    switch (head._tag) {
+      case "Empty":
+        {
+          patches = tail;
+          break;
+        }
+      case "AndThen":
+        {
+          patches = Chunk.prepend(head.first)(Chunk.prepend(head.second)(tail));
+          break;
+        }
+      case "Append":
+        {
+          chunk = Chunk.appendAll(head.values)(chunk);
+          patches = tail;
+          break;
+        }
+      case "Slice":
+        {
+          const array = Chunk.toReadonlyArray(chunk);
+          chunk = Chunk.unsafeFromArray(array.slice(head.from, head.until));
+          patches = tail;
+          break;
+        }
+      case "Update":
+        {
+          const array = Chunk.toReadonlyArray(chunk);
+          array[head.index] = differ.patch(head.patch, array[head.index]);
+          chunk = Chunk.unsafeFromArray(array);
+          patches = tail;
+          break;
+        }
+    }
+  }
+  return chunk;
+});
+//# sourceMappingURL=chunkPatch.js.map

node_modules/effect/dist/esm/internal/differ/contextPatch.js

@@ -0,0 +1,143 @@
+import * as Chunk from "../../Chunk.js";
+import * as Equal from "../../Equal.js";
+import * as Dual from "../../Function.js";
+import { makeContext } from "../context.js";
+import { Structural } from "../data.js";
+/** @internal */
+export const ContextPatchTypeId = /*#__PURE__*/Symbol.for("effect/DifferContextPatch");
+function variance(a) {
+  return a;
+}
+/** @internal */
+const PatchProto = {
+  ...Structural.prototype,
+  [ContextPatchTypeId]: {
+    _Value: variance,
+    _Patch: variance
+  }
+};
+const EmptyProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "Empty"
+});
+const _empty = /*#__PURE__*/Object.create(EmptyProto);
+/**
+ * @internal
+ */
+export const empty = () => _empty;
+const AndThenProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "AndThen"
+});
+const makeAndThen = (first, second) => {
+  const o = Object.create(AndThenProto);
+  o.first = first;
+  o.second = second;
+  return o;
+};
+const AddServiceProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "AddService"
+});
+const makeAddService = (key, service) => {
+  const o = Object.create(AddServiceProto);
+  o.key = key;
+  o.service = service;
+  return o;
+};
+const RemoveServiceProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "RemoveService"
+});
+const makeRemoveService = key => {
+  const o = Object.create(RemoveServiceProto);
+  o.key = key;
+  return o;
+};
+const UpdateServiceProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "UpdateService"
+});
+const makeUpdateService = (key, update) => {
+  const o = Object.create(UpdateServiceProto);
+  o.key = key;
+  o.update = update;
+  return o;
+};
+/** @internal */
+export const diff = (oldValue, newValue) => {
+  const missingServices = new Map(oldValue.unsafeMap);
+  let patch = empty();
+  for (const [tag, newService] of newValue.unsafeMap.entries()) {
+    if (missingServices.has(tag)) {
+      const old = missingServices.get(tag);
+      missingServices.delete(tag);
+      if (!Equal.equals(old, newService)) {
+        patch = combine(makeUpdateService(tag, () => newService))(patch);
+      }
+    } else {
+      missingServices.delete(tag);
+      patch = combine(makeAddService(tag, newService))(patch);
+    }
+  }
+  for (const [tag] of missingServices.entries()) {
+    patch = combine(makeRemoveService(tag))(patch);
+  }
+  return patch;
+};
+/** @internal */
+export const combine = /*#__PURE__*/Dual.dual(2, (self, that) => makeAndThen(self, that));
+/** @internal */
+export const patch = /*#__PURE__*/Dual.dual(2, (self, context) => {
+  if (self._tag === "Empty") {
+    return context;
+  }
+  let wasServiceUpdated = false;
+  let patches = Chunk.of(self);
+  const updatedContext = new Map(context.unsafeMap);
+  while (Chunk.isNonEmpty(patches)) {
+    const head = Chunk.headNonEmpty(patches);
+    const tail = Chunk.tailNonEmpty(patches);
+    switch (head._tag) {
+      case "Empty":
+        {
+          patches = tail;
+          break;
+        }
+      case "AddService":
+        {
+          updatedContext.set(head.key, head.service);
+          patches = tail;
+          break;
+        }
+      case "AndThen":
+        {
+          patches = Chunk.prepend(Chunk.prepend(tail, head.second), head.first);
+          break;
+        }
+      case "RemoveService":
+        {
+          updatedContext.delete(head.key);
+          patches = tail;
+          break;
+        }
+      case "UpdateService":
+        {
+          updatedContext.set(head.key, head.update(updatedContext.get(head.key)));
+          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);
+});
+//# sourceMappingURL=contextPatch.js.map

node_modules/effect/dist/esm/internal/differ/hashMapPatch.js

@@ -0,0 +1,130 @@
+import * as Chunk from "../../Chunk.js";
+import * as Equal from "../../Equal.js";
+import * as Dual from "../../Function.js";
+import * as HashMap from "../../HashMap.js";
+import { Structural } from "../data.js";
+/** @internal */
+export const HashMapPatchTypeId = /*#__PURE__*/Symbol.for("effect/DifferHashMapPatch");
+function variance(a) {
+  return a;
+}
+/** @internal */
+const PatchProto = {
+  ...Structural.prototype,
+  [HashMapPatchTypeId]: {
+    _Value: variance,
+    _Key: variance,
+    _Patch: variance
+  }
+};
+const EmptyProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "Empty"
+});
+const _empty = /*#__PURE__*/Object.create(EmptyProto);
+/** @internal */
+export const empty = () => _empty;
+const AndThenProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "AndThen"
+});
+const makeAndThen = (first, second) => {
+  const o = Object.create(AndThenProto);
+  o.first = first;
+  o.second = second;
+  return o;
+};
+const AddProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "Add"
+});
+const makeAdd = (key, value) => {
+  const o = Object.create(AddProto);
+  o.key = key;
+  o.value = value;
+  return o;
+};
+const RemoveProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "Remove"
+});
+const makeRemove = key => {
+  const o = Object.create(RemoveProto);
+  o.key = key;
+  return o;
+};
+const UpdateProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "Update"
+});
+const makeUpdate = (key, patch) => {
+  const o = Object.create(UpdateProto);
+  o.key = key;
+  o.patch = patch;
+  return o;
+};
+/** @internal */
+export const diff = options => {
+  const [removed, patch] = HashMap.reduce([options.oldValue, empty()], ([map, patch], newValue, key) => {
+    const option = HashMap.get(key)(map);
+    switch (option._tag) {
+      case "Some":
+        {
+          const valuePatch = options.differ.diff(option.value, newValue);
+          if (Equal.equals(valuePatch, options.differ.empty)) {
+            return [HashMap.remove(key)(map), patch];
+          }
+          return [HashMap.remove(key)(map), combine(makeUpdate(key, valuePatch))(patch)];
+        }
+      case "None":
+        {
+          return [map, combine(makeAdd(key, newValue))(patch)];
+        }
+    }
+  })(options.newValue);
+  return HashMap.reduce(patch, (patch, _, key) => combine(makeRemove(key))(patch))(removed);
+};
+/** @internal */
+export const combine = /*#__PURE__*/Dual.dual(2, (self, that) => makeAndThen(self, that));
+/** @internal */
+export const patch = /*#__PURE__*/Dual.dual(3, (self, oldValue, differ) => {
+  if (self._tag === "Empty") {
+    return oldValue;
+  }
+  let map = oldValue;
+  let patches = Chunk.of(self);
+  while (Chunk.isNonEmpty(patches)) {
+    const head = Chunk.headNonEmpty(patches);
+    const tail = Chunk.tailNonEmpty(patches);
+    switch (head._tag) {
+      case "Empty":
+        {
+          patches = tail;
+          break;
+        }
+      case "AndThen":
+        {
+          patches = Chunk.prepend(head.first)(Chunk.prepend(head.second)(tail));
+          break;
+        }
+      case "Add":
+        {
+          map = HashMap.set(head.key, head.value)(map);
+          patches = tail;
+          break;
+        }
+      case "Remove":
+        {
+          map = HashMap.remove(head.key)(map);
+          patches = tail;
+          break;
+        }
+      case "Update":
+        {
+          const option = HashMap.get(head.key)(map);
+          if (option._tag === "Some") {
+            map = HashMap.set(head.key, differ.patch(head.patch, option.value))(map);
+          }
+          patches = tail;
+          break;
+        }
+    }
+  }
+  return map;
+});
+//# sourceMappingURL=hashMapPatch.js.map

node_modules/effect/dist/esm/internal/differ/hashSetPatch.js

@@ -0,0 +1,101 @@
+import * as Chunk from "../../Chunk.js";
+import * as Dual from "../../Function.js";
+import * as HashSet from "../../HashSet.js";
+import { Structural } from "../data.js";
+/** @internal */
+export const HashSetPatchTypeId = /*#__PURE__*/Symbol.for("effect/DifferHashSetPatch");
+function variance(a) {
+  return a;
+}
+/** @internal */
+const PatchProto = {
+  ...Structural.prototype,
+  [HashSetPatchTypeId]: {
+    _Value: variance,
+    _Key: variance,
+    _Patch: variance
+  }
+};
+const EmptyProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "Empty"
+});
+const _empty = /*#__PURE__*/Object.create(EmptyProto);
+/** @internal */
+export const empty = () => _empty;
+const AndThenProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "AndThen"
+});
+/** @internal */
+export const makeAndThen = (first, second) => {
+  const o = Object.create(AndThenProto);
+  o.first = first;
+  o.second = second;
+  return o;
+};
+const AddProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "Add"
+});
+/** @internal */
+export const makeAdd = value => {
+  const o = Object.create(AddProto);
+  o.value = value;
+  return o;
+};
+const RemoveProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "Remove"
+});
+/** @internal */
+export const makeRemove = value => {
+  const o = Object.create(RemoveProto);
+  o.value = value;
+  return o;
+};
+/** @internal */
+export const diff = (oldValue, newValue) => {
+  const [removed, patch] = HashSet.reduce([oldValue, empty()], ([set, patch], value) => {
+    if (HashSet.has(value)(set)) {
+      return [HashSet.remove(value)(set), patch];
+    }
+    return [set, combine(makeAdd(value))(patch)];
+  })(newValue);
+  return HashSet.reduce(patch, (patch, value) => combine(makeRemove(value))(patch))(removed);
+};
+/** @internal */
+export const combine = /*#__PURE__*/Dual.dual(2, (self, that) => makeAndThen(self, that));
+/** @internal */
+export const patch = /*#__PURE__*/Dual.dual(2, (self, oldValue) => {
+  if (self._tag === "Empty") {
+    return oldValue;
+  }
+  let set = oldValue;
+  let patches = Chunk.of(self);
+  while (Chunk.isNonEmpty(patches)) {
+    const head = Chunk.headNonEmpty(patches);
+    const tail = Chunk.tailNonEmpty(patches);
+    switch (head._tag) {
+      case "Empty":
+        {
+          patches = tail;
+          break;
+        }
+      case "AndThen":
+        {
+          patches = Chunk.prepend(head.first)(Chunk.prepend(head.second)(tail));
+          break;
+        }
+      case "Add":
+        {
+          set = HashSet.add(head.value)(set);
+          patches = tail;
+          break;
+        }
+      case "Remove":
+        {
+          set = HashSet.remove(head.value)(set);
+          patches = tail;
+        }
+    }
+  }
+  return set;
+});
+//# sourceMappingURL=hashSetPatch.js.map

node_modules/effect/dist/esm/internal/differ/hashSetPatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hashSetPatch.js","names":["Chunk","Dual","HashSet","Structural","HashSetPatchTypeId","Symbol","for","variance","a","PatchProto","prototype","_Value","_Key","_Patch","EmptyProto","Object","assign","create","_tag","_empty","empty","AndThenProto","makeAndThen","first","second","o","AddProto","makeAdd","value","RemoveProto","makeRemove","diff","oldValue","newValue","removed","patch","reduce","set","has","remove","combine","dual","self","that","patches","of","isNonEmpty","head","headNonEmpty","tail","tailNonEmpty","prepend","add"],"sources":["../../../../src/internal/differ/hashSetPatch.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

node_modules/effect/dist/esm/internal/differ/orPatch.js

@@ -0,0 +1,170 @@
+import * as Chunk from "../../Chunk.js";
+import * as E from "../../Either.js";
+import * as Equal from "../../Equal.js";
+import * as Dual from "../../Function.js";
+import { Structural } from "../data.js";
+/** @internal */
+export const OrPatchTypeId = /*#__PURE__*/Symbol.for("effect/DifferOrPatch");
+function variance(a) {
+  return a;
+}
+/** @internal */
+const PatchProto = {
+  ...Structural.prototype,
+  [OrPatchTypeId]: {
+    _Value: variance,
+    _Key: variance,
+    _Patch: variance
+  }
+};
+const EmptyProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "Empty"
+});
+const _empty = /*#__PURE__*/Object.create(EmptyProto);
+/** @internal */
+export const empty = () => _empty;
+const AndThenProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "AndThen"
+});
+/** @internal */
+export const makeAndThen = (first, second) => {
+  const o = Object.create(AndThenProto);
+  o.first = first;
+  o.second = second;
+  return o;
+};
+const SetLeftProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "SetLeft"
+});
+/** @internal */
+export const makeSetLeft = value => {
+  const o = Object.create(SetLeftProto);
+  o.value = value;
+  return o;
+};
+const SetRightProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "SetRight"
+});
+/** @internal */
+export const makeSetRight = value => {
+  const o = Object.create(SetRightProto);
+  o.value = value;
+  return o;
+};
+const UpdateLeftProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "UpdateLeft"
+});
+/** @internal */
+export const makeUpdateLeft = patch => {
+  const o = Object.create(UpdateLeftProto);
+  o.patch = patch;
+  return o;
+};
+const UpdateRightProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "UpdateRight"
+});
+/** @internal */
+export const makeUpdateRight = patch => {
+  const o = Object.create(UpdateRightProto);
+  o.patch = patch;
+  return o;
+};
+/** @internal */
+export const diff = 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.equals(valuePatch, options.left.empty)) {
+                return empty();
+              }
+              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.equals(valuePatch, options.right.empty)) {
+                return empty();
+              }
+              return makeUpdateRight(valuePatch);
+            }
+        }
+      }
+  }
+};
+/** @internal */
+export const combine = /*#__PURE__*/Dual.dual(2, (self, that) => makeAndThen(self, that));
+/** @internal */
+export const patch = /*#__PURE__*/Dual.dual(2, (self, {
+  left,
+  oldValue,
+  right
+}) => {
+  if (self._tag === "Empty") {
+    return oldValue;
+  }
+  let patches = Chunk.of(self);
+  let result = oldValue;
+  while (Chunk.isNonEmpty(patches)) {
+    const head = Chunk.headNonEmpty(patches);
+    const tail = Chunk.tailNonEmpty(patches);
+    switch (head._tag) {
+      case "Empty":
+        {
+          patches = tail;
+          break;
+        }
+      case "AndThen":
+        {
+          patches = Chunk.prepend(head.first)(Chunk.prepend(head.second)(tail));
+          break;
+        }
+      case "UpdateLeft":
+        {
+          if (result._tag === "Left") {
+            result = E.left(left.patch(head.patch, result.left));
+          }
+          patches = tail;
+          break;
+        }
+      case "UpdateRight":
+        {
+          if (result._tag === "Right") {
+            result = E.right(right.patch(head.patch, result.right));
+          }
+          patches = tail;
+          break;
+        }
+      case "SetLeft":
+        {
+          result = E.left(head.value);
+          patches = tail;
+          break;
+        }
+      case "SetRight":
+        {
+          result = E.right(head.value);
+          patches = tail;
+          break;
+        }
+    }
+  }
+  return result;
+});
+//# sourceMappingURL=orPatch.js.map

node_modules/effect/dist/esm/internal/differ/readonlyArrayPatch.js

@@ -0,0 +1,129 @@
+import * as Arr from "../../Array.js";
+import * as Equal from "../../Equal.js";
+import * as Dual from "../../Function.js";
+import * as Data from "../data.js";
+/** @internal */
+export const ReadonlyArrayPatchTypeId = /*#__PURE__*/Symbol.for("effect/DifferReadonlyArrayPatch");
+function variance(a) {
+  return a;
+}
+const PatchProto = {
+  ...Data.Structural.prototype,
+  [ReadonlyArrayPatchTypeId]: {
+    _Value: variance,
+    _Patch: variance
+  }
+};
+const EmptyProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "Empty"
+});
+const _empty = /*#__PURE__*/Object.create(EmptyProto);
+/**
+ * @internal
+ */
+export const empty = () => _empty;
+const AndThenProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "AndThen"
+});
+const makeAndThen = (first, second) => {
+  const o = Object.create(AndThenProto);
+  o.first = first;
+  o.second = second;
+  return o;
+};
+const AppendProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "Append"
+});
+const makeAppend = values => {
+  const o = Object.create(AppendProto);
+  o.values = values;
+  return o;
+};
+const SliceProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "Slice"
+});
+const makeSlice = (from, until) => {
+  const o = Object.create(SliceProto);
+  o.from = from;
+  o.until = until;
+  return o;
+};
+const UpdateProto = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(PatchProto), {
+  _tag: "Update"
+});
+const makeUpdate = (index, patch) => {
+  const o = Object.create(UpdateProto);
+  o.index = index;
+  o.patch = patch;
+  return o;
+};
+/** @internal */
+export const diff = options => {
+  let i = 0;
+  let patch = empty();
+  while (i < options.oldValue.length && i < options.newValue.length) {
+    const oldElement = options.oldValue[i];
+    const newElement = options.newValue[i];
+    const valuePatch = options.differ.diff(oldElement, newElement);
+    if (!Equal.equals(valuePatch, options.differ.empty)) {
+      patch = combine(patch, makeUpdate(i, valuePatch));
+    }
+    i = i + 1;
+  }
+  if (i < options.oldValue.length) {
+    patch = combine(patch, makeSlice(0, i));
+  }
+  if (i < options.newValue.length) {
+    patch = combine(patch, makeAppend(Arr.drop(i)(options.newValue)));
+  }
+  return patch;
+};
+/** @internal */
+export const combine = /*#__PURE__*/Dual.dual(2, (self, that) => makeAndThen(self, that));
+/** @internal */
+export const patch = /*#__PURE__*/Dual.dual(3, (self, oldValue, differ) => {
+  if (self._tag === "Empty") {
+    return oldValue;
+  }
+  let readonlyArray = oldValue.slice();
+  let patches = Arr.of(self);
+  while (Arr.isNonEmptyArray(patches)) {
+    const head = Arr.headNonEmpty(patches);
+    const tail = Arr.tailNonEmpty(patches);
+    switch (head._tag) {
+      case "Empty":
+        {
+          patches = tail;
+          break;
+        }
+      case "AndThen":
+        {
+          tail.unshift(head.first, head.second);
+          patches = tail;
+          break;
+        }
+      case "Append":
+        {
+          for (const value of head.values) {
+            readonlyArray.push(value);
+          }
+          patches = tail;
+          break;
+        }
+      case "Slice":
+        {
+          readonlyArray = readonlyArray.slice(head.from, head.until);
+          patches = tail;
+          break;
+        }
+      case "Update":
+        {
+          readonlyArray[head.index] = differ.patch(head.patch, readonlyArray[head.index]);
+          patches = tail;
+          break;
+        }
+    }
+  }
+  return readonlyArray;
+});
+//# sourceMappingURL=readonlyArrayPatch.js.map

node_modules/effect/dist/esm/internal/differ/readonlyArrayPatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readonlyArrayPatch.js","names":["Arr","Equal","Dual","Data","ReadonlyArrayPatchTypeId","Symbol","for","variance","a","PatchProto","Structural","prototype","_Value","_Patch","EmptyProto","Object","assign","create","_tag","_empty","empty","AndThenProto","makeAndThen","first","second","o","AppendProto","makeAppend","values","SliceProto","makeSlice","from","until","UpdateProto","makeUpdate","index","patch","diff","options","i","oldValue","length","newValue","oldElement","newElement","valuePatch","differ","equals","combine","drop","dual","self","that","readonlyArray","slice","patches","of","isNonEmptyArray","head","headNonEmpty","tail","tailNonEmpty","unshift","value","push"],"sources":["../../../../src/internal/differ/readonlyArrayPatch.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}