import {
  separated
} from "./chunk-RAKKSTP2.mjs";
import {
  wiltDefault,
  witherDefault
} from "./chunk-DQQFH64X.mjs";
import {
  Ord
} from "./chunk-F7QG6CT5.mjs";
import {
  flap
} from "./chunk-WKK6AYQI.mjs";
import {
  fromEquals
} from "./chunk-YQKF55QL.mjs";
import {
  has,
  isLeft,
  isNone,
  isSome,
  none,
  some
} from "./chunk-WPJQNT3M.mjs";
import {
  SK,
  flow,
  identity,
  pipe
} from "./chunk-ZI34HWXZ.mjs";
import {
  __export
} from "./chunk-QK4PKNB3.mjs";

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