@slicemachine/manager 0.22.2-alpha.dani-snippets.7 → 0.22.2-alpha.dani-repeatable-links-codegen.1

package/dist/_node_modules/fp-ts/es6/ReadonlyRecord.js

@@ -0,0 +1,1019 @@
+import { fromEquals } from "./Eq.js";
+import { pipe, identity, flow, SK } from "./function.js";
+import { flap as flap$1 } from "./Functor.js";
+import { has as has$1, some as some$1, none, isNone, isSome, isLeft } from "./internal.js";
+import { separated } from "./Separated.js";
+import { Ord } from "./string.js";
+import { witherDefault, wiltDefault } from "./Witherable.js";
+var fromRecord = function(r) {
+  return Object.assign({}, r);
+};
+var toRecord = function(r) {
+  return Object.assign({}, r);
+};
+var size = function(r) {
+  return Object.keys(r).length;
+};
+var isEmpty = function(r) {
+  for (var k in r) {
+    if (has$1.call(r, k)) {
+      return false;
+    }
+  }
+  return true;
+};
+var keys_ = function(O) {
+  return function(r) {
+    return Object.keys(r).sort(O.compare);
+  };
+};
+var keys = /* @__PURE__ */ keys_(Ord);
+function collect(O) {
+  if (typeof O === "function") {
+    return collect(Ord)(O);
+  }
+  var keysO = keys_(O);
+  return function(f) {
+    return function(r) {
+      var out = [];
+      for (var _i = 0, _a = keysO(r); _i < _a.length; _i++) {
+        var key = _a[_i];
+        out.push(f(key, r[key]));
+      }
+      return out;
+    };
+  };
+}
+var toReadonlyArray = /* @__PURE__ */ collect(Ord)(function(k, a) {
+  return [k, a];
+});
+function toUnfoldable(U) {
+  return function(r) {
+    var sas = toReadonlyArray(r);
+    var len = sas.length;
+    return U.unfold(0, function(b) {
+      return b < len ? some$1([sas[b], b + 1]) : none;
+    });
+  };
+}
+var upsertAt = function(k, a) {
+  return function(r) {
+    if (has$1.call(r, k) && r[k] === a) {
+      return r;
+    }
+    var out = Object.assign({}, r);
+    out[k] = a;
+    return out;
+  };
+};
+var has = function(k, r) {
+  return has$1.call(r, k);
+};
+function deleteAt(k) {
+  return function(r) {
+    if (!has$1.call(r, k)) {
+      return r;
+    }
+    var out = Object.assign({}, r);
+    delete out[k];
+    return out;
+  };
+}
+var updateAt = function(k, a) {
+  return function(r) {
+    if (!has(k, r)) {
+      return none;
+    }
+    if (r[k] === a) {
+      return some$1(r);
+    }
+    var out = Object.assign({}, r);
+    out[k] = a;
+    return some$1(out);
+  };
+};
+var modifyAt = function(k, f) {
+  return function(r) {
+    if (!has(k, r)) {
+      return none;
+    }
+    var next = f(r[k]);
+    if (next === r[k]) {
+      return some$1(r);
+    }
+    var out = Object.assign({}, r);
+    out[k] = next;
+    return some$1(out);
+  };
+};
+function pop(k) {
+  var deleteAtk = deleteAt(k);
+  return function(r) {
+    var oa = lookup(k, r);
+    return isNone(oa) ? none : some$1([oa.value, deleteAtk(r)]);
+  };
+}
+function isSubrecord(E) {
+  return function(me, that) {
+    if (that === void 0) {
+      var isSubrecordE_1 = isSubrecord(E);
+      return function(that2) {
+        return isSubrecordE_1(that2, me);
+      };
+    }
+    for (var k in me) {
+      if (!has$1.call(that, k) || !E.equals(me[k], that[k])) {
+        return false;
+      }
+    }
+    return true;
+  };
+}
+function lookup(k, r) {
+  if (r === void 0) {
+    return function(r2) {
+      return lookup(k, r2);
+    };
+  }
+  return has$1.call(r, k) ? some$1(r[k]) : none;
+}
+var empty = {};
+function mapWithIndex(f) {
+  return function(r) {
+    var out = {};
+    for (var k in r) {
+      if (has$1.call(r, k)) {
+        out[k] = f(k, r[k]);
+      }
+    }
+    return out;
+  };
+}
+function map(f) {
+  return mapWithIndex(function(_, a) {
+    return f(a);
+  });
+}
+function reduceWithIndex() {
+  var args = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    args[_i] = arguments[_i];
+  }
+  if (args.length === 2) {
+    return reduceWithIndex(Ord).apply(void 0, args);
+  }
+  var keysO = keys_(args[0]);
+  return function(b, f) {
+    return function(fa) {
+      var out = b;
+      var ks = keysO(fa);
+      var len = ks.length;
+      for (var i = 0; i < len; i++) {
+        var k = ks[i];
+        out = f(k, out, fa[k]);
+      }
+      return out;
+    };
+  };
+}
+function foldMapWithIndex(O) {
+  if ("compare" in O) {
+    var keysO_1 = keys_(O);
+    return function(M) {
+      return function(f) {
+        return function(fa) {
+          var out = M.empty;
+          var ks = keysO_1(fa);
+          var len = ks.length;
+          for (var i = 0; i < len; i++) {
+            var k = ks[i];
+            out = M.concat(out, f(k, fa[k]));
+          }
+          return out;
+        };
+      };
+    };
+  }
+  return foldMapWithIndex(Ord)(O);
+}
+function reduceRightWithIndex() {
+  var args = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    args[_i] = arguments[_i];
+  }
+  if (args.length === 2) {
+    return reduceRightWithIndex(Ord).apply(void 0, args);
+  }
+  var keysO = keys_(args[0]);
+  return function(b, f) {
+    return function(fa) {
+      var out = b;
+      var ks = keysO(fa);
+      var len = ks.length;
+      for (var i = len - 1; i >= 0; i--) {
+        var k = ks[i];
+        out = f(k, fa[k], out);
+      }
+      return out;
+    };
+  };
+}
+var singleton = function(k, a) {
+  var _a;
+  return _a = {}, _a[k] = a, _a;
+};
+function traverseWithIndex(F) {
+  var traverseWithIndexOF = _traverseWithIndex(Ord)(F);
+  return function(f) {
+    return function(ta) {
+      return traverseWithIndexOF(ta, f);
+    };
+  };
+}
+function traverse(F) {
+  var traverseOF = _traverse(Ord)(F);
+  return function(f) {
+    return function(ta) {
+      return traverseOF(ta, f);
+    };
+  };
+}
+function sequence(F) {
+  return _sequence(Ord)(F);
+}
+var wither = function(F) {
+  var traverseF = traverse(F);
+  return function(f) {
+    return function(fa) {
+      return F.map(pipe(fa, traverseF(f)), compact);
+    };
+  };
+};
+var wilt = function(F) {
+  var traverseF = traverse(F);
+  return function(f) {
+    return function(fa) {
+      return F.map(pipe(fa, traverseF(f)), separate);
+    };
+  };
+};
+function partitionMapWithIndex(f) {
+  return function(r) {
+    var left = {};
+    var right = {};
+    for (var k in r) {
+      if (has$1.call(r, k)) {
+        var e = f(k, r[k]);
+        switch (e._tag) {
+          case "Left":
+            left[k] = e.left;
+            break;
+          case "Right":
+            right[k] = e.right;
+            break;
+        }
+      }
+    }
+    return separated(left, right);
+  };
+}
+function partitionWithIndex(predicateWithIndex) {
+  return function(r) {
+    var left = {};
+    var right = {};
+    for (var k in r) {
+      if (has$1.call(r, k)) {
+        var a = r[k];
+        if (predicateWithIndex(k, a)) {
+          right[k] = a;
+        } else {
+          left[k] = a;
+        }
+      }
+    }
+    return separated(left, right);
+  };
+}
+function filterMapWithIndex(f) {
+  return function(r) {
+    var out = {};
+    for (var k in r) {
+      if (has$1.call(r, k)) {
+        var ob = f(k, r[k]);
+        if (isSome(ob)) {
+          out[k] = ob.value;
+        }
+      }
+    }
+    return out;
+  };
+}
+function filterWithIndex(predicateWithIndex) {
+  return function(fa) {
+    var out = {};
+    var changed = false;
+    for (var key in fa) {
+      if (has$1.call(fa, key)) {
+        var a = fa[key];
+        if (predicateWithIndex(key, a)) {
+          out[key] = a;
+        } else {
+          changed = true;
+        }
+      }
+    }
+    return changed ? out : fa;
+  };
+}
+function fromFoldable(M, F) {
+  var fromFoldableMapM = fromFoldableMap(M, F);
+  return function(fka) {
+    return fromFoldableMapM(fka, identity);
+  };
+}
+function fromFoldableMap(M, F) {
+  return function(ta, f) {
+    return F.reduce(ta, {}, function(r, a) {
+      var _a = f(a), k = _a[0], b = _a[1];
+      r[k] = has$1.call(r, k) ? M.concat(r[k], b) : b;
+      return r;
+    });
+  };
+}
+var toEntries = toReadonlyArray;
+var fromEntries = function(fa) {
+  var out = {};
+  for (var _i = 0, fa_1 = fa; _i < fa_1.length; _i++) {
+    var a = fa_1[_i];
+    out[a[0]] = a[1];
+  }
+  return out;
+};
+function every(predicate) {
+  return function(r) {
+    for (var k in r) {
+      if (!predicate(r[k])) {
+        return false;
+      }
+    }
+    return true;
+  };
+}
+function some(predicate) {
+  return function(r) {
+    for (var k in r) {
+      if (predicate(r[k])) {
+        return true;
+      }
+    }
+    return false;
+  };
+}
+function elem(E) {
+  return function(a, fa) {
+    if (fa === void 0) {
+      var elemE_1 = elem(E);
+      return function(fa2) {
+        return elemE_1(a, fa2);
+      };
+    }
+    for (var k in fa) {
+      if (E.equals(fa[k], a)) {
+        return true;
+      }
+    }
+    return false;
+  };
+}
+var union = function(M) {
+  return function(second) {
+    return function(first) {
+      if (isEmpty(first)) {
+        return second;
+      }
+      if (isEmpty(second)) {
+        return first;
+      }
+      var out = {};
+      for (var k in first) {
+        if (has(k, second)) {
+          out[k] = M.concat(first[k], second[k]);
+        } else {
+          out[k] = first[k];
+        }
+      }
+      for (var k in second) {
+        if (!has(k, out)) {
+          out[k] = second[k];
+        }
+      }
+      return out;
+    };
+  };
+};
+var intersection = function(M) {
+  return function(second) {
+    return function(first) {
+      if (isEmpty(first) || isEmpty(second)) {
+        return empty;
+      }
+      var out = {};
+      for (var k in first) {
+        if (has(k, second)) {
+          out[k] = M.concat(first[k], second[k]);
+        }
+      }
+      return out;
+    };
+  };
+};
+var difference = function(second) {
+  return function(first) {
+    if (isEmpty(first)) {
+      return second;
+    }
+    if (isEmpty(second)) {
+      return first;
+    }
+    var out = {};
+    for (var k in first) {
+      if (!has(k, second)) {
+        out[k] = first[k];
+      }
+    }
+    for (var k in second) {
+      if (!has(k, first)) {
+        out[k] = second[k];
+      }
+    }
+    return out;
+  };
+};
+var _map = function(fa, f) {
+  return pipe(fa, map(f));
+};
+var _mapWithIndex = function(fa, f) {
+  return pipe(fa, mapWithIndex(f));
+};
+var _reduce = function(O) {
+  var reduceO = reduce(O);
+  return function(fa, b, f) {
+    return pipe(fa, reduceO(b, f));
+  };
+};
+var _foldMap = function(O) {
+  return function(M) {
+    var foldMapM = foldMap(O)(M);
+    return function(fa, f) {
+      return pipe(fa, foldMapM(f));
+    };
+  };
+};
+var _reduceRight = function(O) {
+  var reduceRightO = reduceRight(O);
+  return function(fa, b, f) {
+    return pipe(fa, reduceRightO(b, f));
+  };
+};
+var _filter = function(fa, predicate) {
+  return pipe(fa, filter(predicate));
+};
+var _filterMap = function(fa, f) {
+  return pipe(fa, filterMap(f));
+};
+var _partition = function(fa, predicate) {
+  return pipe(fa, partition(predicate));
+};
+var _partitionMap = function(fa, f) {
+  return pipe(fa, partitionMap(f));
+};
+var _reduceWithIndex = function(O) {
+  var reduceWithIndexO = reduceWithIndex(O);
+  return function(fa, b, f) {
+    return pipe(fa, reduceWithIndexO(b, f));
+  };
+};
+var _foldMapWithIndex = function(O) {
+  var foldMapWithIndexO = foldMapWithIndex(O);
+  return function(M) {
+    var foldMapWithIndexM = foldMapWithIndexO(M);
+    return function(fa, f) {
+      return pipe(fa, foldMapWithIndexM(f));
+    };
+  };
+};
+var _reduceRightWithIndex = function(O) {
+  var reduceRightWithIndexO = reduceRightWithIndex(O);
+  return function(fa, b, f) {
+    return pipe(fa, reduceRightWithIndexO(b, f));
+  };
+};
+var _partitionMapWithIndex = function(fa, f) {
+  return pipe(fa, partitionMapWithIndex(f));
+};
+var _partitionWithIndex = function(fa, predicateWithIndex) {
+  return pipe(fa, partitionWithIndex(predicateWithIndex));
+};
+var _filterMapWithIndex = function(fa, f) {
+  return pipe(fa, filterMapWithIndex(f));
+};
+var _filterWithIndex = function(fa, predicateWithIndex) {
+  return pipe(fa, filterWithIndex(predicateWithIndex));
+};
+var _traverse = function(O) {
+  var traverseWithIndexO = _traverseWithIndex(O);
+  return function(F) {
+    var traverseWithIndexOF = traverseWithIndexO(F);
+    return function(ta, f) {
+      return traverseWithIndexOF(ta, flow(SK, f));
+    };
+  };
+};
+var _sequence = function(O) {
+  var traverseO = _traverse(O);
+  return function(F) {
+    var traverseOF = traverseO(F);
+    return function(ta) {
+      return traverseOF(ta, identity);
+    };
+  };
+};
+var _traverseWithIndex = function(O) {
+  return function(F) {
+    var keysO = keys_(O);
+    return function(ta, f) {
+      var ks = keysO(ta);
+      if (ks.length === 0) {
+        return F.of(empty);
+      }
+      var fr = F.of({});
+      var _loop_1 = function(key2) {
+        fr = F.ap(F.map(fr, function(r) {
+          return function(b) {
+            var _a;
+            return Object.assign({}, r, (_a = {}, _a[key2] = b, _a));
+          };
+        }), f(key2, ta[key2]));
+      };
+      for (var _i = 0, ks_1 = ks; _i < ks_1.length; _i++) {
+        var key = ks_1[_i];
+        _loop_1(key);
+      }
+      return fr;
+    };
+  };
+};
+var filter = function(predicate) {
+  return filterWithIndex(function(_, a) {
+    return predicate(a);
+  });
+};
+var filterMap = function(f) {
+  return filterMapWithIndex(function(_, a) {
+    return f(a);
+  });
+};
+var partition = function(predicate) {
+  return partitionWithIndex(function(_, a) {
+    return predicate(a);
+  });
+};
+var partitionMap = function(f) {
+  return partitionMapWithIndex(function(_, a) {
+    return f(a);
+  });
+};
+function reduce() {
+  var args = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    args[_i] = arguments[_i];
+  }
+  if (args.length === 1) {
+    var reduceWithIndexO_1 = reduceWithIndex(args[0]);
+    return function(b, f) {
+      return reduceWithIndexO_1(b, function(_, b2, a) {
+        return f(b2, a);
+      });
+    };
+  }
+  return reduce(Ord).apply(void 0, args);
+}
+function foldMap(O) {
+  if ("compare" in O) {
+    var foldMapWithIndexO_1 = foldMapWithIndex(O);
+    return function(M) {
+      var foldMapWithIndexM = foldMapWithIndexO_1(M);
+      return function(f) {
+        return foldMapWithIndexM(function(_, a) {
+          return f(a);
+        });
+      };
+    };
+  }
+  return foldMap(Ord)(O);
+}
+function reduceRight() {
+  var args = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    args[_i] = arguments[_i];
+  }
+  if (args.length === 1) {
+    var reduceRightWithIndexO_1 = reduceRightWithIndex(args[0]);
+    return function(b, f) {
+      return reduceRightWithIndexO_1(b, function(_, b2, a) {
+        return f(b2, a);
+      });
+    };
+  }
+  return reduceRight(Ord).apply(void 0, args);
+}
+var compact = function(r) {
+  var out = {};
+  for (var k in r) {
+    if (has$1.call(r, k)) {
+      var oa = r[k];
+      if (isSome(oa)) {
+        out[k] = oa.value;
+      }
+    }
+  }
+  return out;
+};
+var separate = function(r) {
+  var left = {};
+  var right = {};
+  for (var k in r) {
+    if (has$1.call(r, k)) {
+      var e = r[k];
+      if (isLeft(e)) {
+        left[k] = e.left;
+      } else {
+        right[k] = e.right;
+      }
+    }
+  }
+  return separated(left, right);
+};
+var URI = "ReadonlyRecord";
+function getShow(O) {
+  if ("compare" in O) {
+    return function(S) {
+      return {
+        show: function(r) {
+          var elements = collect(O)(function(k, a) {
+            return "".concat(JSON.stringify(k), ": ").concat(S.show(a));
+          })(r).join(", ");
+          return elements === "" ? "{}" : "{ ".concat(elements, " }");
+        }
+      };
+    };
+  }
+  return getShow(Ord)(O);
+}
+function getEq(E) {
+  var isSubrecordE = isSubrecord(E);
+  return fromEquals(function(x, y) {
+    return isSubrecordE(x)(y) && isSubrecordE(y)(x);
+  });
+}
+function getMonoid(S) {
+  return {
+    concat: function(first, second) {
+      if (isEmpty(first)) {
+        return second;
+      }
+      if (isEmpty(second)) {
+        return first;
+      }
+      var r = Object.assign({}, first);
+      for (var k in second) {
+        if (has$1.call(second, k)) {
+          r[k] = has$1.call(first, k) ? S.concat(first[k], second[k]) : second[k];
+        }
+      }
+      return r;
+    },
+    empty
+  };
+}
+var Functor = {
+  URI,
+  map: _map
+};
+var flap = /* @__PURE__ */ flap$1(Functor);
+var FunctorWithIndex = {
+  URI,
+  map: _map,
+  mapWithIndex: _mapWithIndex
+};
+var getFoldable = function(O) {
+  return {
+    URI,
+    reduce: _reduce(O),
+    foldMap: _foldMap(O),
+    reduceRight: _reduceRight(O)
+  };
+};
+var getFoldableWithIndex = function(O) {
+  return {
+    URI,
+    reduce: _reduce(O),
+    foldMap: _foldMap(O),
+    reduceRight: _reduceRight(O),
+    reduceWithIndex: _reduceWithIndex(O),
+    foldMapWithIndex: _foldMapWithIndex(O),
+    reduceRightWithIndex: _reduceRightWithIndex(O)
+  };
+};
+var Compactable = {
+  URI,
+  compact,
+  separate
+};
+var Filterable = {
+  URI,
+  map: _map,
+  compact,
+  separate,
+  filter: _filter,
+  filterMap: _filterMap,
+  partition: _partition,
+  partitionMap: _partitionMap
+};
+var FilterableWithIndex = {
+  URI,
+  map: _map,
+  mapWithIndex: _mapWithIndex,
+  compact,
+  separate,
+  filter: _filter,
+  filterMap: _filterMap,
+  partition: _partition,
+  partitionMap: _partitionMap,
+  filterMapWithIndex: _filterMapWithIndex,
+  filterWithIndex: _filterWithIndex,
+  partitionMapWithIndex: _partitionMapWithIndex,
+  partitionWithIndex: _partitionWithIndex
+};
+var getTraversable = function(O) {
+  return {
+    URI,
+    map: _map,
+    reduce: _reduce(O),
+    foldMap: _foldMap(O),
+    reduceRight: _reduceRight(O),
+    traverse: _traverse(O),
+    sequence: _sequence(O)
+  };
+};
+var getTraversableWithIndex = function(O) {
+  return {
+    URI,
+    map: _map,
+    mapWithIndex: _mapWithIndex,
+    reduce: _reduce(O),
+    foldMap: _foldMap(O),
+    reduceRight: _reduceRight(O),
+    reduceWithIndex: _reduceWithIndex(O),
+    foldMapWithIndex: _foldMapWithIndex(O),
+    reduceRightWithIndex: _reduceRightWithIndex(O),
+    traverse: _traverse(O),
+    sequence: _sequence(O),
+    traverseWithIndex: _traverseWithIndex(O)
+  };
+};
+var getWitherable = function(O) {
+  var T = getTraversable(O);
+  return {
+    URI,
+    map: _map,
+    reduce: _reduce(O),
+    foldMap: _foldMap(O),
+    reduceRight: _reduceRight(O),
+    traverse: T.traverse,
+    sequence: T.sequence,
+    compact,
+    separate,
+    filter: _filter,
+    filterMap: _filterMap,
+    partition: _partition,
+    partitionMap: _partitionMap,
+    wither: witherDefault(T, Compactable),
+    wilt: wiltDefault(T, Compactable)
+  };
+};
+var getUnionSemigroup = function(S) {
+  var unionS = union(S);
+  return {
+    concat: function(first, second) {
+      return unionS(second)(first);
+    }
+  };
+};
+var getUnionMonoid = function(S) {
+  return {
+    concat: getUnionSemigroup(S).concat,
+    empty
+  };
+};
+var getIntersectionSemigroup = function(S) {
+  var intersectionS = intersection(S);
+  return {
+    concat: function(first, second) {
+      return intersectionS(second)(first);
+    }
+  };
+};
+var getDifferenceMagma = function() {
+  return {
+    concat: function(first, second) {
+      return difference(second)(first);
+    }
+  };
+};
+var Foldable = {
+  URI,
+  reduce: /* @__PURE__ */ _reduce(Ord),
+  foldMap: /* @__PURE__ */ _foldMap(Ord),
+  reduceRight: /* @__PURE__ */ _reduceRight(Ord)
+};
+var FoldableWithIndex = {
+  URI,
+  reduce: /* @__PURE__ */ _reduce(Ord),
+  foldMap: /* @__PURE__ */ _foldMap(Ord),
+  reduceRight: /* @__PURE__ */ _reduceRight(Ord),
+  reduceWithIndex: /* @__PURE__ */ _reduceWithIndex(Ord),
+  foldMapWithIndex: /* @__PURE__ */ _foldMapWithIndex(Ord),
+  reduceRightWithIndex: /* @__PURE__ */ _reduceRightWithIndex(Ord)
+};
+var Traversable = {
+  URI,
+  map: _map,
+  reduce: /* @__PURE__ */ _reduce(Ord),
+  foldMap: /* @__PURE__ */ _foldMap(Ord),
+  reduceRight: /* @__PURE__ */ _reduceRight(Ord),
+  traverse: /* @__PURE__ */ _traverse(Ord),
+  sequence
+};
+var TraversableWithIndex = {
+  URI,
+  map: _map,
+  mapWithIndex: _mapWithIndex,
+  reduce: /* @__PURE__ */ _reduce(Ord),
+  foldMap: /* @__PURE__ */ _foldMap(Ord),
+  reduceRight: /* @__PURE__ */ _reduceRight(Ord),
+  reduceWithIndex: /* @__PURE__ */ _reduceWithIndex(Ord),
+  foldMapWithIndex: /* @__PURE__ */ _foldMapWithIndex(Ord),
+  reduceRightWithIndex: /* @__PURE__ */ _reduceRightWithIndex(Ord),
+  traverse: /* @__PURE__ */ _traverse(Ord),
+  sequence,
+  traverseWithIndex: /* @__PURE__ */ _traverseWithIndex(Ord)
+};
+var _wither = /* @__PURE__ */ witherDefault(Traversable, Compactable);
+var _wilt = /* @__PURE__ */ wiltDefault(Traversable, Compactable);
+var Witherable = {
+  URI,
+  map: _map,
+  reduce: /* @__PURE__ */ _reduce(Ord),
+  foldMap: /* @__PURE__ */ _foldMap(Ord),
+  reduceRight: /* @__PURE__ */ _reduceRight(Ord),
+  traverse: /* @__PURE__ */ _traverse(Ord),
+  sequence,
+  compact,
+  separate,
+  filter: _filter,
+  filterMap: _filterMap,
+  partition: _partition,
+  partitionMap: _partitionMap,
+  wither: _wither,
+  wilt: _wilt
+};
+var insertAt = upsertAt;
+function hasOwnProperty(k, r) {
+  return has$1.call(r === void 0 ? this : r, k);
+}
+var readonlyRecord = {
+  URI,
+  map: _map,
+  reduce: /* @__PURE__ */ _reduce(Ord),
+  foldMap: /* @__PURE__ */ _foldMap(Ord),
+  reduceRight: /* @__PURE__ */ _reduceRight(Ord),
+  traverse: /* @__PURE__ */ _traverse(Ord),
+  sequence,
+  compact,
+  separate,
+  filter: _filter,
+  filterMap: _filterMap,
+  partition: _partition,
+  partitionMap: _partitionMap,
+  mapWithIndex: _mapWithIndex,
+  reduceWithIndex: /* @__PURE__ */ _reduceWithIndex(Ord),
+  foldMapWithIndex: /* @__PURE__ */ _foldMapWithIndex(Ord),
+  reduceRightWithIndex: /* @__PURE__ */ _reduceRightWithIndex(Ord),
+  filterMapWithIndex: _filterMapWithIndex,
+  filterWithIndex: _filterWithIndex,
+  partitionMapWithIndex: _partitionMapWithIndex,
+  partitionWithIndex: _partitionWithIndex,
+  traverseWithIndex: /* @__PURE__ */ _traverseWithIndex(Ord),
+  wither: _wither,
+  wilt: _wilt
+};
+export {
+  Compactable,
+  Filterable,
+  FilterableWithIndex,
+  Foldable,
+  FoldableWithIndex,
+  Functor,
+  FunctorWithIndex,
+  Traversable,
+  TraversableWithIndex,
+  URI,
+  Witherable,
+  _filter,
+  _filterMap,
+  _filterMapWithIndex,
+  _filterWithIndex,
+  _foldMap,
+  _foldMapWithIndex,
+  _map,
+  _mapWithIndex,
+  _partition,
+  _partitionMap,
+  _partitionMapWithIndex,
+  _partitionWithIndex,
+  _reduce,
+  _reduceRight,
+  _reduceRightWithIndex,
+  _reduceWithIndex,
+  _sequence,
+  _traverse,
+  collect,
+  compact,
+  deleteAt,
+  difference,
+  elem,
+  empty,
+  every,
+  filter,
+  filterMap,
+  filterMapWithIndex,
+  filterWithIndex,
+  flap,
+  foldMap,
+  foldMapWithIndex,
+  fromEntries,
+  fromFoldable,
+  fromFoldableMap,
+  fromRecord,
+  getDifferenceMagma,
+  getEq,
+  getFoldable,
+  getFoldableWithIndex,
+  getIntersectionSemigroup,
+  getMonoid,
+  getShow,
+  getTraversable,
+  getTraversableWithIndex,
+  getUnionMonoid,
+  getUnionSemigroup,
+  getWitherable,
+  has,
+  hasOwnProperty,
+  insertAt,
+  intersection,
+  isEmpty,
+  isSubrecord,
+  keys,
+  lookup,
+  map,
+  mapWithIndex,
+  modifyAt,
+  partition,
+  partitionMap,
+  partitionMapWithIndex,
+  partitionWithIndex,
+  pop,
+  readonlyRecord,
+  reduce,
+  reduceRight,
+  reduceRightWithIndex,
+  reduceWithIndex,
+  separate,
+  sequence,
+  singleton,
+  size,
+  some,
+  toEntries,
+  toReadonlyArray,
+  toRecord,
+  toUnfoldable,
+  traverse,
+  traverseWithIndex,
+  union,
+  updateAt,
+  upsertAt,
+  wilt,
+  wither
+};
+//# sourceMappingURL=ReadonlyRecord.js.map