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

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

@@ -0,0 +1,568 @@
+import { Foldable as Foldable$1 } from "./Array.js";
+import { pipe } from "./function.js";
+import { flap as flap$1 } from "./Functor.js";
+import { some as some$1, none, has as has$2, isNone } from "./internal.js";
+import { size as size$1, isEmpty as isEmpty$1, upsertAt as upsertAt$1, has as has$1, isSubrecord as isSubrecord$1, lookup as lookup$1, mapWithIndex as mapWithIndex$1, map as map$1, reduceWithIndex as reduceWithIndex$1, foldMapWithIndex as foldMapWithIndex$1, reduceRightWithIndex as reduceRightWithIndex$1, singleton as singleton$1, traverseWithIndex as traverseWithIndex$1, traverse as traverse$1, sequence as sequence$1, partitionMapWithIndex as partitionMapWithIndex$1, partitionWithIndex as partitionWithIndex$1, filterMapWithIndex as filterMapWithIndex$1, filterWithIndex as filterWithIndex$1, fromFoldable as fromFoldable$1, fromFoldableMap as fromFoldableMap$1, every as every$1, some as some$2, elem as elem$1, intersection as intersection$1, difference as difference$1, filter as filter$1, filterMap as filterMap$1, partition as partition$1, partitionMap as partitionMap$1, reduce as reduce$1, foldMap as foldMap$1, reduceRight as reduceRight$1, compact as compact$1, separate as separate$1, getShow as getShow$1, getEq as getEq$1, getMonoid as getMonoid$1, hasOwnProperty as hasOwnProperty$1, union as union$1, _map as _map$1, _mapWithIndex as _mapWithIndex$1, _reduce as _reduce$1, _foldMap as _foldMap$1, _reduceRight as _reduceRight$1, _filter as _filter$1, _filterMap as _filterMap$1, _partition as _partition$1, _partitionMap as _partitionMap$1, _reduceWithIndex as _reduceWithIndex$1, _foldMapWithIndex as _foldMapWithIndex$1, _reduceRightWithIndex as _reduceRightWithIndex$1, _partitionMapWithIndex as _partitionMapWithIndex$1, _partitionWithIndex as _partitionWithIndex$1, _filterMapWithIndex as _filterMapWithIndex$1, _filterWithIndex as _filterWithIndex$1, _traverse as _traverse$1, _sequence as _sequence$1 } from "./ReadonlyRecord.js";
+import { last } from "./Semigroup.js";
+import { Ord } from "./string.js";
+import { witherDefault, wiltDefault } from "./Witherable.js";
+var __assign = globalThis && globalThis.__assign || function() {
+  __assign = Object.assign || function(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s)
+        if (Object.prototype.hasOwnProperty.call(s, p))
+          t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+var size = size$1;
+var isEmpty = isEmpty$1;
+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 toArray = /* @__PURE__ */ collect(Ord)(function(k, a) {
+  return [
+    k,
+    a
+  ];
+});
+function toUnfoldable(U) {
+  return function(r) {
+    var sas = toArray(r);
+    var len = sas.length;
+    return U.unfold(0, function(b) {
+      return b < len ? some$1([sas[b], b + 1]) : none;
+    });
+  };
+}
+var upsertAt = upsertAt$1;
+var has = has$1;
+function deleteAt(k) {
+  return function(r) {
+    if (!has$2.call(r, k)) {
+      return r;
+    }
+    var out = Object.assign({}, r);
+    delete out[k];
+    return out;
+  };
+}
+var updateAt = function(k, a) {
+  return modifyAt(k, function() {
+    return a;
+  });
+};
+var modifyAt = function(k, f) {
+  return function(r) {
+    if (!has(k, r)) {
+      return none;
+    }
+    var out = Object.assign({}, r);
+    out[k] = f(r[k]);
+    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)]);
+  };
+}
+var isSubrecord = isSubrecord$1;
+var lookup = lookup$1;
+var mapWithIndex = mapWithIndex$1;
+var map = map$1;
+function reduceWithIndex() {
+  var args = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    args[_i] = arguments[_i];
+  }
+  return args.length === 1 ? reduceWithIndex$1(args[0]) : reduceWithIndex$1(Ord).apply(void 0, args);
+}
+function foldMapWithIndex(O) {
+  return "compare" in O ? foldMapWithIndex$1(O) : foldMapWithIndex$1(Ord)(O);
+}
+function reduceRightWithIndex() {
+  var args = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    args[_i] = arguments[_i];
+  }
+  return args.length === 1 ? reduceRightWithIndex$1(args[0]) : reduceRightWithIndex$1(Ord).apply(void 0, args);
+}
+var singleton = singleton$1;
+function traverseWithIndex(F) {
+  return traverseWithIndex$1(F);
+}
+function traverse(F) {
+  return traverse$1(F);
+}
+function sequence(F) {
+  return sequence$1(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);
+    };
+  };
+};
+var partitionMapWithIndex = partitionMapWithIndex$1;
+function partitionWithIndex(predicateWithIndex) {
+  return partitionWithIndex$1(predicateWithIndex);
+}
+var filterMapWithIndex = filterMapWithIndex$1;
+function filterWithIndex(predicateWithIndex) {
+  return filterWithIndex$1(predicateWithIndex);
+}
+function fromFoldable(M, F) {
+  return fromFoldable$1(M, F);
+}
+var toEntries = toArray;
+var fromEntries = function(fa) {
+  return fromFoldable(last(), Foldable$1)(fa);
+};
+function fromFoldableMap(M, F) {
+  return fromFoldableMap$1(M, F);
+}
+var every = every$1;
+var some = some$2;
+var elem = elem$1;
+var union = function(M) {
+  var unionM = union$1(M);
+  return function(second) {
+    return function(first) {
+      if (isEmpty(first)) {
+        return __assign({}, second);
+      }
+      if (isEmpty(second)) {
+        return __assign({}, first);
+      }
+      return unionM(second)(first);
+    };
+  };
+};
+var intersection = function(M) {
+  return function(second) {
+    return function(first) {
+      if (isEmpty(first) || isEmpty(second)) {
+        return {};
+      }
+      return intersection$1(M)(second)(first);
+    };
+  };
+};
+var difference = function(second) {
+  return function(first) {
+    if (isEmpty(first)) {
+      return __assign({}, second);
+    }
+    if (isEmpty(second)) {
+      return __assign({}, first);
+    }
+    return difference$1(second)(first);
+  };
+};
+var _map = _map$1;
+var _mapWithIndex = _mapWithIndex$1;
+var _reduce = _reduce$1;
+var _foldMap = _foldMap$1;
+var _reduceRight = _reduceRight$1;
+var _filter = _filter$1;
+var _filterMap = _filterMap$1;
+var _partition = _partition$1;
+var _partitionMap = _partitionMap$1;
+var _reduceWithIndex = _reduceWithIndex$1;
+var _foldMapWithIndex = _foldMapWithIndex$1;
+var _reduceRightWithIndex = _reduceRightWithIndex$1;
+var _partitionMapWithIndex = _partitionMapWithIndex$1;
+var _partitionWithIndex = _partitionWithIndex$1;
+var _filterMapWithIndex = _filterMapWithIndex$1;
+var _filterWithIndex = _filterWithIndex$1;
+var _traverse = _traverse$1;
+var _sequence = _sequence$1;
+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({});
+      }
+      var fr = F.of({});
+      var _loop_1 = function(key2) {
+        fr = F.ap(F.map(fr, function(r) {
+          return function(b) {
+            r[key2] = b;
+            return r;
+          };
+        }), 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 = filter$1;
+var filterMap = filterMap$1;
+var partition = partition$1;
+var partitionMap = partitionMap$1;
+function reduce() {
+  var args = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    args[_i] = arguments[_i];
+  }
+  return args.length === 1 ? reduce$1(args[0]) : reduce$1(Ord).apply(void 0, args);
+}
+function foldMap(O) {
+  return "compare" in O ? foldMap$1(O) : foldMap$1(Ord)(O);
+}
+function reduceRight() {
+  var args = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    args[_i] = arguments[_i];
+  }
+  return args.length === 1 ? reduceRight$1(args[0]) : reduceRight$1(Ord).apply(void 0, args);
+}
+var compact = compact$1;
+var separate = separate$1;
+var URI = "Record";
+function getShow(O) {
+  return "compare" in O ? getShow$1(O) : getShow$1(Ord)(O);
+}
+var getEq = getEq$1;
+var getMonoid = getMonoid$1;
+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 empty = {};
+var insertAt = upsertAt;
+var hasOwnProperty = hasOwnProperty$1;
+var record = {
+  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,
+  collect,
+  compact,
+  deleteAt,
+  difference,
+  elem,
+  empty,
+  every,
+  filter,
+  filterMap,
+  filterMapWithIndex,
+  filterWithIndex,
+  flap,
+  foldMap,
+  foldMapWithIndex,
+  fromEntries,
+  fromFoldable,
+  fromFoldableMap,
+  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,
+  record,
+  reduce,
+  reduceRight,
+  reduceRightWithIndex,
+  reduceWithIndex,
+  separate,
+  sequence,
+  singleton,
+  size,
+  some,
+  toArray,
+  toEntries,
+  toUnfoldable,
+  traverse,
+  traverseWithIndex,
+  union,
+  updateAt,
+  upsertAt,
+  wilt,
+  wither
+};
+//# sourceMappingURL=Record.js.map

package/dist/_node_modules/fp-ts/es6/Record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Record.js","sources":["../../../../../../node_modules/fp-ts/es6/Record.js"],"sourcesContent":["var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nimport * as A from './Array';\nimport { pipe } from './function';\nimport { flap as flap_ } from './Functor';\nimport * as _ from './internal';\nimport * as RR from './ReadonlyRecord';\nimport * as Se from './Semigroup';\nimport * as S from './string';\nimport { wiltDefault, witherDefault } from './Witherable';\n// -------------------------------------------------------------------------------------\n// model\n// -------------------------------------------------------------------------------------\n/**\n * Calculate the number of key/value pairs in a `Record`.\n *\n * @example\n * import { size } from \"fp-ts/Record\";\n *\n * assert.deepStrictEqual(size({ a: true, b: 2, c: \"three\" }), 3);\n *\n * @since 2.0.0\n */\nexport var size = RR.size;\n/**\n * Test whether a `Record` is empty.\n *\n * @example\n * import { isEmpty } from \"fp-ts/Record\";\n *\n * assert.deepStrictEqual(isEmpty({}), true);\n * assert.deepStrictEqual(isEmpty({ a: 3 }), false);\n *\n * @since 2.0.0\n */\nexport var isEmpty = RR.isEmpty;\nvar keys_ = function (O) {\n    return function (r) {\n        return Object.keys(r).sort(O.compare);\n    };\n};\n/**\n * The keys of a `Record`, sorted alphabetically.\n *\n * @example\n * import { keys } from \"fp-ts/Record\";\n *\n * assert.deepStrictEqual(keys({ c: 1, a: 2, b: 3 }), [\"a\", \"b\", \"c\"]);\n *\n * @since 2.0.0\n */\nexport var keys = /*#__PURE__*/ keys_(S.Ord);\nexport function collect(O) {\n    if (typeof O === 'function') {\n        return collect(S.Ord)(O);\n    }\n    var keysO = keys_(O);\n    return function (f) {\n        return function (r) {\n            var out = [];\n            for (var _i = 0, _a = keysO(r); _i < _a.length; _i++) {\n                var key = _a[_i];\n                out.push(f(key, r[key]));\n            }\n            return out;\n        };\n    };\n}\n/**\n * Get a sorted `Array` of the key/value pairs contained in a `Record`.\n * Sorted alphabetically by key.\n *\n * @example\n * import { toArray } from 'fp-ts/Record'\n *\n * const x = { c: 3, a: \"foo\", b: false };\n * assert.deepStrictEqual(toArray(x), [\n *   [\"a\", \"foo\"],\n *   [\"b\", false],\n *   [\"c\", 3],\n * ]);\n *\n * @category conversions\n * @since 2.0.0\n */\nexport var toArray = /*#__PURE__*/ collect(S.Ord)(function (k, a) { return [\n    k,\n    a\n]; });\nexport function toUnfoldable(U) {\n    return function (r) {\n        var sas = toArray(r);\n        var len = sas.length;\n        return U.unfold(0, function (b) { return (b < len ? _.some([sas[b], b + 1]) : _.none); });\n    };\n}\n/**\n * Insert or replace a key/value pair in a `Record`.\n *\n * @example\n * import { upsertAt } from 'fp-ts/Record'\n *\n * assert.deepStrictEqual(upsertAt(\"a\", 5)({ a: 1, b: 2 }), { a: 5, b: 2 });\n * assert.deepStrictEqual(upsertAt(\"c\", 5)({ a: 1, b: 2 }), { a: 1, b: 2, c: 5 });\n *\n * @since 2.10.0\n */\nexport var upsertAt = RR.upsertAt;\n/**\n * Test whether or not a key exists in a `Record`.\n *\n * Note. This function is not pipeable because is a `Refinement`.\n *\n * @example\n * import { has } from 'fp-ts/Record'\n *\n * assert.deepStrictEqual(has(\"a\", { a: 1, b: 2 }), true);\n * assert.deepStrictEqual(has(\"c\", { a: 1, b: 2 }), false);\n *\n * @since 2.10.0\n */\nexport var has = RR.has;\nexport function deleteAt(k) {\n    return function (r) {\n        if (!_.has.call(r, k)) {\n            return r;\n        }\n        var out = Object.assign({}, r);\n        delete out[k];\n        return out;\n    };\n}\n/**\n * Replace a key/value pair in a `Record`.\n *\n * @returns If the specified key exists it returns an `Option` containing a new `Record`\n * with the entry updated, otherwise it returns `None`\n *\n * @example\n * import { updateAt } from 'fp-ts/Record'\n * import { option } from 'fp-ts'\n *\n * assert.deepStrictEqual(updateAt(\"a\", 3)({ a: 1, b: 2 }), option.some({ a: 3, b: 2 }));\n * assert.deepStrictEqual(updateAt(\"c\", 3)({ a: 1, b: 2 }), option.none);\n *\n * @since 2.0.0\n */\nexport var updateAt = function (k, a) {\n    return modifyAt(k, function () { return a; });\n};\n/**\n * Applies a mapping function to one spcific key/value pair in a `Record`.\n *\n * @returns If the specified key exists it returns an `Option` containing a new `Record`\n * with the entry updated, otherwise it returns `None`\n *\n * @example\n * import { modifyAt } from 'fp-ts/Record'\n * import { option } from 'fp-ts'\n *\n * assert.deepStrictEqual(modifyAt(\"a\", (x: number) => x * 3)({ a: 1, b: 2 }), option.some({ a: 3, b: 2 }));\n * assert.deepStrictEqual(modifyAt(\"c\", (x: number) => x * 3)({ a: 1, b: 2 }), option.none);\n *\n * @since 2.0.0\n */\nexport var modifyAt = function (k, f) {\n    return function (r) {\n        if (!has(k, r)) {\n            return _.none;\n        }\n        var out = Object.assign({}, r);\n        out[k] = f(r[k]);\n        return _.some(out);\n    };\n};\nexport function pop(k) {\n    var deleteAtk = deleteAt(k);\n    return function (r) {\n        var oa = lookup(k, r);\n        return _.isNone(oa) ? _.none : _.some([oa.value, deleteAtk(r)]);\n    };\n}\n// TODO: remove non-curried overloading in v3\n/**\n * Test whether one `Record` contains all of the keys and values\n * contained in another `Record`.\n *\n * @example\n * import { isSubrecord } from 'fp-ts/Record'\n * import { string } from 'fp-ts'\n *\n * assert.deepStrictEqual(\n *   isSubrecord(string.Eq)({ a: \"foo\", b: \"bar\", c: \"baz\" })({ a: \"foo\", b: \"bar\", c: \"baz\" }),\n *   true\n * );\n * assert.deepStrictEqual(\n *   isSubrecord(string.Eq)({ a: \"foo\", b: \"bar\", c: \"baz\" })({ a: \"foo\", c: \"baz\" }),\n *   true\n * );\n * assert.deepStrictEqual(\n *   isSubrecord(string.Eq)({ a: \"foo\", b: \"bar\", c: \"baz\" })({ a: \"foo\", b: \"not-bar\", c: \"baz\" }),\n *   false\n * );\n * assert.deepStrictEqual(\n *   isSubrecord(string.Eq)({ a: \"foo\", b: \"bar\" })({ a: \"foo\", b: \"bar\", c: \"baz\" }),\n *   false\n * );\n *\n * @since 2.0.0\n */\nexport var isSubrecord = RR.isSubrecord;\n// TODO: remove non-curried overloading in v3\n/**\n * Lookup the value for a key in a `Record`.\n *\n * @returns If the specified key exists it returns an `Option` containing the value,\n * otherwise it returns `None`\n *\n * @example\n * import { lookup } from 'fp-ts/Record'\n * import { option } from 'fp-ts'\n *\n * assert.deepStrictEqual(lookup(\"b\")({ a: \"foo\", b: \"bar\" }), option.some(\"bar\"));\n * assert.deepStrictEqual(lookup(\"c\")({ a: \"foo\", b: \"bar\" }), option.none);\n *\n * @since 2.0.0\n */\nexport var lookup = RR.lookup;\n/**\n * Map a `Record` passing the key/value pairs to the iterating function.\n *\n * @example\n * import { mapWithIndex } from \"fp-ts/Record\";\n *\n * const f = (k: string, n: number) => `${k.toUpperCase()}-${n}`;\n * assert.deepStrictEqual(mapWithIndex(f)({ a: 3, b: 5 }), { a: \"A-3\", b: \"B-5\" });\n *\n * @since 2.0.0\n */\nexport var mapWithIndex = RR.mapWithIndex;\n/**\n * Map a `Record` passing the values to the iterating function.\n *\n * @example\n * import { map } from \"fp-ts/Record\";\n *\n * const f = (n: number) => `-${n}-`;\n * assert.deepStrictEqual(map(f)({ a: 3, b: 5 }), { a: \"-3-\", b: \"-5-\" });\n *\n * @category mapping\n * @since 2.0.0\n */\nexport var map = RR.map;\nexport function reduceWithIndex() {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    return args.length === 1 ? RR.reduceWithIndex(args[0]) : RR.reduceWithIndex(S.Ord).apply(void 0, args);\n}\nexport function foldMapWithIndex(O) {\n    return 'compare' in O ? RR.foldMapWithIndex(O) : RR.foldMapWithIndex(S.Ord)(O);\n}\nexport function reduceRightWithIndex() {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    return args.length === 1 ? RR.reduceRightWithIndex(args[0]) : RR.reduceRightWithIndex(S.Ord).apply(void 0, args);\n}\n/**\n * Create a `Record` with one key/value pair.\n *\n * @example\n * import { singleton } from \"fp-ts/Record\";\n *\n * assert.deepStrictEqual(singleton(\"a\", 1), { a: 1 });\n *\n * @since 2.0.0\n */\nexport var singleton = RR.singleton;\nexport function traverseWithIndex(F) {\n    return RR.traverseWithIndex(F);\n}\nexport function traverse(F) {\n    return RR.traverse(F);\n}\nexport function sequence(F) {\n    return RR.sequence(F);\n}\n/**\n * @category filtering\n * @since 2.6.5\n */\nexport var wither = function (F) {\n    var traverseF = traverse(F);\n    return function (f) { return function (fa) { return F.map(pipe(fa, traverseF(f)), compact); }; };\n};\n/**\n * @category filtering\n * @since 2.6.5\n */\nexport var wilt = function (F) {\n    var traverseF = traverse(F);\n    return function (f) { return function (fa) { return F.map(pipe(fa, traverseF(f)), separate); }; };\n};\n/**\n * Maps a `Record` with a function returning an `Either` and\n * partitions the resulting `Record` into `Left`s and `Right`s.\n *\n * @example\n * import { partitionMapWithIndex } from \"fp-ts/Record\"\n * import { either } from \"fp-ts\"\n *\n * const f = (key: string, a: number) =>\n *   a >= 0 ? either.right(`${key} is >= 0 (${a})`) : either.left(`${key} is < 0 (${a})`);\n * assert.deepStrictEqual(partitionMapWithIndex(f)({ a: -1, b: 2, c: 123 }), {\n *   left: {\n *     a: \"a is < 0 (-1)\",\n *   },\n *   right: {\n *     b: \"b is >= 0 (2)\",\n *     c: \"c is >= 0 (123)\",\n *   },\n * });\n *\n * @since 2.0.0\n */\nexport var partitionMapWithIndex = RR.partitionMapWithIndex;\nexport function partitionWithIndex(predicateWithIndex) {\n    return RR.partitionWithIndex(predicateWithIndex);\n}\n/**\n * Maps a `Record` with an iterating function that takes key and value and\n * returns an `Option`, keeping only the `Some` values and discarding `None`s.\n *\n * @example\n * import { filterMapWithIndex } from \"fp-ts/Record\"\n * import { option } from \"fp-ts\"\n *\n * const f = (key: string, a: number) => (a >= 0 ? option.some(`${key}${a}`) : option.none);\n * assert.deepStrictEqual(filterMapWithIndex(f)({ a: -1, b: 2, c: 3 }), {\n *   b: \"b2\",\n *   c: \"c3\",\n * });\n *\n * @since 2.0.0\n */\nexport var filterMapWithIndex = RR.filterMapWithIndex;\nexport function filterWithIndex(predicateWithIndex) {\n    return RR.filterWithIndex(predicateWithIndex);\n}\nexport function fromFoldable(M, F) {\n    return RR.fromFoldable(M, F);\n}\n/**\n * Alias of [`toArray`](#toArray).\n *\n * @example\n * import { toEntries } from 'fp-ts/Record'\n *\n * assert.deepStrictEqual(toEntries({ b: 2, a: 1 }), [['a', 1], ['b', 2]])\n *\n * @since 2.12.0\n * @category conversions\n */\nexport var toEntries = toArray;\n/**\n * Converts an `Array` of `[key, value]` tuples into a `Record`.\n *\n * @example\n * import { fromEntries } from 'fp-ts/Record'\n *\n * assert.deepStrictEqual(fromEntries([['a', 1], ['b', 2], ['a', 3]]), { b: 2, a: 3 })\n *\n * @since 2.12.0\n * @category conversions\n */\nexport var fromEntries = function (fa) { return fromFoldable(Se.last(), A.Foldable)(fa); };\nexport function fromFoldableMap(M, F) {\n    return RR.fromFoldableMap(M, F);\n}\n/**\n * Test if every value in a `Record` satisfies the predicate.\n *\n * @example\n * import { every } from \"fp-ts/Record\"\n *\n * assert.deepStrictEqual(every((n: number) => n >= 0)({ a: 1, b: 2 }), true);\n * assert.deepStrictEqual(every((n: number) => n >= 0)({ a: 1, b: -1 }), false);\n *\n * @since 2.0.0\n */\nexport var every = RR.every;\n/**\n * Test if at least one value in a `Record` satisfies the predicate.\n *\n * @example\n * import { some } from \"fp-ts/Record\"\n *\n * assert.deepStrictEqual(some((n: number) => n >= 0)({ a: 1, b: -2 }), true);\n * assert.deepStrictEqual(some((n: number) => n >= 0)({ a: -1, b: -2 }), false);\n *\n * @since 2.0.0\n */\nexport var some = RR.some;\n// TODO: remove non-curried overloading in v3\n/**\n * Given an `Eq` checks if a `Record` contains an entry with\n * value equal to a provided value.\n *\n * @example\n * import { elem } from \"fp-ts/Record\"\n * import { number } from \"fp-ts\"\n *\n * assert.deepStrictEqual(elem(number.Eq)(123, { foo: 123, bar: 234 }), true);\n * assert.deepStrictEqual(elem(number.Eq)(-7, { foo: 123, bar: 234 }), false);\n *\n * @since 2.0.0\n */\nexport var elem = RR.elem;\n/**\n * Union of two `Record`s.\n * Takes two `Record`s and produces a `Record` combining all the\n * entries of the two inputs.\n * It uses the `concat` function of the provided `Magma` to\n * combine the elements with the same key.\n *\n * @example\n * import { union } from \"fp-ts/Record\";\n * import { Magma } from \"fp-ts/Magma\";\n *\n * const m1: Magma<number> = { concat: (x: number, y: number) => x + y };\n * assert.deepStrictEqual(union(m1)({ a: 3, c: 3 })({ a: 1, b: 2 }), { a: 4, b: 2, c: 3 });\n * const m2: Magma<number> = { concat: (x: number) => x };\n * assert.deepStrictEqual(union(m2)({ a: 3, c: 3 })({ a: 1, b: 2 }), { a: 1, b: 2, c: 3 });\n *\n * @since 2.11.0\n */\nexport var union = function (M) {\n    var unionM = RR.union(M);\n    return function (second) { return function (first) {\n        if (isEmpty(first)) {\n            return __assign({}, second);\n        }\n        if (isEmpty(second)) {\n            return __assign({}, first);\n        }\n        return unionM(second)(first);\n    }; };\n};\n/**\n * Intersection of two `Record`s.\n * Takes two `Record`s and produces a `Record` combining only the\n * entries of the two inputswith the same key.\n * It uses the `concat` function of the provided `Magma` to\n * combine the elements.\n *\n * @example\n * import { intersection } from \"fp-ts/Record\";\n * import { Magma } from \"fp-ts/Magma\";\n *\n * const m1: Magma<number> = { concat: (x: number, y: number) => x + y };\n * assert.deepStrictEqual(intersection(m1)({ a: 3, c: 3 })({ a: 1, b: 2 }), { a: 4});\n * const m2: Magma<number> = { concat: (x: number) => x };\n * assert.deepStrictEqual(intersection(m2)({ a: 3, c: 3 })({ a: 1, b: 2 }), { a: 1});\n *\n * @since 2.11.0\n */\nexport var intersection = function (M) {\n    return function (second) {\n        return function (first) {\n            if (isEmpty(first) || isEmpty(second)) {\n                return {};\n            }\n            return RR.intersection(M)(second)(first);\n        };\n    };\n};\n/**\n * Difference between two `Record`s.\n * Takes two `Record`s and produces a `Record` composed by the\n * entries of the two inputs, removing the entries with the same\n * key in both inputs.\n *\n * @example\n * import { difference } from \"fp-ts/Record\";\n *\n * assert.deepStrictEqual(difference({ a: 1 })({ a: 1, b: 2 }), { b: 2 });\n * assert.deepStrictEqual(difference({ a: 3 })({ a: 1, b: 2 }), { b: 2 });\n * assert.deepStrictEqual(difference({ a: 3, c: 3 })({ a: 1, b: 2 }), { b: 2, c: 3 });\n *\n * @since 2.11.0\n */\nexport var difference = function (second) {\n    return function (first) {\n        if (isEmpty(first)) {\n            return __assign({}, second);\n        }\n        if (isEmpty(second)) {\n            return __assign({}, first);\n        }\n        return RR.difference(second)(first);\n    };\n};\nvar _map = RR._map;\nvar _mapWithIndex = RR._mapWithIndex;\nvar _reduce = RR._reduce;\nvar _foldMap = RR._foldMap;\nvar _reduceRight = RR._reduceRight;\nvar _filter = RR._filter;\nvar _filterMap = RR._filterMap;\nvar _partition = RR._partition;\nvar _partitionMap = RR._partitionMap;\nvar _reduceWithIndex = RR._reduceWithIndex;\nvar _foldMapWithIndex = RR._foldMapWithIndex;\nvar _reduceRightWithIndex = RR._reduceRightWithIndex;\nvar _partitionMapWithIndex = RR._partitionMapWithIndex;\nvar _partitionWithIndex = RR._partitionWithIndex;\nvar _filterMapWithIndex = RR._filterMapWithIndex;\nvar _filterWithIndex = RR._filterWithIndex;\nvar _traverse = RR._traverse;\nvar _sequence = RR._sequence;\nvar _traverseWithIndex = function (O) {\n    return function (F) {\n        var keysO = keys_(O);\n        return function (ta, f) {\n            var ks = keysO(ta);\n            if (ks.length === 0) {\n                return F.of({});\n            }\n            var fr = F.of({});\n            var _loop_1 = function (key) {\n                fr = F.ap(F.map(fr, function (r) { return function (b) {\n                    r[key] = b;\n                    return r;\n                }; }), f(key, ta[key]));\n            };\n            for (var _i = 0, ks_1 = ks; _i < ks_1.length; _i++) {\n                var key = ks_1[_i];\n                _loop_1(key);\n            }\n            return fr;\n        };\n    };\n};\n/**\n * Given a `Predicate`, it produces a new `Record` keeping only the entries with a\n * value that satisfies the provided predicate.\n *\n * @example\n * import { filter } from \"fp-ts/Record\"\n *\n * assert.deepStrictEqual(filter((s: string) => s.length < 4)({ a: \"foo\", b: \"bar\", c: \"verylong\" }), {\n *   a: \"foo\",\n *   b: \"bar\",\n * });\n *\n * @category filtering\n * @since 2.0.0\n */\nexport var filter = RR.filter;\n/**\n * Maps a `Record` with an iterating function that returns an `Option`\n * and it keeps only the `Some` values discarding the `None`s.\n *\n * @example\n * import { filterMap } from \"fp-ts/Record\"\n * import { option } from \"fp-ts\"\n *\n * const f = (s: string) => s.length < 4 ? option.some(`${s} is short`): option.none\n * assert.deepStrictEqual(filterMap(f)({ a: \"foo\", b: \"bar\", c: \"verylong\" }), {\n *   a: \"foo is short\",\n *   b: \"bar is short\",\n * });\n *\n * @category filtering\n * @since 2.0.0\n */\nexport var filterMap = RR.filterMap;\n/**\n * Partition a `Record` into two parts according to a `Predicate`.\n *\n * @example\n * import { partition } from \"fp-ts/Record\"\n *\n * assert.deepStrictEqual(partition((s: string) => s.length < 4)({ a: \"foo\", b: \"bar\", c: \"verylong\" }), {\n *   left:{\n *     c: \"verylong\"\n *   },\n *   right: {\n *     a: \"foo\",\n *     b: \"bar\",\n *   },\n * });\n *\n * @category filtering\n * @since 2.0.0\n */\nexport var partition = RR.partition;\n/**\n * Maps a `Record` with a function returning an `Either` and\n * partitions the resulting `Record` into `Left`s and `Right`s.\n *\n * @example\n * import { partitionMap } from \"fp-ts/Record\"\n * import { either } from \"fp-ts\"\n *\n * const f = (s: string) => (s.length < 4 ? either.right(`${s} is short`) : either.left(`${s} is not short`));\n * assert.deepStrictEqual(partitionMap(f)({ a: \"foo\", b: \"bar\", c: \"verylong\" }), {\n *   left: {\n *     c: \"verylong is not short\",\n *   },\n *   right: {\n *     a: \"foo is short\",\n *     b: \"bar is short\",\n *   },\n * });\n *\n * @category filtering\n * @since 2.0.0\n */\nexport var partitionMap = RR.partitionMap;\nexport function reduce() {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    return args.length === 1 ? RR.reduce(args[0]) : RR.reduce(S.Ord).apply(void 0, args);\n}\nexport function foldMap(O) {\n    return 'compare' in O ? RR.foldMap(O) : RR.foldMap(S.Ord)(O);\n}\nexport function reduceRight() {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    return args.length === 1 ? RR.reduceRight(args[0]) : RR.reduceRight(S.Ord).apply(void 0, args);\n}\n/**\n * Compact a `Record` of `Option`s discarding the `None` values and\n * keeping the `Some` values.\n *\n * @example\n * import { compact } from 'fp-ts/Record'\n * import { option } from 'fp-ts'\n *\n * assert.deepStrictEqual(compact({ a: option.some(\"foo\"), b: option.none, c: option.some(\"bar\") }), {\n *   a: \"foo\",\n *   c: \"bar\",\n * });\n *\n * @category filtering\n * @since 2.0.0\n */\nexport var compact = RR.compact;\n/**\n * Separate a `Record` of `Either`s into `Left`s and `Right`s.\n *\n * @example\n * import { separate } from 'fp-ts/Record'\n * import { either } from 'fp-ts'\n *\n * assert.deepStrictEqual(\n *   separate({ a: either.right(\"foo\"), b: either.left(\"bar\"), c: either.right(\"baz\") }),\n *   {\n *     right: {\n *       a: \"foo\",\n *       c: \"baz\",\n *     },\n *     left: {\n *       b: \"bar\",\n *     },\n *   }\n * );\n *\n * @category filtering\n * @since 2.0.0\n */\nexport var separate = RR.separate;\n/**\n * @category type lambdas\n * @since 2.0.0\n */\nexport var URI = 'Record';\nexport function getShow(O) {\n    return 'compare' in O ? RR.getShow(O) : RR.getShow(S.Ord)(O);\n}\n/**\n * Given an `Eq` for the base type, it produces an `Eq`\n * for a `Record` of that base type.\n *\n * @example\n * import { getEq } from \"fp-ts/Record\";\n * import { string } from \"fp-ts\";\n * import { Eq } from \"fp-ts/Eq\";\n *\n * const eq: Eq<Record<string, string>> = getEq(string.Eq);\n * assert.deepStrictEqual(eq.equals({ a: \"foo\" }, { b: \"bar\" }), false);\n * assert.deepStrictEqual(eq.equals({ a: \"foo\" }, { a: \"foo\" }), true);\n *\n * @category instances\n * @since 2.0.0\n */\nexport var getEq = RR.getEq;\n/**\n * Returns a `Monoid` instance for `Record`s, given a `Semigroup`\n * instance for the base type.\n * The `Monoid` makes the union of two `Record`s comining the\n * overlapping entries with the provided `Semigroup`.\n *\n * @example\n * import { SemigroupSum } from 'fp-ts/number'\n * import { getMonoid } from 'fp-ts/Record'\n *\n * const M = getMonoid(SemigroupSum);\n * assert.deepStrictEqual(M.concat({ foo: 123, bar: 234 }, { foo: 456, baz: 567 }), { foo: 579 , bar: 234, baz: 567 });\n *\n * @category instances\n * @since 2.0.0\n */\nexport var getMonoid = RR.getMonoid;\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Functor = {\n    URI: URI,\n    map: _map\n};\n/**\n * Takes a value and a `Record` of functions and returns a\n * `Record` by applying each function to the input value.\n *\n * @example\n * import { flap } from \"fp-ts/Record\"\n *\n * const fab = { x: (n: number) => `${n} times 2`, y: (n: number) => `${n * 2}` };\n * assert.deepStrictEqual(flap(3)(fab), {\n *   x: \"3 times 2\",\n *   y: \"6\",\n * });\n *\n * @category mapping\n * @since 2.10.0\n */\nexport var flap = /*#__PURE__*/ flap_(Functor);\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FunctorWithIndex = {\n    URI: URI,\n    map: _map,\n    mapWithIndex: _mapWithIndex\n};\n/**\n * Produces a `Foldable` instance for a `Record`, using the\n * provided `Ord` to sort the `Record`'s entries by key.\n *\n * @category folding\n * @since 2.11.0\n */\nexport var getFoldable = function (O) { return ({\n    URI: URI,\n    reduce: _reduce(O),\n    foldMap: _foldMap(O),\n    reduceRight: _reduceRight(O)\n}); };\n/**\n * Produces a `FoldableWithIndex1` instance for a `Record`, using the\n * provided `Ord` to sort the `Record`'s entries by key.\n *\n * @category folding\n * @since 2.11.0\n */\nexport var getFoldableWithIndex = function (O) { return ({\n    URI: URI,\n    reduce: _reduce(O),\n    foldMap: _foldMap(O),\n    reduceRight: _reduceRight(O),\n    reduceWithIndex: _reduceWithIndex(O),\n    foldMapWithIndex: _foldMapWithIndex(O),\n    reduceRightWithIndex: _reduceRightWithIndex(O)\n}); };\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Compactable = {\n    URI: URI,\n    compact: compact,\n    separate: separate\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Filterable = {\n    URI: URI,\n    map: _map,\n    compact: compact,\n    separate: separate,\n    filter: _filter,\n    filterMap: _filterMap,\n    partition: _partition,\n    partitionMap: _partitionMap\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FilterableWithIndex = {\n    URI: URI,\n    map: _map,\n    mapWithIndex: _mapWithIndex,\n    compact: compact,\n    separate: separate,\n    filter: _filter,\n    filterMap: _filterMap,\n    partition: _partition,\n    partitionMap: _partitionMap,\n    filterMapWithIndex: _filterMapWithIndex,\n    filterWithIndex: _filterWithIndex,\n    partitionMapWithIndex: _partitionMapWithIndex,\n    partitionWithIndex: _partitionWithIndex\n};\n/**\n * Produces a `Traversable` instance for a `Record`, using the\n * provided `Ord` to sort the `Record`'s entries by key.\n *\n * @category traversing\n * @since 2.11.0\n */\nexport var getTraversable = function (O) { return ({\n    URI: URI,\n    map: _map,\n    reduce: _reduce(O),\n    foldMap: _foldMap(O),\n    reduceRight: _reduceRight(O),\n    traverse: _traverse(O),\n    sequence: _sequence(O)\n}); };\n/**\n * Produces a `TraversableWithIndex` instance for a `Record`, using the\n * provided `Ord` to sort the `Record`'s entries by key.\n *\n * @category traversing\n * @since 2.11.0\n */\nexport var getTraversableWithIndex = function (O) { return ({\n    URI: URI,\n    map: _map,\n    mapWithIndex: _mapWithIndex,\n    reduce: _reduce(O),\n    foldMap: _foldMap(O),\n    reduceRight: _reduceRight(O),\n    reduceWithIndex: _reduceWithIndex(O),\n    foldMapWithIndex: _foldMapWithIndex(O),\n    reduceRightWithIndex: _reduceRightWithIndex(O),\n    traverse: _traverse(O),\n    sequence: _sequence(O),\n    traverseWithIndex: _traverseWithIndex(O)\n}); };\n/**\n * @category filtering\n * @since 2.11.0\n */\nexport var getWitherable = function (O) {\n    var T = getTraversable(O);\n    return {\n        URI: URI,\n        map: _map,\n        reduce: _reduce(O),\n        foldMap: _foldMap(O),\n        reduceRight: _reduceRight(O),\n        traverse: T.traverse,\n        sequence: T.sequence,\n        compact: compact,\n        separate: separate,\n        filter: _filter,\n        filterMap: _filterMap,\n        partition: _partition,\n        partitionMap: _partitionMap,\n        wither: witherDefault(T, Compactable),\n        wilt: wiltDefault(T, Compactable)\n    };\n};\n/**\n * Given a `Semigroup` in the base type, it produces a `Semigroup`\n * in the `Record` of the base type.\n * The resulting `Semigroup` concatenates two `Record`s by\n * `union`.\n *\n * @example\n * import { getUnionSemigroup } from \"fp-ts/Record\"\n * import { Semigroup } from \"fp-ts/Semigroup\"\n *\n * const sNumber: Semigroup<number> = { concat: (x, y) => x - y };\n * const sRecord: Semigroup<Record<string, number>> = getUnionSemigroup(sNumber);\n * assert.deepStrictEqual(sRecord.concat({ a: 1, b: 2 }, { b: 3, c: 4 }), { a: 1, b: -1, c: 4 });\n *\n * @category instances\n * @since 2.11.0\n */\nexport var getUnionSemigroup = function (S) {\n    var unionS = union(S);\n    return {\n        concat: function (first, second) { return unionS(second)(first); }\n    };\n};\n/**\n * Same as `getMonoid`.\n * Returns a `Monoid` instance for `Record`s given a `Semigroup`\n * instance for the base type.\n * The `Monoid` makes the union of two `Record`s combining the\n * entries that have the same key with the provided `Semigroup`.\n *\n * @example\n * import { SemigroupSum } from 'fp-ts/number'\n * import { getUnionMonoid } from 'fp-ts/Record'\n *\n * const M = getUnionMonoid(SemigroupSum);\n * assert.deepStrictEqual(M.concat({ foo: 123, bar: 234 }, { foo: 456, baz: 567 }), { foo: 579 , bar: 234, baz: 567 });\n *\n * @category instances\n * @since 2.11.0\n */\nexport var getUnionMonoid = function (S) { return ({\n    concat: getUnionSemigroup(S).concat,\n    empty: {}\n}); };\n/**\n * Given a `Semigroup` in the base type, it produces a `Semigroup`\n * in the `Record` of the base type.\n * The resulting `Semigroup` concatenates two `Record`s by\n * `intersection`.\n *\n * @example\n * import { getIntersectionSemigroup } from \"fp-ts/Record\"\n * import { Semigroup } from \"fp-ts/Semigroup\"\n *\n * const sNumber: Semigroup<number> = { concat: (x, y) => x - y };\n * const sRecord: Semigroup<Record<string, number>> = getIntersectionSemigroup(sNumber);\n * assert.deepStrictEqual(sRecord.concat({ a: 1, b: 2 }, { b: 3, c: 4 }), { b: -1 });\n *\n * @category instances\n * @since 2.11.0\n */\nexport var getIntersectionSemigroup = function (S) {\n    var intersectionS = intersection(S);\n    return {\n        concat: function (first, second) { return intersectionS(second)(first); }\n    };\n};\n/**\n * Produces a `Magma` with a `concat` function that combines\n * two `Record`s by making the `difference`.\n *\n * @example\n * import { getDifferenceMagma, difference } from \"fp-ts/Record\"\n * import { Magma } from \"fp-ts/Magma\"\n *\n * const r1 = { a: 3, c: 3 };\n * const r2 = { a: 1, b: 2 };\n * const m: Magma<Record<string, number>> = getDifferenceMagma<number>();\n * assert.deepStrictEqual(m.concat(r1, r2), difference(r2)(r1));\n * assert.deepStrictEqual(m.concat(r1, r2), { c: 3, b: 2 });\n *\n * @category instances\n * @since 2.11.0\n */\nexport var getDifferenceMagma = function () { return ({\n    concat: function (first, second) { return difference(second)(first); }\n}); };\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * Use `getFoldable` instead.\n *\n * @category zone of death\n * @since 2.7.0\n * @deprecated\n */\nexport var Foldable = {\n    URI: URI,\n    reduce: /*#__PURE__*/ _reduce(S.Ord),\n    foldMap: /*#__PURE__*/ _foldMap(S.Ord),\n    reduceRight: /*#__PURE__*/ _reduceRight(S.Ord)\n};\n/**\n * Use `getFoldableWithIndex` instead.\n *\n * @category zone of death\n * @since 2.7.0\n * @deprecated\n */\nexport var FoldableWithIndex = {\n    URI: URI,\n    reduce: /*#__PURE__*/ _reduce(S.Ord),\n    foldMap: /*#__PURE__*/ _foldMap(S.Ord),\n    reduceRight: /*#__PURE__*/ _reduceRight(S.Ord),\n    reduceWithIndex: /*#__PURE__*/ _reduceWithIndex(S.Ord),\n    foldMapWithIndex: /*#__PURE__*/ _foldMapWithIndex(S.Ord),\n    reduceRightWithIndex: /*#__PURE__*/ _reduceRightWithIndex(S.Ord)\n};\n/**\n * Use `getTraversable` instead.\n *\n * @category zone of death\n * @since 2.7.0\n * @deprecated\n */\nexport var Traversable = {\n    URI: URI,\n    map: _map,\n    reduce: /*#__PURE__*/ _reduce(S.Ord),\n    foldMap: /*#__PURE__*/ _foldMap(S.Ord),\n    reduceRight: /*#__PURE__*/ _reduceRight(S.Ord),\n    traverse: /*#__PURE__*/ _traverse(S.Ord),\n    sequence: sequence\n};\n/**\n * Use the `getTraversableWithIndex` instead.\n *\n * @category zone of death\n * @since 2.7.0\n * @deprecated\n */\nexport var TraversableWithIndex = {\n    URI: URI,\n    map: _map,\n    mapWithIndex: _mapWithIndex,\n    reduce: /*#__PURE__*/ _reduce(S.Ord),\n    foldMap: /*#__PURE__*/ _foldMap(S.Ord),\n    reduceRight: /*#__PURE__*/ _reduceRight(S.Ord),\n    reduceWithIndex: /*#__PURE__*/ _reduceWithIndex(S.Ord),\n    foldMapWithIndex: /*#__PURE__*/ _foldMapWithIndex(S.Ord),\n    reduceRightWithIndex: /*#__PURE__*/ _reduceRightWithIndex(S.Ord),\n    traverse: /*#__PURE__*/ _traverse(S.Ord),\n    sequence: sequence,\n    traverseWithIndex: /*#__PURE__*/ _traverseWithIndex(S.Ord)\n};\nvar _wither = /*#__PURE__*/ witherDefault(Traversable, Compactable);\nvar _wilt = /*#__PURE__*/ wiltDefault(Traversable, Compactable);\n/**\n * Use `getWitherable` instead.\n *\n * @category zone of death\n * @since 2.7.0\n * @deprecated\n */\nexport var Witherable = {\n    URI: URI,\n    map: _map,\n    reduce: /*#__PURE__*/ _reduce(S.Ord),\n    foldMap: /*#__PURE__*/ _foldMap(S.Ord),\n    reduceRight: /*#__PURE__*/ _reduceRight(S.Ord),\n    traverse: /*#__PURE__*/ _traverse(S.Ord),\n    sequence: sequence,\n    compact: compact,\n    separate: separate,\n    filter: _filter,\n    filterMap: _filterMap,\n    partition: _partition,\n    partitionMap: _partitionMap,\n    wither: _wither,\n    wilt: _wilt\n};\n/**\n * Use a new `{}` instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var empty = {};\n/**\n * Use [`upsertAt`](#upsertat) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var insertAt = upsertAt;\n/**\n * Use [`has`](#has) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var hasOwnProperty = RR.hasOwnProperty;\n/**\n * This instance is deprecated, use small, specific instances instead.\n * For example if a function needs a `Functor` instance, pass `R.Functor` instead of `R.record`\n * (where `R` is from `import R from 'fp-ts/Record'`)\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var record = {\n    URI: URI,\n    map: _map,\n    reduce: /*#__PURE__*/ _reduce(S.Ord),\n    foldMap: /*#__PURE__*/ _foldMap(S.Ord),\n    reduceRight: /*#__PURE__*/ _reduceRight(S.Ord),\n    traverse: /*#__PURE__*/ _traverse(S.Ord),\n    sequence: sequence,\n    compact: compact,\n    separate: separate,\n    filter: _filter,\n    filterMap: _filterMap,\n    partition: _partition,\n    partitionMap: _partitionMap,\n    mapWithIndex: _mapWithIndex,\n    reduceWithIndex: /*#__PURE__*/ _reduceWithIndex(S.Ord),\n    foldMapWithIndex: /*#__PURE__*/ _foldMapWithIndex(S.Ord),\n    reduceRightWithIndex: /*#__PURE__*/ _reduceRightWithIndex(S.Ord),\n    filterMapWithIndex: _filterMapWithIndex,\n    filterWithIndex: _filterWithIndex,\n    partitionMapWithIndex: _partitionMapWithIndex,\n    partitionWithIndex: _partitionWithIndex,\n    traverseWithIndex: /*#__PURE__*/ _traverseWithIndex(S.Ord),\n    wither: _wither,\n    wilt: _wilt\n};\n"],"names":["this","RR.size","RR.isEmpty","S.Ord","_.some","_.none","RR.upsertAt","RR.has","_.has","_.isNone","RR.isSubrecord","RR.lookup","RR.mapWithIndex","RR.map","RR.reduceWithIndex","RR.foldMapWithIndex","RR.reduceRightWithIndex","RR.singleton","RR.traverseWithIndex","RR.traverse","RR.sequence","RR.partitionMapWithIndex","RR.partitionWithIndex","RR.filterMapWithIndex","RR.filterWithIndex","RR.fromFoldable","Se.last","A.Foldable","RR.fromFoldableMap","RR.every","RR.some","RR.elem","RR.union","RR.intersection","RR.difference","RR._map","RR._mapWithIndex","RR._reduce","RR._foldMap","RR._reduceRight","RR._filter","RR._filterMap","RR._partition","RR._partitionMap","RR._reduceWithIndex","RR._foldMapWithIndex","RR._reduceRightWithIndex","RR._partitionMapWithIndex","RR._partitionWithIndex","RR._filterMapWithIndex","RR._filterWithIndex","RR._traverse","RR._sequence","key","RR.filter","RR.filterMap","RR.partition","RR.partitionMap","RR.reduce","RR.foldMap","RR.reduceRight","RR.compact","RR.separate","RR.getShow","RR.getEq","RR.getMonoid","flap_","RR.hasOwnProperty"],"mappings":"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","x_google_ignoreList":[0]}