effect 2.0.0-next.38 → 2.0.0-next.39

package/dist/HashSet-69824ba8.esm.js

@@ -1,907 +0,0 @@
-import { e as equals, s as symbol$1 } from './Equal-2a99fde3.esm.js';
-import { d as dual, p as pipe, i as identity } from './Function-12511160.esm.js';
-import { h as hash, s as symbol, c as combine } from './Hash-7910f34f.esm.js';
-import { t as toString, a as toJSON, N as NodeInspectSymbol } from './Inspectable-b0c51e90.esm.js';
-import { S as Stack } from './Stack-765c2298.esm.js';
-import { n as none, a as isNone, i as isSome, s as some$1, m as map$2 } from './Option-df40d2b9.esm.js';
-import { p as pipeArguments } from './Pipeable-10760a1d.esm.js';
-import { i as isObject } from './Predicate-6b61b95b.esm.js';
-
-/** @internal */
-const SIZE = 5;
-
-/** @internal */
-const BUCKET_SIZE = /*#__PURE__*/Math.pow(2, SIZE);
-
-/** @internal */
-const MASK = BUCKET_SIZE - 1;
-
-/** @internal */
-const MAX_INDEX_NODE = BUCKET_SIZE / 2;
-
-/** @internal */
-const MIN_ARRAY_NODE = BUCKET_SIZE / 4;
-
-/**
- * Hamming weight.
- *
- * Taken from: http://jsperf.com/hamming-weight
- *
- * @internal
- */
-function popcount(x) {
-  x -= x >> 1 & 0x55555555;
-  x = (x & 0x33333333) + (x >> 2 & 0x33333333);
-  x = x + (x >> 4) & 0x0f0f0f0f;
-  x += x >> 8;
-  x += x >> 16;
-  return x & 0x7f;
-}
-
-/** @internal */
-function hashFragment(shift, h) {
-  return h >>> shift & MASK;
-}
-
-/** @internal */
-function toBitmap(x) {
-  return 1 << x;
-}
-
-/** @internal */
-function fromBitmap(bitmap, bit) {
-  return popcount(bitmap & bit - 1);
-}
-
-/** @internal */
-function arrayUpdate(mutate, at, v, arr) {
-  let out = arr;
-  if (!mutate) {
-    const len = arr.length;
-    out = new Array(len);
-    for (let i = 0; i < len; ++i) out[i] = arr[i];
-  }
-  out[at] = v;
-  return out;
-}
-
-/** @internal */
-function arraySpliceOut(mutate, at, arr) {
-  const newLen = arr.length - 1;
-  let i = 0;
-  let g = 0;
-  let out = arr;
-  if (mutate) {
-    i = g = at;
-  } else {
-    out = new Array(newLen);
-    while (i < at) out[g++] = arr[i++];
-  }
-  ++i;
-  while (i <= newLen) out[g++] = arr[i++];
-  if (mutate) {
-    out.length = newLen;
-  }
-  return out;
-}
-
-/** @internal */
-function arraySpliceIn(mutate, at, v, arr) {
-  const len = arr.length;
-  if (mutate) {
-    let i = len;
-    while (i >= at) arr[i--] = arr[i];
-    arr[at] = v;
-    return arr;
-  }
-  let i = 0,
-    g = 0;
-  const out = new Array(len + 1);
-  while (i < at) out[g++] = arr[i++];
-  out[at] = v;
-  while (i < len) out[++g] = arr[i++];
-  return out;
-}
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-class EmptyNode {
-  _tag = "EmptyNode";
-  modify(edit, _shift, f, hash, key, size) {
-    const v = f(none());
-    if (isNone(v)) return new EmptyNode();
-    ++size.value;
-    return new LeafNode(edit, hash, key, v);
-  }
-}
-
-/** @internal */
-function isEmptyNode(a) {
-  return a instanceof EmptyNode;
-}
-
-/** @internal */
-function isLeafNode(node) {
-  return isEmptyNode(node) || node._tag === "LeafNode" || node._tag === "CollisionNode";
-}
-
-/** @internal */
-function canEditNode(node, edit) {
-  return isEmptyNode(node) ? false : edit === node.edit;
-}
-
-/** @internal */
-class LeafNode {
-  _tag = "LeafNode";
-  constructor(edit, hash, key, value) {
-    this.edit = edit;
-    this.hash = hash;
-    this.key = key;
-    this.value = value;
-  }
-  modify(edit, shift, f, hash, key, size) {
-    if (equals(key, this.key)) {
-      const v = f(this.value);
-      if (v === this.value) return this;else if (isNone(v)) {
-        --size.value;
-        return new EmptyNode();
-      }
-      if (canEditNode(this, edit)) {
-        this.value = v;
-        return this;
-      }
-      return new LeafNode(edit, hash, key, v);
-    }
-    const v = f(none());
-    if (isNone(v)) return this;
-    ++size.value;
-    return mergeLeaves(edit, shift, this.hash, this, hash, new LeafNode(edit, hash, key, v));
-  }
-}
-
-/** @internal */
-class CollisionNode {
-  _tag = "CollisionNode";
-  constructor(edit, hash, children) {
-    this.edit = edit;
-    this.hash = hash;
-    this.children = children;
-  }
-  modify(edit, shift, f, hash, key, size) {
-    if (hash === this.hash) {
-      const canEdit = canEditNode(this, edit);
-      const list = this.updateCollisionList(canEdit, edit, this.hash, this.children, f, key, size);
-      if (list === this.children) return this;
-      return list.length > 1 ? new CollisionNode(edit, this.hash, list) : list[0]; // collapse single element collision list
-    }
-
-    const v = f(none());
-    if (isNone(v)) return this;
-    ++size.value;
-    return mergeLeaves(edit, shift, this.hash, this, hash, new LeafNode(edit, hash, key, v));
-  }
-  updateCollisionList(mutate, edit, hash, list, f, key, size) {
-    const len = list.length;
-    for (let i = 0; i < len; ++i) {
-      const child = list[i];
-      if ("key" in child && equals(key, child.key)) {
-        const value = child.value;
-        const newValue = f(value);
-        if (newValue === value) return list;
-        if (isNone(newValue)) {
-          --size.value;
-          return arraySpliceOut(mutate, i, list);
-        }
-        return arrayUpdate(mutate, i, new LeafNode(edit, hash, key, newValue), list);
-      }
-    }
-    const newValue = f(none());
-    if (isNone(newValue)) return list;
-    ++size.value;
-    return arrayUpdate(mutate, len, new LeafNode(edit, hash, key, newValue), list);
-  }
-}
-
-/** @internal */
-class IndexedNode {
-  _tag = "IndexedNode";
-  constructor(edit, mask, children) {
-    this.edit = edit;
-    this.mask = mask;
-    this.children = children;
-  }
-  modify(edit, shift, f, hash, key, size) {
-    const mask = this.mask;
-    const children = this.children;
-    const frag = hashFragment(shift, hash);
-    const bit = toBitmap(frag);
-    const indx = fromBitmap(mask, bit);
-    const exists = mask & bit;
-    const canEdit = canEditNode(this, edit);
-    if (!exists) {
-      const _newChild = new EmptyNode().modify(edit, shift + SIZE, f, hash, key, size);
-      if (!_newChild) return this;
-      return children.length >= MAX_INDEX_NODE ? expand(edit, frag, _newChild, mask, children) : new IndexedNode(edit, mask | bit, arraySpliceIn(canEdit, indx, _newChild, children));
-    }
-    const current = children[indx];
-    const child = current.modify(edit, shift + SIZE, f, hash, key, size);
-    if (current === child) return this;
-    let bitmap = mask;
-    let newChildren;
-    if (isEmptyNode(child)) {
-      // remove
-      bitmap &= ~bit;
-      if (!bitmap) return new EmptyNode();
-      if (children.length <= 2 && isLeafNode(children[indx ^ 1])) {
-        return children[indx ^ 1]; // collapse
-      }
-
-      newChildren = arraySpliceOut(canEdit, indx, children);
-    } else {
-      // modify
-      newChildren = arrayUpdate(canEdit, indx, child, children);
-    }
-    if (canEdit) {
-      this.mask = bitmap;
-      this.children = newChildren;
-      return this;
-    }
-    return new IndexedNode(edit, bitmap, newChildren);
-  }
-}
-
-/** @internal */
-class ArrayNode {
-  _tag = "ArrayNode";
-  constructor(edit, size, children) {
-    this.edit = edit;
-    this.size = size;
-    this.children = children;
-  }
-  modify(edit, shift, f, hash, key, size) {
-    let count = this.size;
-    const children = this.children;
-    const frag = hashFragment(shift, hash);
-    const child = children[frag];
-    const newChild = (child || new EmptyNode()).modify(edit, shift + SIZE, f, hash, key, size);
-    if (child === newChild) return this;
-    const canEdit = canEditNode(this, edit);
-    let newChildren;
-    if (isEmptyNode(child) && !isEmptyNode(newChild)) {
-      ++count;
-      newChildren = arrayUpdate(canEdit, frag, newChild, children);
-    } else if (!isEmptyNode(child) && isEmptyNode(newChild)) {
-      --count;
-      if (count <= MIN_ARRAY_NODE) {
-        return pack(edit, count, frag, children);
-      }
-      newChildren = arrayUpdate(canEdit, frag, new EmptyNode(), children);
-    } else {
-      // modify
-      newChildren = arrayUpdate(canEdit, frag, newChild, children);
-    }
-    if (canEdit) {
-      this.size = count;
-      this.children = newChildren;
-      return this;
-    }
-    return new ArrayNode(edit, count, newChildren);
-  }
-}
-function pack(edit, count, removed, elements) {
-  const children = new Array(count - 1);
-  let g = 0;
-  let bitmap = 0;
-  for (let i = 0, len = elements.length; i < len; ++i) {
-    if (i !== removed) {
-      const elem = elements[i];
-      if (elem && !isEmptyNode(elem)) {
-        children[g++] = elem;
-        bitmap |= 1 << i;
-      }
-    }
-  }
-  return new IndexedNode(edit, bitmap, children);
-}
-function expand(edit, frag, child, bitmap, subNodes) {
-  const arr = [];
-  let bit = bitmap;
-  let count = 0;
-  for (let i = 0; bit; ++i) {
-    if (bit & 1) arr[i] = subNodes[count++];
-    bit >>>= 1;
-  }
-  arr[frag] = child;
-  return new ArrayNode(edit, count + 1, arr);
-}
-function mergeLeavesInner(edit, shift, h1, n1, h2, n2) {
-  if (h1 === h2) return new CollisionNode(edit, h1, [n2, n1]);
-  const subH1 = hashFragment(shift, h1);
-  const subH2 = hashFragment(shift, h2);
-  if (subH1 === subH2) {
-    return child => new IndexedNode(edit, toBitmap(subH1) | toBitmap(subH2), [child]);
-  } else {
-    const children = subH1 < subH2 ? [n1, n2] : [n2, n1];
-    return new IndexedNode(edit, toBitmap(subH1) | toBitmap(subH2), children);
-  }
-}
-function mergeLeaves(edit, shift, h1, n1, h2, n2) {
-  let stack = undefined;
-  let currentShift = shift;
-  // eslint-disable-next-line no-constant-condition
-  while (true) {
-    const res = mergeLeavesInner(edit, currentShift, h1, n1, h2, n2);
-    if (typeof res === "function") {
-      stack = new Stack(res, stack);
-      currentShift = currentShift + SIZE;
-    } else {
-      let final = res;
-      while (stack != null) {
-        final = stack.value(final);
-        stack = stack.previous;
-      }
-      return final;
-    }
-  }
-}
-
-/** @internal */
-const HashMapTypeId = /*#__PURE__*/Symbol.for("effect/HashMap");
-
-/** @internal */
-
-const HashMapProto = {
-  [HashMapTypeId]: HashMapTypeId,
-  [Symbol.iterator]() {
-    return new HashMapIterator(this, (k, v) => [k, v]);
-  },
-  [symbol]() {
-    let hash$1 = hash("HashMap");
-    for (const item of this) {
-      hash$1 ^= combine(hash(item[0]))(hash(item[1]));
-    }
-    return hash$1;
-  },
-  [symbol$1](that) {
-    if (isHashMap(that)) {
-      if (that._size !== this._size) {
-        return false;
-      }
-      for (const item of this) {
-        const elem = pipe(that, getHash(item[0], hash(item[0])));
-        if (isNone(elem)) {
-          return false;
-        } else {
-          if (!equals(item[1], elem.value)) {
-            return false;
-          }
-        }
-      }
-      return true;
-    }
-    return false;
-  },
-  toString() {
-    return toString(this.toJSON());
-  },
-  toJSON() {
-    return {
-      _id: "HashMap",
-      values: Array.from(this).map(toJSON)
-    };
-  },
-  [NodeInspectSymbol]() {
-    return this.toJSON();
-  },
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-};
-const makeImpl$1 = (editable, edit, root, size) => {
-  const map = Object.create(HashMapProto);
-  map._editable = editable;
-  map._edit = edit;
-  map._root = root;
-  map._size = size;
-  return map;
-};
-class HashMapIterator {
-  constructor(map, f) {
-    this.map = map;
-    this.f = f;
-    this.v = visitLazy(this.map._root, this.f, undefined);
-  }
-  next() {
-    if (isNone(this.v)) {
-      return {
-        done: true,
-        value: undefined
-      };
-    }
-    const v0 = this.v.value;
-    this.v = applyCont(v0.cont);
-    return {
-      done: false,
-      value: v0.value
-    };
-  }
-  [Symbol.iterator]() {
-    return new HashMapIterator(this.map, this.f);
-  }
-}
-const applyCont = cont => cont ? visitLazyChildren(cont[0], cont[1], cont[2], cont[3], cont[4]) : none();
-const visitLazy = (node, f, cont = undefined) => {
-  switch (node._tag) {
-    case "LeafNode":
-      {
-        if (isSome(node.value)) {
-          return some$1({
-            value: f(node.key, node.value.value),
-            cont
-          });
-        }
-        return applyCont(cont);
-      }
-    case "CollisionNode":
-    case "ArrayNode":
-    case "IndexedNode":
-      {
-        const children = node.children;
-        return visitLazyChildren(children.length, children, 0, f, cont);
-      }
-    default:
-      {
-        return applyCont(cont);
-      }
-  }
-};
-const visitLazyChildren = (len, children, i, f, cont) => {
-  while (i < len) {
-    const child = children[i++];
-    if (child && !isEmptyNode(child)) {
-      return visitLazy(child, f, [len, children, i, f, cont]);
-    }
-  }
-  return applyCont(cont);
-};
-const _empty$1 = /*#__PURE__*/makeImpl$1(false, 0, /*#__PURE__*/new EmptyNode(), 0);
-
-/** @internal */
-const empty$1 = () => _empty$1;
-
-/** @internal */
-const make$1 = (...entries) => fromIterable$1(entries);
-
-/** @internal */
-const fromIterable$1 = entries => {
-  const map = beginMutation$1(empty$1());
-  for (const entry of entries) {
-    set(entry[0], entry[1])(map);
-  }
-  return endMutation$1(map);
-};
-
-/** @internal */
-const isHashMap = u => isObject(u) && HashMapTypeId in u;
-
-/** @internal */
-const isEmpty = self => self && isEmptyNode(self._root);
-
-/** @internal */
-const get = /*#__PURE__*/dual(2, (self, key) => getHash(self, key, hash(key)));
-
-/** @internal */
-const getHash = /*#__PURE__*/dual(3, (self, key, hash) => {
-  let node = self._root;
-  let shift = 0;
-  // eslint-disable-next-line no-constant-condition
-  while (true) {
-    switch (node._tag) {
-      case "LeafNode":
-        {
-          return equals(key, node.key) ? node.value : none();
-        }
-      case "CollisionNode":
-        {
-          if (hash === node.hash) {
-            const children = node.children;
-            for (let i = 0, len = children.length; i < len; ++i) {
-              const child = children[i];
-              if ("key" in child && equals(key, child.key)) {
-                return child.value;
-              }
-            }
-          }
-          return none();
-        }
-      case "IndexedNode":
-        {
-          const frag = hashFragment(shift, hash);
-          const bit = toBitmap(frag);
-          if (node.mask & bit) {
-            node = node.children[fromBitmap(node.mask, bit)];
-            shift += SIZE;
-            break;
-          }
-          return none();
-        }
-      case "ArrayNode":
-        {
-          node = node.children[hashFragment(shift, hash)];
-          if (node) {
-            shift += SIZE;
-            break;
-          }
-          return none();
-        }
-      default:
-        return none();
-    }
-  }
-});
-
-/** @internal */
-const unsafeGet = /*#__PURE__*/dual(2, (self, key) => {
-  const element = getHash(self, key, hash(key));
-  if (isNone(element)) {
-    throw new Error("Error: Expected map to contain key");
-  }
-  return element.value;
-});
-
-/** @internal */
-const has$1 = /*#__PURE__*/dual(2, (self, key) => isSome(getHash(self, key, hash(key))));
-
-/** @internal */
-const hasHash = /*#__PURE__*/dual(3, (self, key, hash) => isSome(getHash(self, key, hash)));
-
-/** @internal */
-const set = /*#__PURE__*/dual(3, (self, key, value) => modifyAt(self, key, () => some$1(value)));
-
-/** @internal */
-const setTree = /*#__PURE__*/dual(3, (self, newRoot, newSize) => {
-  if (self._editable) {
-    self._root = newRoot;
-    self._size = newSize;
-    return self;
-  }
-  return newRoot === self._root ? self : makeImpl$1(self._editable, self._edit, newRoot, newSize);
-});
-
-/** @internal */
-const keys = self => new HashMapIterator(self, key => key);
-
-/** @internal */
-const values$1 = self => new HashMapIterator(self, (_, value) => value);
-
-/** @internal */
-const size$1 = self => self._size;
-
-/** @internal */
-const beginMutation$1 = self => makeImpl$1(true, self._edit + 1, self._root, self._size);
-
-/** @internal */
-const endMutation$1 = self => {
-  self._editable = false;
-  return self;
-};
-
-/** @internal */
-const mutate$1 = /*#__PURE__*/dual(2, (self, f) => {
-  const transient = beginMutation$1(self);
-  f(transient);
-  return endMutation$1(transient);
-});
-
-/** @internal */
-const modifyAt = /*#__PURE__*/dual(3, (self, key, f) => modifyHash(self, key, hash(key), f));
-
-/** @internal */
-const modifyHash = /*#__PURE__*/dual(4, (self, key, hash, f) => {
-  const size = {
-    value: self._size
-  };
-  const newRoot = self._root.modify(self._editable ? self._edit : NaN, 0, f, hash, key, size);
-  return pipe(self, setTree(newRoot, size.value));
-});
-
-/** @internal */
-const modify = /*#__PURE__*/dual(3, (self, key, f) => modifyAt(self, key, map$2(f)));
-
-/** @internal */
-const union$1 = /*#__PURE__*/dual(2, (self, that) => {
-  const result = beginMutation$1(self);
-  forEach$1(that, (v, k) => set(result, k, v));
-  return endMutation$1(result);
-});
-
-/** @internal */
-const remove$1 = /*#__PURE__*/dual(2, (self, key) => modifyAt(self, key, none));
-
-/** @internal */
-const removeMany = /*#__PURE__*/dual(2, (self, keys) => mutate$1(self, map => {
-  for (const key of keys) {
-    remove$1(key)(map);
-  }
-}));
-
-/**
- * Maps over the entries of the `HashMap` using the specified function.
- *
- * @since 2.0.0
- * @category mapping
- */
-const map$1 = /*#__PURE__*/dual(2, (self, f) => reduce$1(self, empty$1(), (map, value, key) => set(map, key, f(value, key))));
-
-/** @internal */
-const flatMap$1 = /*#__PURE__*/dual(2, (self, f) => reduce$1(self, empty$1(), (zero, value, key) => mutate$1(zero, map => forEach$1(f(value, key), (value, key) => set(map, key, value)))));
-
-/** @internal */
-const forEach$1 = /*#__PURE__*/dual(2, (self, f) => reduce$1(self, void 0, (_, value, key) => f(value, key)));
-
-/** @internal */
-const reduce$1 = /*#__PURE__*/dual(3, (self, zero, f) => {
-  const root = self._root;
-  if (root._tag === "LeafNode") {
-    return isSome(root.value) ? f(zero, root.value.value, root.key) : zero;
-  }
-  if (root._tag === "EmptyNode") {
-    return zero;
-  }
-  const toVisit = [root.children];
-  let children;
-  while (children = toVisit.pop()) {
-    for (let i = 0, len = children.length; i < len;) {
-      const child = children[i++];
-      if (child && !isEmptyNode(child)) {
-        if (child._tag === "LeafNode") {
-          if (isSome(child.value)) {
-            zero = f(zero, child.value.value, child.key);
-          }
-        } else {
-          toVisit.push(child.children);
-        }
-      }
-    }
-  }
-  return zero;
-});
-
-/** @internal */
-const filter$1 = /*#__PURE__*/dual(2, (self, f) => mutate$1(empty$1(), map => {
-  for (const [k, a] of self) {
-    if (f(a, k)) {
-      set(map, k, a);
-    }
-  }
-}));
-
-/** @internal */
-const compact = self => filterMap(self, identity);
-
-/** @internal */
-const filterMap = /*#__PURE__*/dual(2, (self, f) => mutate$1(empty$1(), map => {
-  for (const [k, a] of self) {
-    const option = f(a, k);
-    if (isSome(option)) {
-      set(map, k, option.value);
-    }
-  }
-}));
-
-/** @internal */
-const findFirst = /*#__PURE__*/dual(2, (self, predicate) => {
-  for (const ka of self) {
-    if (predicate(ka[0], ka[1])) {
-      return some$1(ka);
-    }
-  }
-  return none();
-});
-
-/** @internal */
-const HashSetTypeId = /*#__PURE__*/Symbol.for("effect/HashSet");
-
-/** @internal */
-
-const HashSetProto = {
-  [HashSetTypeId]: HashSetTypeId,
-  [Symbol.iterator]() {
-    return keys(this._keyMap);
-  },
-  [symbol]() {
-    return combine(hash(this._keyMap))(hash("HashSet"));
-  },
-  [symbol$1](that) {
-    if (isHashSet(that)) {
-      return size$1(this._keyMap) === size$1(that._keyMap) && equals(this._keyMap, that._keyMap);
-    }
-    return false;
-  },
-  toString() {
-    return toString(this.toJSON());
-  },
-  toJSON() {
-    return {
-      _id: "HashSet",
-      values: Array.from(this).map(toJSON)
-    };
-  },
-  [NodeInspectSymbol]() {
-    return this.toJSON();
-  },
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-};
-
-/** @internal */
-const makeImpl = keyMap => {
-  const set = Object.create(HashSetProto);
-  set._keyMap = keyMap;
-  return set;
-};
-
-/** @internal */
-const isHashSet = u => isObject(u) && HashSetTypeId in u;
-const _empty = /*#__PURE__*/makeImpl( /*#__PURE__*/empty$1());
-
-/** @internal */
-const empty = () => _empty;
-
-/** @internal */
-const fromIterable = elements => {
-  const set = beginMutation(empty());
-  for (const value of elements) {
-    add(set, value);
-  }
-  return endMutation(set);
-};
-
-/** @internal */
-const make = (...elements) => {
-  const set = beginMutation(empty());
-  for (const value of elements) {
-    add(set, value);
-  }
-  return endMutation(set);
-};
-
-/** @internal */
-const has = /*#__PURE__*/dual(2, (self, value) => has$1(self._keyMap, value));
-
-/** @internal */
-const some = /*#__PURE__*/dual(2, (self, f) => {
-  let found = false;
-  for (const value of self) {
-    found = f(value);
-    if (found) {
-      break;
-    }
-  }
-  return found;
-});
-
-/** @internal */
-const every = /*#__PURE__*/dual(2, (self, refinement) => !some(self, a => !refinement(a)));
-
-/** @internal */
-const isSubset = /*#__PURE__*/dual(2, (self, that) => every(self, value => has(that, value)));
-
-/** @internal */
-const values = self => keys(self._keyMap);
-
-/** @internal */
-const size = self => size$1(self._keyMap);
-
-/** @internal */
-const beginMutation = self => makeImpl(beginMutation$1(self._keyMap));
-
-/** @internal */
-const endMutation = self => {
-  self._keyMap._editable = false;
-  return self;
-};
-
-/** @internal */
-const mutate = /*#__PURE__*/dual(2, (self, f) => {
-  const transient = beginMutation(self);
-  f(transient);
-  return endMutation(transient);
-});
-
-/** @internal */
-const add = /*#__PURE__*/dual(2, (self, value) => self._keyMap._editable ? (set(value, true)(self._keyMap), self) : makeImpl(set(value, true)(self._keyMap)));
-
-/** @internal */
-const remove = /*#__PURE__*/dual(2, (self, value) => self._keyMap._editable ? (remove$1(value)(self._keyMap), self) : makeImpl(remove$1(value)(self._keyMap)));
-
-/** @internal */
-const difference = /*#__PURE__*/dual(2, (self, that) => mutate(self, set => {
-  for (const value of that) {
-    remove(set, value);
-  }
-}));
-
-/** @internal */
-const intersection = /*#__PURE__*/dual(2, (self, that) => mutate(empty(), set => {
-  for (const value of that) {
-    if (has(value)(self)) {
-      add(value)(set);
-    }
-  }
-}));
-
-/** @internal */
-const union = /*#__PURE__*/dual(2, (self, that) => mutate(empty(), set => {
-  forEach(self, value => add(set, value));
-  for (const value of that) {
-    add(set, value);
-  }
-}));
-
-/** @internal */
-const toggle = /*#__PURE__*/dual(2, (self, value) => has(self, value) ? remove(self, value) : add(self, value));
-
-/** @internal */
-const map = /*#__PURE__*/dual(2, (self, f) => mutate(empty(), set => {
-  forEach(self, a => {
-    const b = f(a);
-    if (!has(set, b)) {
-      add(set, b);
-    }
-  });
-}));
-
-/** @internal */
-const flatMap = /*#__PURE__*/dual(2, (self, f) => mutate(empty(), set => {
-  forEach(self, a => {
-    for (const b of f(a)) {
-      if (!has(set, b)) {
-        add(set, b);
-      }
-    }
-  });
-}));
-
-/** @internal */
-const forEach = /*#__PURE__*/dual(2, (self, f) => forEach$1(self._keyMap, (_, k) => f(k)));
-
-/** @internal */
-const reduce = /*#__PURE__*/dual(3, (self, zero, f) => reduce$1(self._keyMap, zero, (z, _, a) => f(z, a)));
-
-/** @internal */
-const filter = /*#__PURE__*/dual(2, (self, f) => {
-  return mutate(empty(), set => {
-    const iterator = values(self);
-    let next;
-    while (!(next = iterator.next()).done) {
-      const value = next.value;
-      if (f(value)) {
-        add(set, value);
-      }
-    }
-  });
-});
-
-/** @internal */
-const partition = /*#__PURE__*/dual(2, (self, f) => {
-  const iterator = values(self);
-  let next;
-  const right = beginMutation(empty());
-  const left = beginMutation(empty());
-  while (!(next = iterator.next()).done) {
-    const value = next.value;
-    if (f(value)) {
-      add(right, value);
-    } else {
-      add(left, value);
-    }
-  }
-  return [endMutation(left), endMutation(right)];
-});
-
-export { filter$1 as $, isHashMap as A, empty$1 as B, make$1 as C, fromIterable$1 as D, isEmpty as E, get as F, getHash as G, unsafeGet as H, has$1 as I, hasHash as J, set as K, keys as L, values$1 as M, size$1 as N, beginMutation$1 as O, endMutation$1 as P, mutate$1 as Q, modifyAt as R, modifyHash as S, modify as T, union$1 as U, remove$1 as V, removeMany as W, map$1 as X, flatMap$1 as Y, forEach$1 as Z, reduce$1 as _, every as a, compact as a0, filterMap as a1, findFirst as a2, isSubset as b, size as c, beginMutation as d, empty as e, fromIterable as f, endMutation as g, has as h, isHashSet as i, mutate as j, add as k, difference as l, make as m, intersection as n, map as o, flatMap as p, forEach as q, remove as r, some as s, toggle as t, union as u, values as v, reduce as w, filter as x, partition as y, makeImpl as z };