effect 2.0.0-next.49 → 2.0.0-next.50

package/ReadonlyRecord/dist/effect-ReadonlyRecord.esm.js

@@ -1,6 +1,7 @@
 import { isLeft } from '../../Either/dist/effect-Either.esm.js';
+import { equivalence } from '../../Equal/dist/effect-Equal.esm.js';
 import { dual, identity } from '../../Function/dist/effect-Function.esm.js';
-import { some, none, isSome } from '../../Option/dist/effect-Option.esm.js';
+import { some as some$1, none, isSome } from '../../Option/dist/effect-Option.esm.js';
 
 /**
  * This module provides utility functions for working with records in TypeScript.
@@ -8,21 +9,16 @@ import { some, none, isSome } from '../../Option/dist/effect-Option.esm.js';
  * @since 2.0.0
  */
 
-// -------------------------------------------------------------------------------------
-// models
-// -------------------------------------------------------------------------------------
-
 /**
  * @category models
  * @since 2.0.0
  */
+
 /**
  * @category type lambdas
  * @since 2.0.0
  */
-// -------------------------------------------------------------------------------------
-// constructors
-// -------------------------------------------------------------------------------------
+
 /**
  * Creates a new, empty record.
  *
@@ -31,14 +27,10 @@ import { some, none, isSome } from '../../Option/dist/effect-Option.esm.js';
  */
 const empty = () => ({});
 
-// -------------------------------------------------------------------------------------
-// guards
-// -------------------------------------------------------------------------------------
-
 /**
- * Determine if a `Record` is empty.
+ * Determine if a record is empty.
  *
- * @param self - `Record` to test for emptiness.
+ * @param self - record to test for emptiness.
  *
  * @example
  * import { isEmptyRecord } from "effect/ReadonlyRecord"
@@ -59,9 +51,9 @@ const isEmptyRecord = self => {
 };
 
 /**
- * Determine if a `ReadonlyRecord` is empty.
+ * Determine if a record is empty.
  *
- * @param self - `ReadonlyRecord` to test for emptiness.
+ * @param self - record to test for emptiness.
  *
  * @example
  * import { isEmptyReadonlyRecord } from "effect/ReadonlyRecord"
@@ -74,10 +66,6 @@ const isEmptyRecord = self => {
  */
 const isEmptyReadonlyRecord = isEmptyRecord;
 
-// -------------------------------------------------------------------------------------
-// conversions
-// -------------------------------------------------------------------------------------
-
 /**
  * Takes an iterable and a projection function and returns a record.
  * The projection function maps each value of the iterable to a tuple of a key and a value, which is then added to the resulting record.
@@ -86,7 +74,7 @@ const isEmptyReadonlyRecord = isEmptyRecord;
  * @param f - A projection function that maps values of the iterable to a tuple of a key and a value.
  *
  * @example
- * import { fromIterable } from 'effect/ReadonlyRecord'
+ * import { fromIterable } from "effect/ReadonlyRecord"
  *
  * const input = [1, 2, 3, 4]
  *
@@ -116,7 +104,7 @@ const fromIterable = /*#__PURE__*/dual(2, (self, f) => {
  * @param self - The iterable of key-value pairs.
  *
  * @example
- * import { fromEntries } from 'effect/ReadonlyRecord'
+ * import { fromEntries } from "effect/ReadonlyRecord"
  *
  * const input: Array<[string, number]> = [["a", 1], ["b", 2]]
  *
@@ -128,10 +116,10 @@ const fromIterable = /*#__PURE__*/dual(2, (self, f) => {
 const fromEntries = /*#__PURE__*/fromIterable(identity);
 
 /**
- * Transforms the values of a `ReadonlyRecord` into an `Array` with a custom mapping function.
+ * Transforms the values of a record into an `Array` with a custom mapping function.
  *
- * @param self - The `ReadonlyRecord` to transform.
- * @param f - The custom mapping function to apply to each key/value of the `ReadonlyRecord`.
+ * @param self - The record to transform.
+ * @param f - The custom mapping function to apply to each key/value of the record.
  *
  * @example
  * import { collect } from "effect/ReadonlyRecord"
@@ -167,31 +155,9 @@ const collect = /*#__PURE__*/dual(2, (self, f) => {
 const toEntries = /*#__PURE__*/collect((key, value) => [key, value]);
 
 /**
- * Takes a record and returns an array of tuples containing its keys and values.
- *
- * Alias of {@link toEntries}.
- *
- * @param self - The record to transform.
- *
- * @example
- * import { toArray } from "effect/ReadonlyRecord"
- *
- * const x = { a: 1, b: 2, c: 3 }
- * assert.deepStrictEqual(toArray(x), [["a", 1], ["b", 2], ["c", 3]])
- *
- * @category conversions
- * @since 2.0.0
- */
-const toArray = toEntries;
-
-// -------------------------------------------------------------------------------------
-// utils
-// -------------------------------------------------------------------------------------
-
-/**
- * Returns the number of key/value pairs in a `ReadonlyRecord`.
+ * Returns the number of key/value pairs in a record.
  *
- * @param self - A `ReadonlyRecord` to calculate the number of key/value pairs in.
+ * @param self - A record to calculate the number of key/value pairs in.
  *
  * @example
  * import { size } from "effect/ReadonlyRecord";
@@ -203,13 +169,13 @@ const toArray = toEntries;
 const size = self => Object.keys(self).length;
 
 /**
- * Check if a given `key` exists in a `ReadonlyRecord`.
+ * Check if a given `key` exists in a record.
  *
- * @param self - the `ReadonlyRecord` to look in.
- * @param key - the key to look for in the `ReadonlyRecord`.
+ * @param self - the record to look in.
+ * @param key - the key to look for in the record.
  *
  * @example
- * import { has } from 'effect/ReadonlyRecord'
+ * import { has } from "effect/ReadonlyRecord"
  *
  * assert.deepStrictEqual(has({ a: 1, b: 2 }, "a"), true);
  * assert.deepStrictEqual(has({ a: 1, b: 2 }, "c"), false);
@@ -219,10 +185,10 @@ const size = self => Object.keys(self).length;
 const has = /*#__PURE__*/dual(2, (self, key) => Object.prototype.hasOwnProperty.call(self, key));
 
 /**
- * Retrieve a value at a particular key from a `ReadonlyRecord`, returning it wrapped in an `Option`.
+ * Retrieve a value at a particular key from a record, returning it wrapped in an `Option`.
  *
- * @param self - The `ReadonlyRecord` to retrieve value from.
- * @param key - Key to retrieve from `ReadonlyRecord`.
+ * @param self - The record to retrieve value from.
+ * @param key - Key to retrieve from record.
  *
  * @example
  * import { get } from "effect/ReadonlyRecord"
@@ -235,13 +201,13 @@ const has = /*#__PURE__*/dual(2, (self, key) => Object.prototype.hasOwnProperty.
  *
  * @since 2.0.0
  */
-const get = /*#__PURE__*/dual(2, (self, key) => has(self, key) ? some(self[key]) : none());
+const get = /*#__PURE__*/dual(2, (self, key) => has(self, key) ? some$1(self[key]) : none());
 
 /**
  * Apply a function to the element at the specified key, creating a new record,
  * or return `None` if the key doesn't exist.
  *
- * @param self - The `ReadonlyRecord` to be updated.
+ * @param self - The record to be updated.
  * @param key - The key of the element to modify.
  * @param f - The function to apply to the element.
  *
@@ -270,13 +236,13 @@ const modifyOption = /*#__PURE__*/dual(3, (self, key, f) => {
     ...self
   };
   out[key] = f(self[key]);
-  return some(out);
+  return some$1(out);
 });
 
 /**
  * Replaces a value in the record with the new value passed as parameter.
  *
- * @param self - The `ReadonlyRecord` to be updated.
+ * @param self - The record to be updated.
  * @param key - The key to search for in the record.
  * @param b - The new value to replace the existing value with.
  *
@@ -295,13 +261,13 @@ const modifyOption = /*#__PURE__*/dual(3, (self, key, f) => {
 const replaceOption = /*#__PURE__*/dual(3, (self, key, b) => modifyOption(self, key, () => b));
 
 /**
- * Removes a key from a `ReadonlyRecord` and returns a new `Record`
+ * Removes a key from a record and returns a new record
  *
- * @param self - the `ReadonlyRecord` to remove the key from.
- * @param key - the key to remove from the `ReadonlyRecord`.
+ * @param self - the record to remove the key from.
+ * @param key - the key to remove from the record.
  *
  * @example
- * import { remove } from 'effect/ReadonlyRecord'
+ * import { remove } from "effect/ReadonlyRecord"
  *
  * assert.deepStrictEqual(remove({ a: 1, b: 2 }, "a"), { b: 2 })
  *
@@ -316,15 +282,15 @@ const remove = /*#__PURE__*/dual(2, (self, key) => {
 });
 
 /**
- * Retrieves the value of the property with the given `key` from a `ReadonlyRecord` and returns an `Option`
- * of a tuple with the value and the `ReadonlyRecord` with the removed property.
+ * Retrieves the value of the property with the given `key` from a record and returns an `Option`
+ * of a tuple with the value and the record with the removed property.
  * If the key is not present, returns `O.none`.
  *
- * @param self - The input `ReadonlyRecord`.
+ * @param self - The input record.
  * @param key - The key of the property to retrieve.
  *
  * @example
- * import { pop } from 'effect/ReadonlyRecord'
+ * import { pop } from "effect/ReadonlyRecord"
  * import { some, none } from 'effect/Option'
  *
  * assert.deepStrictEqual(pop({ a: 1, b: 2 }, "a"), some([1, { b: 2 }]))
@@ -333,13 +299,13 @@ const remove = /*#__PURE__*/dual(2, (self, key) => {
  * @category record
  * @since 2.0.0
  */
-const pop = /*#__PURE__*/dual(2, (self, key) => has(self, key) ? some([self[key], remove(self, key)]) : none());
+const pop = /*#__PURE__*/dual(2, (self, key) => has(self, key) ? some$1([self[key], remove(self, key)]) : none());
 
 /**
- * Maps a `ReadonlyRecord` into another `Record` by applying a transformation function to each of its values.
+ * Maps a record into another record by applying a transformation function to each of its values.
  *
- * @param self - The `ReadonlyRecord` to be mapped.
- * @param f - A transformation function that will be applied to each of the values in the `ReadonlyRecord`.
+ * @param self - The record to be mapped.
+ * @param f - A transformation function that will be applied to each of the values in the record.
  *
  * @example
  * import { map } from "effect/ReadonlyRecord"
@@ -363,14 +329,14 @@ const map = /*#__PURE__*/dual(2, (self, f) => {
 });
 
 /**
- * Transforms a `ReadonlyRecord` into a `Record` by applying the function `f` to each key and value in the original `ReadonlyRecord`.
- * If the function returns `Some`, the key-value pair is included in the output `Record`.
+ * Transforms a record into a record by applying the function `f` to each key and value in the original record.
+ * If the function returns `Some`, the key-value pair is included in the output record.
  *
- * @param self - The input `ReadonlyRecord`.
+ * @param self - The input record.
  * @param f - The transformation function.
  *
  * @example
- * import { filterMap } from 'effect/ReadonlyRecord'
+ * import { filterMap } from "effect/ReadonlyRecord"
  * import { some, none } from 'effect/Option'
  *
  * const x = { a: 1, b: 2, c: 3 }
@@ -393,11 +359,11 @@ const filterMap = /*#__PURE__*/dual(2, (self, f) => {
 /**
  * Selects properties from a record whose values match the given predicate.
  *
- * @param self - The `ReadonlyRecord` to filter.
+ * @param self - The record to filter.
  * @param predicate - A function that returns a `boolean` value to determine if the entry should be included in the new record.
  *
  * @example
- * import { filter } from 'effect/ReadonlyRecord'
+ * import { filter } from "effect/ReadonlyRecord"
  *
  * const x = { a: 1, b: 2, c: 3, d: 4 }
  * assert.deepStrictEqual(filter(x, (n) => n > 2), { c: 3, d: 4 })
@@ -416,12 +382,12 @@ const filter = /*#__PURE__*/dual(2, (self, predicate) => {
 });
 
 /**
- * Given a `ReadonlyRecord` with `Option` values, returns a `Record` with only the `Some` values, with the same keys.
+ * Given a record with `Option` values, returns a record with only the `Some` values, with the same keys.
  *
- * @param self - A `ReadonlyRecord` with `Option` values.
+ * @param self - A record with `Option` values.
  *
  * @example
- * import { compact } from 'effect/ReadonlyRecord'
+ * import { compact } from "effect/ReadonlyRecord"
  * import { some, none } from 'effect/Option'
  *
  * assert.deepStrictEqual(
@@ -435,13 +401,13 @@ const filter = /*#__PURE__*/dual(2, (self, predicate) => {
 const compact = /*#__PURE__*/filterMap(identity);
 
 /**
- * Partitions the elements of a `ReadonlyRecord` into two groups: those that match a predicate, and those that don't.
+ * Partitions the elements of a record into two groups: those that match a predicate, and those that don't.
  *
- * @param self - The `ReadonlyRecord` to partition.
+ * @param self - The record to partition.
  * @param f - The predicate function to apply to each element.
  *
  * @example
- * import { partitionMap } from 'effect/ReadonlyRecord'
+ * import { partitionMap } from "effect/ReadonlyRecord"
  * import { left, right } from 'effect/Either'
  *
  * const x = { a: 1, b: 2, c: 3 }
@@ -466,13 +432,13 @@ const partitionMap = /*#__PURE__*/dual(2, (self, f) => {
 });
 
 /**
- * Partitions a `ReadonlyRecord` of `Either` values into two separate records,
+ * Partitions a record of `Either` values into two separate records,
  * one with the `Left` values and one with the `Right` values.
  *
- * @param self - the `ReadonlyRecord` to partition.
+ * @param self - the record to partition.
  *
  * @example
- * import { separate } from 'effect/ReadonlyRecord'
+ * import { separate } from "effect/ReadonlyRecord"
  * import { left, right } from 'effect/Either'
  *
  * assert.deepStrictEqual(
@@ -486,13 +452,13 @@ const partitionMap = /*#__PURE__*/dual(2, (self, f) => {
 const separate = /*#__PURE__*/partitionMap(identity);
 
 /**
- * Partitions a `ReadonlyRecord` into two separate `Record`s based on the result of a predicate function.
+ * Partitions a record into two separate records based on the result of a predicate function.
  *
- * @param self - The input `ReadonlyRecord` to partition.
- * @param predicate - The partitioning function to determine the partitioning of each value of the `ReadonlyRecord`.
+ * @param self - The input record to partition.
+ * @param predicate - The partitioning function to determine the partitioning of each value of the record.
  *
  * @example
- * import { partition } from 'effect/ReadonlyRecord'
+ * import { partition } from "effect/ReadonlyRecord"
  *
  * assert.deepStrictEqual(
  *   partition({ a: 1, b: 3 }, (n) => n > 2),
@@ -515,4 +481,269 @@ const partition = /*#__PURE__*/dual(2, (self, predicate) => {
   return [left, right];
 });
 
-export { collect, compact, empty, filter, filterMap, fromEntries, fromIterable, get, has, isEmptyReadonlyRecord, isEmptyRecord, map, modifyOption, partition, partitionMap, pop, remove, replaceOption, separate, size, toArray, toEntries };
+/**
+ * Retrieve the keys of a given record as an array.
+ *
+ * @param self - The object for which you want to get the keys.
+ *
+ * @since 2.0.0
+ */
+const keys = self => Object.keys(self);
+
+/**
+ * Retrieve the values of a given record as an array.
+ *
+ * @param self - The object for which you want to get the values.
+ *
+ * @since 2.0.0
+ */
+const values = self => collect(self, (_, a) => a);
+
+/**
+ * Add a new key-value pair or update an existing key's value in a record.
+ *
+ * @param self - The record to which you want to add or update a key-value pair.
+ * @param key - The key you want to add or update.
+ * @param values - The value you want to associate with the key.
+ *
+ * @example
+ * import { upsert } from "effect/ReadonlyRecord"
+ *
+ * assert.deepStrictEqual(upsert("a", 5)({ a: 1, b: 2 }), { a: 5, b: 2 });
+ * assert.deepStrictEqual(upsert("c", 5)({ a: 1, b: 2 }), { a: 1, b: 2, c: 5 });
+ *
+ * @since 2.0.0
+ */
+const upsert = /*#__PURE__*/dual(3, (self, key, value) => {
+  const out = {
+    ...self
+  };
+  out[key] = value;
+  return out;
+});
+
+/**
+ * Replace a key's value in a record and return the updated record.
+ *
+ * @param self - The original record.
+ * @param key - The key to replace.
+ * @param value - The new value to associate with the key.
+ *
+ * @example
+ * import { update } from "effect/ReadonlyRecord"
+ * import { some, none } from "effect/Option"
+ *
+ * assert.deepStrictEqual(update("a", 3)({ a: 1, b: 2 }), { a: 3, b: 2 });
+ * assert.deepStrictEqual(update("c", 3)({ a: 1, b: 2 }), { a: 1, b: 2 });
+ *
+ * @since 2.0.0
+ */
+const update = /*#__PURE__*/dual(3, (self, key, value) => {
+  const out = {
+    ...self
+  };
+  if (has(self, key)) {
+    out[key] = value;
+  }
+  return out;
+});
+
+/**
+ * Check if all the keys and values in one record are also found in another record.
+ *
+ * @param self - The first record to check.
+ * @param that - The second record to compare against.
+ * @param equivalence - A function to compare values.
+ *
+ * @since 2.0.0
+ */
+const isSubrecordBy = equivalence => dual(2, (self, that) => {
+  for (const key in self) {
+    if (!has(that, key) || !equivalence(self[key], that[key])) {
+      return false;
+    }
+  }
+  return true;
+});
+
+/**
+ * Check if one record is a subrecord of another, meaning it contains all the keys and values found in the second record.
+ * This comparison uses default equality checks (`Equal.equivalence()`).
+ *
+ * @param self - The first record to check.
+ * @param that - The second record to compare against.
+ *
+ * @since 2.0.0
+ */
+const isSubrecord = /*#__PURE__*/isSubrecordBy( /*#__PURE__*/equivalence());
+
+/**
+ * Reduce a record to a single value by combining its entries with a specified function.
+ *
+ * @param self - The record to reduce.
+ * @param zero - The initial value of the accumulator.
+ * @param f - The function to combine entries (accumulator, value, key).
+ *
+ * @category folding
+ * @since 2.0.0
+ */
+const reduce = /*#__PURE__*/dual(3, (self, zero, f) => {
+  let out = zero;
+  for (const key in self) {
+    out = f(out, self[key], key);
+  }
+  return out;
+});
+
+/**
+ * Check if all entries in a record meet a specific condition.
+ *
+ * @param self - The record to check.
+ * @param predicate - The condition to test entries (value, key).
+ *
+ * @since 2.0.0
+ */
+const every = /*#__PURE__*/dual(2, (self, predicate) => {
+  for (const key in self) {
+    if (!predicate(self[key], key)) {
+      return false;
+    }
+  }
+  return true;
+});
+
+/**
+ * Check if any entry in a record meets a specific condition.
+ *
+ * @param self - The record to check.
+ * @param predicate - The condition to test entries (value, key).
+ *
+ * @since 2.0.0
+ */
+const some = /*#__PURE__*/dual(2, (self, predicate) => {
+  for (const key in self) {
+    if (predicate(self[key], key)) {
+      return true;
+    }
+  }
+  return false;
+});
+
+/**
+ * Merge two records, preserving entries that exist in either of the records.
+ *
+ * @param self - The first record.
+ * @param that - The second record to combine with the first.
+ * @param combine - A function to specify how to merge entries with the same key.
+ *
+ * @since 2.0.0
+ */
+const union = /*#__PURE__*/dual(3, (self, that, combine) => {
+  if (isEmptyRecord(self)) {
+    return {
+      ...that
+    };
+  }
+  if (isEmptyRecord(that)) {
+    return {
+      ...self
+    };
+  }
+  const out = {};
+  for (const key in self) {
+    if (has(that, key)) {
+      out[key] = combine(self[key], that[key]);
+    } else {
+      out[key] = self[key];
+    }
+  }
+  for (const key in that) {
+    if (!has(out, key)) {
+      out[key] = that[key];
+    }
+  }
+  return out;
+});
+
+/**
+ * Merge two records, retaining only the entries that exist in both records.
+ *
+ * @param self - The first record.
+ * @param that - The second record to merge with the first.
+ * @param combine - A function to specify how to merge entries with the same key.
+ *
+ * @since 2.0.0
+ */
+const intersection = /*#__PURE__*/dual(3, (self, that, combine) => {
+  if (isEmptyRecord(self) || isEmptyRecord(that)) {
+    return empty();
+  }
+  const out = {};
+  for (const key in self) {
+    if (has(that, key)) {
+      out[key] = combine(self[key], that[key]);
+    }
+  }
+  return out;
+});
+
+/**
+ * Merge two records, preserving only the entries that are unique to each record.
+ *
+ * @param self - The first record.
+ * @param that - The second record to compare with the first.
+ *
+ * @since 2.0.0
+ */
+const difference = /*#__PURE__*/dual(2, (self, that) => {
+  if (isEmptyRecord(self)) {
+    return {
+      ...that
+    };
+  }
+  if (isEmptyRecord(that)) {
+    return {
+      ...self
+    };
+  }
+  const out = {};
+  for (const key in self) {
+    if (!has(that, key)) {
+      out[key] = self[key];
+    }
+  }
+  for (const key in that) {
+    if (!has(self, key)) {
+      out[key] = that[key];
+    }
+  }
+  return out;
+});
+
+/**
+ * Create an `Equivalence` for records using the provided `Equivalence` for values.
+ *
+ * @param equivalence - An `Equivalence` for the values contained in the records.
+ *
+ * @category instances
+ * @since 2.0.0
+ */
+const getEquivalence = equivalence => {
+  const is = isSubrecordBy(equivalence);
+  return (self, that) => is(self, that) && is(that, self);
+};
+
+/**
+ * Create a non-empty record from a single element.
+ *
+ * @param key - The key for the element.
+ * @param value - The value associated with the key.
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+const singleton = (key, value) => ({
+  [key]: value
+});
+
+export { collect, compact, difference, empty, every, filter, filterMap, fromEntries, fromIterable, get, getEquivalence, has, intersection, isEmptyReadonlyRecord, isEmptyRecord, isSubrecord, isSubrecordBy, keys, map, modifyOption, partition, partitionMap, pop, reduce, remove, replaceOption, separate, singleton, size, some, toEntries, union, update, upsert, values };

package/RedBlackTree/dist/effect-RedBlackTree.cjs.dev.js

@@ -22,7 +22,6 @@ require('../../Utils/dist/effect-Utils.cjs.dev.js');
 require('../../GlobalValue/dist/effect-GlobalValue.cjs.dev.js');
 require('../../dist/ReadonlyArray-9a1474f6.cjs.dev.js');
 require('../../ReadonlyRecord/dist/effect-ReadonlyRecord.cjs.dev.js');
-require('../../Number/dist/effect-Number.cjs.dev.js');
 
 /** @internal */
 const Direction$1 = {

package/RedBlackTree/dist/effect-RedBlackTree.cjs.prod.js

@@ -22,7 +22,6 @@ require('../../Utils/dist/effect-Utils.cjs.prod.js');
 require('../../GlobalValue/dist/effect-GlobalValue.cjs.prod.js');
 require('../../dist/ReadonlyArray-f9ed7a05.cjs.prod.js');
 require('../../ReadonlyRecord/dist/effect-ReadonlyRecord.cjs.prod.js');
-require('../../Number/dist/effect-Number.cjs.prod.js');
 
 /** @internal */
 const Direction$1 = {

package/Ref/dist/effect-Ref.cjs.dev.js

@@ -2,9 +2,9 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var Ref_dist_effectRef = require('../../dist/Ref-c75b5362.cjs.dev.js');
+var Ref_dist_effectRef = require('../../dist/Ref-f990026b.cjs.dev.js');
 require('../../Function/dist/effect-Function.cjs.dev.js');
-require('../../dist/core-6815193e.cjs.dev.js');
+require('../../dist/core-b4bf44d3.cjs.dev.js');
 require('../../Chunk/dist/effect-Chunk.cjs.dev.js');
 require('../../Equal/dist/effect-Equal.cjs.dev.js');
 require('../../Hash/dist/effect-Hash.cjs.dev.js');
@@ -18,7 +18,6 @@ require('../../dist/Either-e7500e90.cjs.dev.js');
 require('../../dist/Option-01caa9d4.cjs.dev.js');
 require('../../dist/Effectable-71c10ab9.cjs.dev.js');
 require('../../Pipeable/dist/effect-Pipeable.cjs.dev.js');
-require('../../Number/dist/effect-Number.cjs.dev.js');
 require('../../Order/dist/effect-Order.cjs.dev.js');
 require('../../ReadonlyArray/dist/effect-ReadonlyArray.cjs.dev.js');
 require('../../Either/dist/effect-Either.cjs.dev.js');
@@ -28,13 +27,13 @@ require('../../Context/dist/effect-Context.cjs.dev.js');
 require('../../dist/Context-607e9b4c.cjs.dev.js');
 require('../../Differ/dist/effect-Differ.cjs.dev.js');
 require('../../HashMap/dist/effect-HashMap.cjs.dev.js');
-require('../../dist/HashSet-dd020cb0.cjs.dev.js');
+require('../../dist/HashSet-c12c037b.cjs.dev.js');
 require('../../dist/Stack-ada2d201.cjs.dev.js');
 require('../../HashSet/dist/effect-HashSet.cjs.dev.js');
-require('../../dist/FiberId-6708cdca.cjs.dev.js');
+require('../../dist/FiberId-6595cf4c.cjs.dev.js');
 require('../../MutableRef/dist/effect-MutableRef.cjs.dev.js');
 require('../../List/dist/effect-List.cjs.dev.js');
-require('../../dist/RuntimeFlagsPatch-9cbc441d.cjs.dev.js');
+require('../../dist/RuntimeFlagsPatch-7d62915d.cjs.dev.js');