@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.cjs

@@ -0,0 +1,1019 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Eq = require("./Eq.cjs");
+const _function = require("./function.cjs");
+const Functor$1 = require("./Functor.cjs");
+const internal = require("./internal.cjs");
+const Separated = require("./Separated.cjs");
+const string = require("./string.cjs");
+const Witherable$1 = require("./Witherable.cjs");
+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 (internal.has.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_(string.Ord);
+function collect(O) {
+  if (typeof O === "function") {
+    return collect(string.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(string.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 ? internal.some([sas[b], b + 1]) : internal.none;
+    });
+  };
+}
+var upsertAt = function(k, a) {
+  return function(r) {
+    if (internal.has.call(r, k) && r[k] === a) {
+      return r;
+    }
+    var out = Object.assign({}, r);
+    out[k] = a;
+    return out;
+  };
+};
+var has = function(k, r) {
+  return internal.has.call(r, k);
+};
+function deleteAt(k) {
+  return function(r) {
+    if (!internal.has.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 internal.none;
+    }
+    if (r[k] === a) {
+      return internal.some(r);
+    }
+    var out = Object.assign({}, r);
+    out[k] = a;
+    return internal.some(out);
+  };
+};
+var modifyAt = function(k, f) {
+  return function(r) {
+    if (!has(k, r)) {
+      return internal.none;
+    }
+    var next = f(r[k]);
+    if (next === r[k]) {
+      return internal.some(r);
+    }
+    var out = Object.assign({}, r);
+    out[k] = next;
+    return internal.some(out);
+  };
+};
+function pop(k) {
+  var deleteAtk = deleteAt(k);
+  return function(r) {
+    var oa = lookup(k, r);
+    return internal.isNone(oa) ? internal.none : internal.some([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 (!internal.has.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 internal.has.call(r, k) ? internal.some(r[k]) : internal.none;
+}
+var empty = {};
+function mapWithIndex(f) {
+  return function(r) {
+    var out = {};
+    for (var k in r) {
+      if (internal.has.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(string.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(string.Ord)(O);
+}
+function reduceRightWithIndex() {
+  var args = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    args[_i] = arguments[_i];
+  }
+  if (args.length === 2) {
+    return reduceRightWithIndex(string.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(string.Ord)(F);
+  return function(f) {
+    return function(ta) {
+      return traverseWithIndexOF(ta, f);
+    };
+  };
+}
+function traverse(F) {
+  var traverseOF = _traverse(string.Ord)(F);
+  return function(f) {
+    return function(ta) {
+      return traverseOF(ta, f);
+    };
+  };
+}
+function sequence(F) {
+  return _sequence(string.Ord)(F);
+}
+var wither = function(F) {
+  var traverseF = traverse(F);
+  return function(f) {
+    return function(fa) {
+      return F.map(_function.pipe(fa, traverseF(f)), compact);
+    };
+  };
+};
+var wilt = function(F) {
+  var traverseF = traverse(F);
+  return function(f) {
+    return function(fa) {
+      return F.map(_function.pipe(fa, traverseF(f)), separate);
+    };
+  };
+};
+function partitionMapWithIndex(f) {
+  return function(r) {
+    var left = {};
+    var right = {};
+    for (var k in r) {
+      if (internal.has.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.separated(left, right);
+  };
+}
+function partitionWithIndex(predicateWithIndex) {
+  return function(r) {
+    var left = {};
+    var right = {};
+    for (var k in r) {
+      if (internal.has.call(r, k)) {
+        var a = r[k];
+        if (predicateWithIndex(k, a)) {
+          right[k] = a;
+        } else {
+          left[k] = a;
+        }
+      }
+    }
+    return Separated.separated(left, right);
+  };
+}
+function filterMapWithIndex(f) {
+  return function(r) {
+    var out = {};
+    for (var k in r) {
+      if (internal.has.call(r, k)) {
+        var ob = f(k, r[k]);
+        if (internal.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 (internal.has.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, _function.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] = internal.has.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 _function.pipe(fa, map(f));
+};
+var _mapWithIndex = function(fa, f) {
+  return _function.pipe(fa, mapWithIndex(f));
+};
+var _reduce = function(O) {
+  var reduceO = reduce(O);
+  return function(fa, b, f) {
+    return _function.pipe(fa, reduceO(b, f));
+  };
+};
+var _foldMap = function(O) {
+  return function(M) {
+    var foldMapM = foldMap(O)(M);
+    return function(fa, f) {
+      return _function.pipe(fa, foldMapM(f));
+    };
+  };
+};
+var _reduceRight = function(O) {
+  var reduceRightO = reduceRight(O);
+  return function(fa, b, f) {
+    return _function.pipe(fa, reduceRightO(b, f));
+  };
+};
+var _filter = function(fa, predicate) {
+  return _function.pipe(fa, filter(predicate));
+};
+var _filterMap = function(fa, f) {
+  return _function.pipe(fa, filterMap(f));
+};
+var _partition = function(fa, predicate) {
+  return _function.pipe(fa, partition(predicate));
+};
+var _partitionMap = function(fa, f) {
+  return _function.pipe(fa, partitionMap(f));
+};
+var _reduceWithIndex = function(O) {
+  var reduceWithIndexO = reduceWithIndex(O);
+  return function(fa, b, f) {
+    return _function.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 _function.pipe(fa, foldMapWithIndexM(f));
+    };
+  };
+};
+var _reduceRightWithIndex = function(O) {
+  var reduceRightWithIndexO = reduceRightWithIndex(O);
+  return function(fa, b, f) {
+    return _function.pipe(fa, reduceRightWithIndexO(b, f));
+  };
+};
+var _partitionMapWithIndex = function(fa, f) {
+  return _function.pipe(fa, partitionMapWithIndex(f));
+};
+var _partitionWithIndex = function(fa, predicateWithIndex) {
+  return _function.pipe(fa, partitionWithIndex(predicateWithIndex));
+};
+var _filterMapWithIndex = function(fa, f) {
+  return _function.pipe(fa, filterMapWithIndex(f));
+};
+var _filterWithIndex = function(fa, predicateWithIndex) {
+  return _function.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, _function.flow(_function.SK, f));
+    };
+  };
+};
+var _sequence = function(O) {
+  var traverseO = _traverse(O);
+  return function(F) {
+    var traverseOF = traverseO(F);
+    return function(ta) {
+      return traverseOF(ta, _function.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(string.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(string.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(string.Ord).apply(void 0, args);
+}
+var compact = function(r) {
+  var out = {};
+  for (var k in r) {
+    if (internal.has.call(r, k)) {
+      var oa = r[k];
+      if (internal.isSome(oa)) {
+        out[k] = oa.value;
+      }
+    }
+  }
+  return out;
+};
+var separate = function(r) {
+  var left = {};
+  var right = {};
+  for (var k in r) {
+    if (internal.has.call(r, k)) {
+      var e = r[k];
+      if (internal.isLeft(e)) {
+        left[k] = e.left;
+      } else {
+        right[k] = e.right;
+      }
+    }
+  }
+  return Separated.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(string.Ord)(O);
+}
+function getEq(E) {
+  var isSubrecordE = isSubrecord(E);
+  return Eq.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 (internal.has.call(second, k)) {
+          r[k] = internal.has.call(first, k) ? S.concat(first[k], second[k]) : second[k];
+        }
+      }
+      return r;
+    },
+    empty
+  };
+}
+var Functor = {
+  URI,
+  map: _map
+};
+var flap = /* @__PURE__ */ Functor$1.flap(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: Witherable$1.witherDefault(T, Compactable),
+    wilt: Witherable$1.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(string.Ord),
+  foldMap: /* @__PURE__ */ _foldMap(string.Ord),
+  reduceRight: /* @__PURE__ */ _reduceRight(string.Ord)
+};
+var FoldableWithIndex = {
+  URI,
+  reduce: /* @__PURE__ */ _reduce(string.Ord),
+  foldMap: /* @__PURE__ */ _foldMap(string.Ord),
+  reduceRight: /* @__PURE__ */ _reduceRight(string.Ord),
+  reduceWithIndex: /* @__PURE__ */ _reduceWithIndex(string.Ord),
+  foldMapWithIndex: /* @__PURE__ */ _foldMapWithIndex(string.Ord),
+  reduceRightWithIndex: /* @__PURE__ */ _reduceRightWithIndex(string.Ord)
+};
+var Traversable = {
+  URI,
+  map: _map,
+  reduce: /* @__PURE__ */ _reduce(string.Ord),
+  foldMap: /* @__PURE__ */ _foldMap(string.Ord),
+  reduceRight: /* @__PURE__ */ _reduceRight(string.Ord),
+  traverse: /* @__PURE__ */ _traverse(string.Ord),
+  sequence
+};
+var TraversableWithIndex = {
+  URI,
+  map: _map,
+  mapWithIndex: _mapWithIndex,
+  reduce: /* @__PURE__ */ _reduce(string.Ord),
+  foldMap: /* @__PURE__ */ _foldMap(string.Ord),
+  reduceRight: /* @__PURE__ */ _reduceRight(string.Ord),
+  reduceWithIndex: /* @__PURE__ */ _reduceWithIndex(string.Ord),
+  foldMapWithIndex: /* @__PURE__ */ _foldMapWithIndex(string.Ord),
+  reduceRightWithIndex: /* @__PURE__ */ _reduceRightWithIndex(string.Ord),
+  traverse: /* @__PURE__ */ _traverse(string.Ord),
+  sequence,
+  traverseWithIndex: /* @__PURE__ */ _traverseWithIndex(string.Ord)
+};
+var _wither = /* @__PURE__ */ Witherable$1.witherDefault(Traversable, Compactable);
+var _wilt = /* @__PURE__ */ Witherable$1.wiltDefault(Traversable, Compactable);
+var Witherable = {
+  URI,
+  map: _map,
+  reduce: /* @__PURE__ */ _reduce(string.Ord),
+  foldMap: /* @__PURE__ */ _foldMap(string.Ord),
+  reduceRight: /* @__PURE__ */ _reduceRight(string.Ord),
+  traverse: /* @__PURE__ */ _traverse(string.Ord),
+  sequence,
+  compact,
+  separate,
+  filter: _filter,
+  filterMap: _filterMap,
+  partition: _partition,
+  partitionMap: _partitionMap,
+  wither: _wither,
+  wilt: _wilt
+};
+var insertAt = upsertAt;
+function hasOwnProperty(k, r) {
+  return internal.has.call(r === void 0 ? this : r, k);
+}
+var readonlyRecord = {
+  URI,
+  map: _map,
+  reduce: /* @__PURE__ */ _reduce(string.Ord),
+  foldMap: /* @__PURE__ */ _foldMap(string.Ord),
+  reduceRight: /* @__PURE__ */ _reduceRight(string.Ord),
+  traverse: /* @__PURE__ */ _traverse(string.Ord),
+  sequence,
+  compact,
+  separate,
+  filter: _filter,
+  filterMap: _filterMap,
+  partition: _partition,
+  partitionMap: _partitionMap,
+  mapWithIndex: _mapWithIndex,
+  reduceWithIndex: /* @__PURE__ */ _reduceWithIndex(string.Ord),
+  foldMapWithIndex: /* @__PURE__ */ _foldMapWithIndex(string.Ord),
+  reduceRightWithIndex: /* @__PURE__ */ _reduceRightWithIndex(string.Ord),
+  filterMapWithIndex: _filterMapWithIndex,
+  filterWithIndex: _filterWithIndex,
+  partitionMapWithIndex: _partitionMapWithIndex,
+  partitionWithIndex: _partitionWithIndex,
+  traverseWithIndex: /* @__PURE__ */ _traverseWithIndex(string.Ord),
+  wither: _wither,
+  wilt: _wilt
+};
+exports.Compactable = Compactable;
+exports.Filterable = Filterable;
+exports.FilterableWithIndex = FilterableWithIndex;
+exports.Foldable = Foldable;
+exports.FoldableWithIndex = FoldableWithIndex;
+exports.Functor = Functor;
+exports.FunctorWithIndex = FunctorWithIndex;
+exports.Traversable = Traversable;
+exports.TraversableWithIndex = TraversableWithIndex;
+exports.URI = URI;
+exports.Witherable = Witherable;
+exports._filter = _filter;
+exports._filterMap = _filterMap;
+exports._filterMapWithIndex = _filterMapWithIndex;
+exports._filterWithIndex = _filterWithIndex;
+exports._foldMap = _foldMap;
+exports._foldMapWithIndex = _foldMapWithIndex;
+exports._map = _map;
+exports._mapWithIndex = _mapWithIndex;
+exports._partition = _partition;
+exports._partitionMap = _partitionMap;
+exports._partitionMapWithIndex = _partitionMapWithIndex;
+exports._partitionWithIndex = _partitionWithIndex;
+exports._reduce = _reduce;
+exports._reduceRight = _reduceRight;
+exports._reduceRightWithIndex = _reduceRightWithIndex;
+exports._reduceWithIndex = _reduceWithIndex;
+exports._sequence = _sequence;
+exports._traverse = _traverse;
+exports.collect = collect;
+exports.compact = compact;
+exports.deleteAt = deleteAt;
+exports.difference = difference;
+exports.elem = elem;
+exports.empty = empty;
+exports.every = every;
+exports.filter = filter;
+exports.filterMap = filterMap;
+exports.filterMapWithIndex = filterMapWithIndex;
+exports.filterWithIndex = filterWithIndex;
+exports.flap = flap;
+exports.foldMap = foldMap;
+exports.foldMapWithIndex = foldMapWithIndex;
+exports.fromEntries = fromEntries;
+exports.fromFoldable = fromFoldable;
+exports.fromFoldableMap = fromFoldableMap;
+exports.fromRecord = fromRecord;
+exports.getDifferenceMagma = getDifferenceMagma;
+exports.getEq = getEq;
+exports.getFoldable = getFoldable;
+exports.getFoldableWithIndex = getFoldableWithIndex;
+exports.getIntersectionSemigroup = getIntersectionSemigroup;
+exports.getMonoid = getMonoid;
+exports.getShow = getShow;
+exports.getTraversable = getTraversable;
+exports.getTraversableWithIndex = getTraversableWithIndex;
+exports.getUnionMonoid = getUnionMonoid;
+exports.getUnionSemigroup = getUnionSemigroup;
+exports.getWitherable = getWitherable;
+exports.has = has;
+exports.hasOwnProperty = hasOwnProperty;
+exports.insertAt = insertAt;
+exports.intersection = intersection;
+exports.isEmpty = isEmpty;
+exports.isSubrecord = isSubrecord;
+exports.keys = keys;
+exports.lookup = lookup;
+exports.map = map;
+exports.mapWithIndex = mapWithIndex;
+exports.modifyAt = modifyAt;
+exports.partition = partition;
+exports.partitionMap = partitionMap;
+exports.partitionMapWithIndex = partitionMapWithIndex;
+exports.partitionWithIndex = partitionWithIndex;
+exports.pop = pop;
+exports.readonlyRecord = readonlyRecord;
+exports.reduce = reduce;
+exports.reduceRight = reduceRight;
+exports.reduceRightWithIndex = reduceRightWithIndex;
+exports.reduceWithIndex = reduceWithIndex;
+exports.separate = separate;
+exports.sequence = sequence;
+exports.singleton = singleton;
+exports.size = size;
+exports.some = some;
+exports.toEntries = toEntries;
+exports.toReadonlyArray = toReadonlyArray;
+exports.toRecord = toRecord;
+exports.toUnfoldable = toUnfoldable;
+exports.traverse = traverse;
+exports.traverseWithIndex = traverseWithIndex;
+exports.union = union;
+exports.updateAt = updateAt;
+exports.upsertAt = upsertAt;
+exports.wilt = wilt;
+exports.wither = wither;
+//# sourceMappingURL=ReadonlyRecord.cjs.map