"use strict";Object.defineProperty(exports, "__esModule", {value: true});

var _chunkS2Z5L3RBjs = require('./chunk-S2Z5L3RB.js');


var _chunkT4ZJ6CA2js = require('./chunk-T4ZJ6CA2.js');



var _chunkUNAIGMDHjs = require('./chunk-UNAIGMDH.js');


var _chunk7K74W2G3js = require('./chunk-7K74W2G3.js');


var _chunkTGVEPLW2js = require('./chunk-TGVEPLW2.js');






var _chunkOTKMOSH2js = require('./chunk-OTKMOSH2.js');



var _chunkSQA7G4TEjs = require('./chunk-SQA7G4TE.js');


var _chunk6C3VEZWHjs = require('./chunk-6C3VEZWH.js');

// src/ReadonlyMap.ts
var ReadonlyMap_exports = {};
_chunk6C3VEZWHjs.__export.call(void 0, ReadonlyMap_exports, {
  Compactable: () => Compactable,
  Filterable: () => Filterable,
  Functor: () => Functor,
  URI: () => URI,
  collect: () => collect,
  compact: () => compact,
  deleteAt: () => deleteAt,
  difference: () => difference,
  elem: () => elem,
  empty: () => empty,
  filter: () => filter,
  filterMap: () => filterMap,
  filterMapWithIndex: () => filterMapWithIndex,
  filterWithIndex: () => filterWithIndex,
  flap: () => flap2,
  foldMap: () => foldMap,
  foldMapWithIndex: () => foldMapWithIndex,
  fromFoldable: () => fromFoldable,
  fromMap: () => fromMap,
  getDifferenceMagma: () => getDifferenceMagma,
  getEq: () => getEq,
  getFilterableWithIndex: () => getFilterableWithIndex,
  getFoldable: () => getFoldable,
  getFoldableWithIndex: () => getFoldableWithIndex,
  getFunctorWithIndex: () => getFunctorWithIndex,
  getIntersectionSemigroup: () => getIntersectionSemigroup,
  getMonoid: () => getMonoid,
  getShow: () => getShow,
  getTraversable: () => getTraversable,
  getTraversableWithIndex: () => getTraversableWithIndex,
  getUnionMonoid: () => getUnionMonoid,
  getUnionSemigroup: () => getUnionSemigroup,
  getWitherable: () => getWitherable,
  insertAt: () => insertAt,
  intersection: () => intersection,
  isEmpty: () => isEmpty,
  isSubmap: () => isSubmap,
  keys: () => keys,
  lookup: () => lookup,
  lookupWithKey: () => lookupWithKey,
  map: () => map2,
  mapWithIndex: () => mapWithIndex,
  member: () => member,
  modifyAt: () => modifyAt,
  partition: () => partition,
  partitionMap: () => partitionMap,
  partitionMapWithIndex: () => partitionMapWithIndex,
  partitionWithIndex: () => partitionWithIndex,
  pop: () => pop,
  readonlyMap: () => readonlyMap,
  reduce: () => reduce,
  reduceRight: () => reduceRight,
  reduceRightWithIndex: () => reduceRightWithIndex,
  reduceWithIndex: () => reduceWithIndex,
  separate: () => separate,
  singleton: () => singleton,
  size: () => size,
  toMap: () => toMap,
  toReadonlyArray: () => toReadonlyArray,
  toUnfoldable: () => toUnfoldable,
  union: () => union,
  updateAt: () => updateAt,
  upsertAt: () => upsertAt,
  values: () => values
});
var fromMap = (m) => new Map(m);
function toMap(m) {
  return new Map(m);
}
function getShow(SK2, SA) {
  return {
    show: (m) => {
      const entries = [];
      m.forEach((a, k) => {
        entries.push(`[${SK2.show(k)}, ${SA.show(a)}]`);
      });
      return `new Map([${entries.sort().join(", ")}])`;
    }
  };
}
var size = (m) => m.size;
var isEmpty = (m) => m.size === 0;
function member(E) {
  const lookupE = lookup(E);
  return (k, m) => {
    if (m === void 0) {
      const memberE = member(E);
      return (m2) => memberE(k, m2);
    }
    return _chunkOTKMOSH2js.isSome.call(void 0, lookupE(k, m));
  };
}
function elem(E) {
  return (a, m) => {
    if (m === void 0) {
      const elemE = elem(E);
      return (m2) => elemE(a, m2);
    }
    const values2 = m.values();
    let e;
    while (!(e = values2.next()).done) {
      const v = e.value;
      if (E.equals(a, v)) {
        return true;
      }
    }
    return false;
  };
}
var keys = (O) => (m) => Array.from(m.keys()).sort(O.compare);
var values = (O) => (m) => Array.from(m.values()).sort(O.compare);
function collect(O) {
  const keysO = keys(O);
  return (f) => (m) => {
    const out = [];
    const ks = keysO(m);
    for (const key of ks) {
      out.push(f(key, m.get(key)));
    }
    return out;
  };
}
var toReadonlyArray = (O) => collect(O)((k, a) => [k, a]);
function toUnfoldable(ord, U) {
  const toReadonlyArrayO = toReadonlyArray(ord);
  return (d) => {
    const kas = toReadonlyArrayO(d);
    const len = kas.length;
    return U.unfold(0, (b) => b < len ? _chunkOTKMOSH2js.some.call(void 0, [kas[b], b + 1]) : _chunkOTKMOSH2js.none);
  };
}
var upsertAt = (E) => {
  const lookupWithKeyE = lookupWithKey(E);
  return (k, a) => {
    const lookupWithKeyEk = lookupWithKeyE(k);
    return (m) => {
      const found = lookupWithKeyEk(m);
      if (_chunkOTKMOSH2js.isNone.call(void 0, found)) {
        const out = new Map(m);
        out.set(k, a);
        return out;
      } else if (found.value[1] !== a) {
        const out = new Map(m);
        out.set(found.value[0], a);
        return out;
      }
      return m;
    };
  };
};
var deleteAt = (E) => {
  const lookupWithKeyE = lookupWithKey(E);
  return (k) => (m) => {
    const found = lookupWithKeyE(k, m);
    if (_chunkOTKMOSH2js.isSome.call(void 0, found)) {
      const r = new Map(m);
      r.delete(found.value[0]);
      return r;
    }
    return m;
  };
};
var updateAt = (E) => {
  const modifyAtE = modifyAt(E);
  return (k, a) => modifyAtE(k, () => a);
};
var modifyAt = (E) => {
  const lookupWithKeyE = lookupWithKey(E);
  return (k, f) => (m) => {
    const found = lookupWithKeyE(k, m);
    if (_chunkOTKMOSH2js.isNone.call(void 0, found)) {
      return _chunkOTKMOSH2js.none;
    }
    const [fk, fv] = found.value;
    const next = f(fv);
    if (next === fv) {
      return _chunkOTKMOSH2js.some.call(void 0, m);
    }
    const r = new Map(m);
    r.set(fk, next);
    return _chunkOTKMOSH2js.some.call(void 0, r);
  };
};
function pop(E) {
  const lookupE = lookup(E);
  const deleteAtE = deleteAt(E);
  return (k) => {
    const deleteAtEk = deleteAtE(k);
    return (m) => _chunkSQA7G4TEjs.pipe.call(void 0, 
      lookupE(k, m),
      _chunkS2Z5L3RBjs.map2.call(void 0, (a) => [a, deleteAtEk(m)])
    );
  };
}
function lookupWithKey(E) {
  return (k, m) => {
    if (m === void 0) {
      const lookupWithKeyE = lookupWithKey(E);
      return (m2) => lookupWithKeyE(k, m2);
    }
    const entries = m.entries();
    let e;
    while (!(e = entries.next()).done) {
      const [ka, a] = e.value;
      if (E.equals(ka, k)) {
        return _chunkOTKMOSH2js.some.call(void 0, [ka, a]);
      }
    }
    return _chunkOTKMOSH2js.none;
  };
}
function lookup(E) {
  const lookupWithKeyE = lookupWithKey(E);
  return (k, m) => {
    if (m === void 0) {
      const lookupE = lookup(E);
      return (m2) => lookupE(k, m2);
    }
    return _chunkSQA7G4TEjs.pipe.call(void 0, 
      lookupWithKeyE(k, m),
      _chunkS2Z5L3RBjs.map2.call(void 0, ([_, a]) => a)
    );
  };
}
function isSubmap(SK2, SA) {
  const lookupWithKeyS = lookupWithKey(SK2);
  return (me, that) => {
    if (that === void 0) {
      const isSubmapSKSA = isSubmap(SK2, SA);
      return (that2) => isSubmapSKSA(that2, me);
    }
    const entries = me.entries();
    let e;
    while (!(e = entries.next()).done) {
      const [k, a] = e.value;
      const d2OptA = lookupWithKeyS(k, that);
      if (_chunkOTKMOSH2js.isNone.call(void 0, d2OptA) || !SK2.equals(k, d2OptA.value[0]) || !SA.equals(a, d2OptA.value[1])) {
        return false;
      }
    }
    return true;
  };
}
var empty = (
  // the type annotation here is intended (otherwise it doesn't type-check)
  /* @__PURE__ */ new Map()
);
function getEq(SK2, SA) {
  const isSubmapSKSA = isSubmap(SK2, SA);
  return _chunkTGVEPLW2js.fromEquals.call(void 0, (x, y) => isSubmapSKSA(x, y) && isSubmapSKSA(y, x));
}
function getMonoid(SK2, SA) {
  const lookupWithKeyS = lookupWithKey(SK2);
  return {
    concat: (mx, my) => {
      if (isEmpty(mx)) {
        return my;
      }
      if (isEmpty(my)) {
        return mx;
      }
      const r = new Map(mx);
      const entries = my.entries();
      let e;
      while (!(e = entries.next()).done) {
        const [k, a] = e.value;
        const mxOptA = lookupWithKeyS(k, mx);
        if (_chunkOTKMOSH2js.isSome.call(void 0, mxOptA)) {
          r.set(mxOptA.value[0], SA.concat(mxOptA.value[1], a));
        } else {
          r.set(k, a);
        }
      }
      return r;
    },
    empty
  };
}
var singleton = (k, a) => /* @__PURE__ */ new Map([[k, a]]);
function fromFoldable(E, M, F) {
  return (fka) => {
    const lookupWithKeyE = lookupWithKey(E);
    return F.reduce(fka, /* @__PURE__ */ new Map(), (b, [k, a]) => {
      const bOpt = lookupWithKeyE(k, b);
      if (_chunkOTKMOSH2js.isSome.call(void 0, bOpt)) {
        b.set(bOpt.value[0], M.concat(bOpt.value[1], a));
      } else {
        b.set(k, a);
      }
      return b;
    });
  };
}
var _mapWithIndex = (fa, f) => {
  const m = /* @__PURE__ */ new Map();
  const entries = fa.entries();
  let e;
  while (!(e = entries.next()).done) {
    const [key, a] = e.value;
    m.set(key, f(key, a));
  }
  return m;
};
var partitionMapWithIndex = (f) => (fa) => {
  const left = /* @__PURE__ */ new Map();
  const right = /* @__PURE__ */ new Map();
  const entries = fa.entries();
  let e;
  while (!(e = entries.next()).done) {
    const [k, a] = e.value;
    const ei = f(k, a);
    if (_chunkOTKMOSH2js.isLeft.call(void 0, ei)) {
      left.set(k, ei.left);
    } else {
      right.set(k, ei.right);
    }
  }
  return _chunkT4ZJ6CA2js.separated.call(void 0, left, right);
};
function partitionWithIndex(predicateWithIndex) {
  return (m) => {
    const left = /* @__PURE__ */ new Map();
    const right = /* @__PURE__ */ new Map();
    const entries = m.entries();
    let e;
    while (!(e = entries.next()).done) {
      const [k, a] = e.value;
      if (predicateWithIndex(k, a)) {
        right.set(k, a);
      } else {
        left.set(k, a);
      }
    }
    return _chunkT4ZJ6CA2js.separated.call(void 0, left, right);
  };
}
var filterMapWithIndex = (f) => (fa) => {
  const m = /* @__PURE__ */ new Map();
  const entries = fa.entries();
  let e;
  while (!(e = entries.next()).done) {
    const [k, a] = e.value;
    const o = f(k, a);
    if (_chunkOTKMOSH2js.isSome.call(void 0, o)) {
      m.set(k, o.value);
    }
  }
  return m;
};
function filterWithIndex(predicateWithIndex) {
  return (m) => {
    const out = /* @__PURE__ */ new Map();
    const entries = m.entries();
    let e;
    while (!(e = entries.next()).done) {
      const [k, a] = e.value;
      if (predicateWithIndex(k, a)) {
        out.set(k, a);
      }
    }
    return out;
  };
}
var _map = (fa, f) => _mapWithIndex(fa, (_, a) => f(a));
var _filter = (fa, p) => _filterWithIndex(fa, (_, a) => p(a));
var _filterMap = (fa, f) => _filterMapWithIndex(fa, (_, a) => f(a));
var _partition = (fa, predicate) => _partitionWithIndex(fa, (_, a) => predicate(a));
var _partitionMap = (fa, f) => _partitionMapWithIndex(fa, (_, a) => f(a));
var _filterWithIndex = (fa, p) => _chunkSQA7G4TEjs.pipe.call(void 0, fa, filterWithIndex(p));
var _filterMapWithIndex = (fa, f) => _chunkSQA7G4TEjs.pipe.call(void 0, fa, filterMapWithIndex(f));
var _partitionWithIndex = (fa, p) => _chunkSQA7G4TEjs.pipe.call(void 0, fa, partitionWithIndex(p));
var _partitionMapWithIndex = (fa, f) => _chunkSQA7G4TEjs.pipe.call(void 0, fa, partitionMapWithIndex(f));
var compact = (fa) => {
  const m = /* @__PURE__ */ new Map();
  const entries = fa.entries();
  let e;
  while (!(e = entries.next()).done) {
    const [k, oa] = e.value;
    if (_chunkOTKMOSH2js.isSome.call(void 0, oa)) {
      m.set(k, oa.value);
    }
  }
  return m;
};
var filter = (predicate) => (fa) => _filter(fa, predicate);
var filterMap = (f) => (fa) => _filterMap(fa, f);
var map2 = (f) => (fa) => _map(fa, f);
var mapWithIndex = (f) => (fa) => _mapWithIndex(fa, f);
var partition = (predicate) => (fa) => _partition(fa, predicate);
var partitionMap = (f) => (fa) => _partitionMap(fa, f);
var separate = (fa) => {
  const left = /* @__PURE__ */ new Map();
  const right = /* @__PURE__ */ new Map();
  const entries = fa.entries();
  let e;
  while (!(e = entries.next()).done) {
    const [k, ei] = e.value;
    if (_chunkOTKMOSH2js.isLeft.call(void 0, ei)) {
      left.set(k, ei.left);
    } else {
      right.set(k, ei.right);
    }
  }
  return _chunkT4ZJ6CA2js.separated.call(void 0, left, right);
};
var URI = "ReadonlyMap";
var getUnionSemigroup = (E, S) => {
  const unionES = union(E, S);
  return {
    concat: (first, second) => unionES(second)(first)
  };
};
var getUnionMonoid = (E, S) => ({
  concat: getUnionSemigroup(E, S).concat,
  empty
});
var getIntersectionSemigroup = (E, S) => {
  const intersectionES = intersection(E, S);
  return {
    concat: (first, second) => intersectionES(second)(first)
  };
};
var getDifferenceMagma = (E) => () => {
  const differenceE = difference(E);
  return {
    concat: (first, second) => differenceE(second)(first)
  };
};
function getFilterableWithIndex() {
  return {
    URI,
    _E: void 0,
    map: _map,
    mapWithIndex: _mapWithIndex,
    compact,
    separate,
    filter: _filter,
    filterMap: _filterMap,
    partition: _partition,
    partitionMap: _partitionMap,
    partitionMapWithIndex: _partitionMapWithIndex,
    partitionWithIndex: _partitionWithIndex,
    filterMapWithIndex: _filterMapWithIndex,
    filterWithIndex: _filterWithIndex
  };
}
var Functor = {
  URI,
  map: _map
};
var flap2 = /* @__PURE__ */ _chunk7K74W2G3js.flap.call(void 0, Functor);
var getFunctorWithIndex = () => ({
  URI,
  _E: void 0,
  map: _map,
  mapWithIndex: _mapWithIndex
});
var Compactable = {
  URI,
  compact,
  separate
};
var Filterable = {
  URI,
  map: _map,
  compact,
  separate,
  filter: _filter,
  filterMap: _filterMap,
  partition: _partition,
  partitionMap: _partitionMap
};
var reduce = (O) => {
  const reduceWithIndexO = reduceWithIndex(O);
  return (b, f) => reduceWithIndexO(b, (_, b2, a) => f(b2, a));
};
var foldMap = (O) => {
  const foldMapWithIndexO = foldMapWithIndex(O);
  return (M) => {
    const foldMapWithIndexOM = foldMapWithIndexO(M);
    return (f) => foldMapWithIndexOM((_, a) => f(a));
  };
};
var reduceRight = (O) => {
  const reduceRightWithIndexO = reduceRightWithIndex(O);
  return (b, f) => reduceRightWithIndexO(b, (_, b2, a) => f(b2, a));
};
var getFoldable = (O) => {
  const reduceO = reduce(O);
  const foldMapO = foldMap(O);
  const reduceRightO = reduceRight(O);
  return {
    URI,
    _E: void 0,
    reduce: (fa, b, f) => _chunkSQA7G4TEjs.pipe.call(void 0, fa, reduceO(b, f)),
    foldMap: (M) => {
      const foldMapOM = foldMapO(M);
      return (fa, f) => _chunkSQA7G4TEjs.pipe.call(void 0, fa, foldMapOM(f));
    },
    reduceRight: (fa, b, f) => _chunkSQA7G4TEjs.pipe.call(void 0, fa, reduceRightO(b, f))
  };
};
var reduceWithIndex = (O) => {
  const keysO = keys(O);
  return (b, f) => (m) => {
    let out = b;
    for (const k of keysO(m)) {
      out = f(k, out, m.get(k));
    }
    return out;
  };
};
var foldMapWithIndex = (O) => {
  const keysO = keys(O);
  return (M) => (f) => (m) => {
    let out = M.empty;
    for (const k of keysO(m)) {
      out = M.concat(out, f(k, m.get(k)));
    }
    return out;
  };
};
var reduceRightWithIndex = (O) => {
  const keysO = keys(O);
  return (b, f) => (m) => {
    let out = b;
    const ks = keysO(m);
    const len = ks.length;
    for (let i = len - 1; i >= 0; i--) {
      const k = ks[i];
      out = f(k, m.get(k), out);
    }
    return out;
  };
};
var getFoldableWithIndex = (O) => {
  const F = getFoldable(O);
  const reduceWithIndexO = reduceWithIndex(O);
  const foldMapWithIndexO = foldMapWithIndex(O);
  const reduceRightWithIndexO = reduceRightWithIndex(O);
  return {
    URI,
    _E: void 0,
    reduce: F.reduce,
    foldMap: F.foldMap,
    reduceRight: F.reduceRight,
    reduceWithIndex: (fa, b, f) => _chunkSQA7G4TEjs.pipe.call(void 0, fa, reduceWithIndexO(b, f)),
    foldMapWithIndex: (M) => {
      const foldMapWithIndexOM = foldMapWithIndexO(M);
      return (fa, f) => _chunkSQA7G4TEjs.pipe.call(void 0, fa, foldMapWithIndexOM(f));
    },
    reduceRightWithIndex: (fa, b, f) => _chunkSQA7G4TEjs.pipe.call(void 0, fa, reduceRightWithIndexO(b, f))
  };
};
var getTraversable = (O) => {
  const TWI = getTraversableWithIndex(O);
  const F = getFoldable(O);
  return {
    URI,
    _E: void 0,
    map: _map,
    reduce: F.reduce,
    foldMap: F.foldMap,
    reduceRight: F.reduceRight,
    traverse: TWI.traverse,
    sequence: TWI.sequence
  };
};
var getTraversableWithIndex = (O) => {
  const FWI = getFoldableWithIndex(O);
  const keysO = keys(O);
  const traverseWithIndex = (F) => {
    return (ta, f) => {
      let fm = F.of(/* @__PURE__ */ new Map());
      const ks = keysO(ta);
      const len = ks.length;
      for (let i = 0; i < len; i++) {
        const key = ks[i];
        const a = ta.get(key);
        fm = F.ap(
          F.map(fm, (m) => (b) => m.set(key, b)),
          f(key, a)
        );
      }
      return fm;
    };
  };
  const traverse = (F) => {
    const traverseWithIndexF = traverseWithIndex(F);
    return (ta, f) => traverseWithIndexF(ta, (_, a) => f(a));
  };
  const sequence = (F) => {
    const traverseWithIndexF = traverseWithIndex(F);
    return (ta) => traverseWithIndexF(ta, _chunkSQA7G4TEjs.SK);
  };
  return {
    URI,
    _E: void 0,
    map: _map,
    mapWithIndex: _mapWithIndex,
    reduce: FWI.reduce,
    foldMap: FWI.foldMap,
    reduceRight: FWI.reduceRight,
    reduceWithIndex: FWI.reduceWithIndex,
    foldMapWithIndex: FWI.foldMapWithIndex,
    reduceRightWithIndex: FWI.reduceRightWithIndex,
    traverse,
    sequence,
    traverseWithIndex
  };
};
function getWitherable(O) {
  const TWI = getTraversableWithIndex(O);
  return {
    URI,
    _E: void 0,
    map: _map,
    compact,
    separate,
    filter: _filter,
    filterMap: _filterMap,
    partition: _partition,
    partitionMap: _partitionMap,
    reduce: TWI.reduce,
    foldMap: TWI.foldMap,
    reduceRight: TWI.reduceRight,
    traverse: TWI.traverse,
    sequence: TWI.sequence,
    mapWithIndex: _mapWithIndex,
    reduceWithIndex: TWI.reduceWithIndex,
    foldMapWithIndex: TWI.foldMapWithIndex,
    reduceRightWithIndex: TWI.reduceRightWithIndex,
    traverseWithIndex: TWI.traverseWithIndex,
    wilt: _chunkUNAIGMDHjs.wiltDefault.call(void 0, TWI, Compactable),
    wither: _chunkUNAIGMDHjs.witherDefault.call(void 0, TWI, Compactable)
  };
}
var union = (E, M) => {
  const lookupE = lookup(E);
  return (second) => (first) => {
    if (isEmpty(first)) {
      return second;
    }
    if (isEmpty(second)) {
      return first;
    }
    const out = /* @__PURE__ */ new Map();
    const firstEntries = first.entries();
    let e;
    while (!(e = firstEntries.next()).done) {
      const [k, a] = e.value;
      const oka = lookupE(k)(second);
      if (_chunkOTKMOSH2js.isSome.call(void 0, oka)) {
        out.set(k, M.concat(a, oka.value));
      } else {
        out.set(k, a);
      }
    }
    const secondEntries = second.entries();
    while (!(e = secondEntries.next()).done) {
      const [k, a] = e.value;
      const oka = lookupE(k)(out);
      if (_chunkOTKMOSH2js.isNone.call(void 0, oka)) {
        out.set(k, a);
      }
    }
    return out;
  };
};
var intersection = (E, M) => {
  const lookupE = lookup(E);
  return (second) => (first) => {
    if (isEmpty(first) || isEmpty(second)) {
      return empty;
    }
    const out = /* @__PURE__ */ new Map();
    const entries = first.entries();
    let e;
    while (!(e = entries.next()).done) {
      const [k, a] = e.value;
      const oka = lookupE(k)(second);
      if (_chunkOTKMOSH2js.isSome.call(void 0, oka)) {
        out.set(k, M.concat(a, oka.value));
      }
    }
    return out;
  };
};
var difference = (E) => {
  const memberE = member(E);
  return (second) => (first) => {
    if (isEmpty(first)) {
      return second;
    }
    if (isEmpty(second)) {
      return first;
    }
    const out = /* @__PURE__ */ new Map();
    const firstEntries = first.entries();
    let e;
    while (!(e = firstEntries.next()).done) {
      const [k, a] = e.value;
      if (!memberE(k)(second)) {
        out.set(k, a);
      }
    }
    const secondEntries = second.entries();
    while (!(e = secondEntries.next()).done) {
      const [k, a] = e.value;
      if (!memberE(k)(first)) {
        out.set(k, a);
      }
    }
    return out;
  };
};
var insertAt = upsertAt;
var readonlyMap = {
  URI,
  map: _map,
  compact,
  separate,
  filter: _filter,
  filterMap: _filterMap,
  partition: _partition,
  partitionMap: _partitionMap
};



































































exports.fromMap = fromMap; exports.toMap = toMap; exports.getShow = getShow; exports.size = size; exports.isEmpty = isEmpty; exports.member = member; exports.elem = elem; exports.keys = keys; exports.values = values; exports.collect = collect; exports.toReadonlyArray = toReadonlyArray; exports.toUnfoldable = toUnfoldable; exports.upsertAt = upsertAt; exports.deleteAt = deleteAt; exports.updateAt = updateAt; exports.modifyAt = modifyAt; exports.pop = pop; exports.lookupWithKey = lookupWithKey; exports.lookup = lookup; exports.isSubmap = isSubmap; exports.empty = empty; exports.getEq = getEq; exports.getMonoid = getMonoid; exports.singleton = singleton; exports.fromFoldable = fromFoldable; exports.partitionMapWithIndex = partitionMapWithIndex; exports.partitionWithIndex = partitionWithIndex; exports.filterMapWithIndex = filterMapWithIndex; exports.filterWithIndex = filterWithIndex; exports.compact = compact; exports.filter = filter; exports.filterMap = filterMap; exports.map = map2; exports.mapWithIndex = mapWithIndex; exports.partition = partition; exports.partitionMap = partitionMap; exports.separate = separate; exports.URI = URI; exports.getUnionSemigroup = getUnionSemigroup; exports.getUnionMonoid = getUnionMonoid; exports.getIntersectionSemigroup = getIntersectionSemigroup; exports.getDifferenceMagma = getDifferenceMagma; exports.getFilterableWithIndex = getFilterableWithIndex; exports.Functor = Functor; exports.flap = flap2; exports.getFunctorWithIndex = getFunctorWithIndex; exports.Compactable = Compactable; exports.Filterable = Filterable; exports.reduce = reduce; exports.foldMap = foldMap; exports.reduceRight = reduceRight; exports.getFoldable = getFoldable; exports.reduceWithIndex = reduceWithIndex; exports.foldMapWithIndex = foldMapWithIndex; exports.reduceRightWithIndex = reduceRightWithIndex; exports.getFoldableWithIndex = getFoldableWithIndex; exports.getTraversable = getTraversable; exports.getTraversableWithIndex = getTraversableWithIndex; exports.getWitherable = getWitherable; exports.union = union; exports.intersection = intersection; exports.difference = difference; exports.insertAt = insertAt; exports.readonlyMap = readonlyMap; exports.ReadonlyMap_exports = ReadonlyMap_exports;
