@slicemachine/manager 0.22.2-alpha.dani-repeatable-links-codegen.2 → 0.22.2-alpha.dani-repeatable-links-warning.1

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

@@ -1,1019 +0,0 @@
-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