@clayroach/effect 3.19.14-source-capture.6 → 3.19.14-source-capture.8

package/src/index.ts

@@ -1,1561 +0,0 @@
-/**
- * @since 2.0.0
- */
-
-export {
-  /**
-   * @since 2.0.0
-   */
-  absurd,
-  /**
-   * @since 2.0.0
-   */
-  flow,
-  /**
-   * @since 2.0.0
-   */
-  hole,
-  /**
-   * @since 2.0.0
-   */
-  identity,
-  /**
-   * @since 2.0.0
-   */
-  pipe,
-  /**
-   * @since 2.0.0
-   */
-  unsafeCoerce
-} from "./Function.js"
-
-/**
- * @since 3.10.0
- */
-export * as Arbitrary from "./Arbitrary.js"
-
-/**
- * This module provides utility functions for working with arrays in TypeScript.
- *
- * @since 2.0.0
- */
-export * as Array from "./Array.js"
-
-/**
- * This module provides utility functions and type class instances for working with the `BigDecimal` type in TypeScript.
- * It includes functions for basic arithmetic operations, as well as type class instances for `Equivalence` and `Order`.
- *
- * A `BigDecimal` allows storing any real number to arbitrary precision; which avoids common floating point errors
- * (such as 0.1 + 0.2 ≠ 0.3) at the cost of complexity.
- *
- * Internally, `BigDecimal` uses a `BigInt` object, paired with a 64-bit integer which determines the position of the
- * decimal point. Therefore, the precision *is not* actually arbitrary, but limited to 2<sup>63</sup> decimal places.
- *
- * It is not recommended to convert a floating point number to a decimal directly, as the floating point representation
- * may be unexpected.
- *
- * @module BigDecimal
- * @since 2.0.0
- * @see {@link module:BigInt} for more similar operations on `bigint` types
- * @see {@link module:Number} for more similar operations on `number` types
- */
-export * as BigDecimal from "./BigDecimal.js"
-
-/**
- * This module provides utility functions and type class instances for working with the `bigint` type in TypeScript.
- * It includes functions for basic arithmetic operations, as well as type class instances for
- * `Equivalence` and `Order`.
- *
- * @module BigInt
- * @since 2.0.0
- * @see {@link module:BigDecimal} for more similar operations on `BigDecimal` types
- * @see {@link module:Number} for more similar operations on `number` types
- */
-export * as BigInt from "./BigInt.js"
-
-/**
- * This module provides utility functions and type class instances for working with the `boolean` type in TypeScript.
- * It includes functions for basic boolean operations, as well as type class instances for
- * `Equivalence` and `Order`.
- *
- * @since 2.0.0
- */
-export * as Boolean from "./Boolean.js"
-
-/**
- * This module provides types and utility functions to create and work with branded types,
- * which are TypeScript types with an added type tag to prevent accidental usage of a value in the wrong context.
- *
- * The `refined` and `nominal` functions are both used to create branded types in TypeScript.
- * The main difference between them is that `refined` allows for validation of the data, while `nominal` does not.
- *
- * The `nominal` function is used to create a new branded type that has the same underlying type as the input, but with a different name.
- * This is useful when you want to distinguish between two values of the same type that have different meanings.
- * The `nominal` function does not perform any validation of the input data.
- *
- * On the other hand, the `refined` function is used to create a new branded type that has the same underlying type as the input,
- * but with a different name, and it also allows for validation of the input data.
- * The `refined` function takes a predicate that is used to validate the input data.
- * If the input data fails the validation, a `BrandErrors` is returned, which provides information about the specific validation failure.
- *
- * @since 2.0.0
- */
-export * as Brand from "./Brand.js"
-
-/**
- * @since 2.0.0
- */
-export * as Cache from "./Cache.js"
-
-/**
- * The `Effect<A, E, R>` type is polymorphic in values of type `E` and we can
- * work with any error type that we want. However, there is a lot of information
- * that is not inside an arbitrary `E` value. So as a result, an `Effect` needs
- * somewhere to store things like unexpected errors or defects, stack and
- * execution traces, causes of fiber interruptions, and so forth.
- *
- * Effect-TS is very strict about preserving the full information related to a
- * failure. It captures all type of errors into the `Cause` data type. `Effect`
- * uses the `Cause<E>` data type to store the full story of failure. So its
- * error model is lossless. It doesn't throw information related to the failure
- * result. So we can figure out exactly what happened during the operation of
- * our effects.
- *
- * It is important to note that `Cause` is an underlying data type representing
- * errors occuring within an `Effect` workflow. Thus, we don't usually deal with
- * `Cause`s directly. Even though it is not a data type that we deal with very
- * often, the `Cause` of a failing `Effect` workflow can be accessed at any
- * time, which gives us total access to all parallel and sequential errors in
- * occurring within our codebase.
- *
- * @since 2.0.0
- */
-export * as Cause from "./Cause.js"
-
-/**
- * @since 2.0.0
- */
-export * as Channel from "./Channel.js"
-
-/**
- * @since 2.0.0
- */
-export * as ChildExecutorDecision from "./ChildExecutorDecision.js"
-
-/**
- * @since 2.0.0
- */
-export * as Chunk from "./Chunk.js"
-
-/**
- * @since 2.0.0
- */
-export * as Clock from "./Clock.js"
-
-/**
- * @since 2.0.0
- */
-export * as Config from "./Config.js"
-
-/**
- * @since 2.0.0
- */
-export * as ConfigError from "./ConfigError.js"
-
-/**
- * @since 2.0.0
- */
-export * as ConfigProvider from "./ConfigProvider.js"
-
-/**
- * @since 2.0.0
- */
-export * as ConfigProviderPathPatch from "./ConfigProviderPathPatch.js"
-
-/**
- * @since 2.0.0
- */
-export * as Console from "./Console.js"
-
-/**
- * This module provides a data structure called `Context` that can be used for dependency injection in effectful
- * programs. It is essentially a table mapping `Tag`s to their implementations (called `Service`s), and can be used to
- * manage dependencies in a type-safe way. The `Context` data structure is essentially a way of providing access to a set
- * of related services that can be passed around as a single unit. This module provides functions to create, modify, and
- * query the contents of a `Context`, as well as a number of utility types for working with tags and services.
- *
- * @since 2.0.0
- */
-export * as Context from "./Context.js"
-
-/**
- * @since 2.0.0
- */
-export * as Cron from "./Cron.js"
-
-/**
- * @since 2.0.0
- */
-export * as Data from "./Data.js"
-
-/**
- * @since 3.6.0
- */
-export * as DateTime from "./DateTime.js"
-
-/**
- * @since 2.0.0
- */
-export * as DefaultServices from "./DefaultServices.js"
-
-/**
- * @since 2.0.0
- */
-export * as Deferred from "./Deferred.js"
-
-/**
- * @since 2.0.0
- */
-export * as Differ from "./Differ.js"
-
-/**
- * @since 2.0.0
- */
-export * as Duration from "./Duration.js"
-
-/**
- * @since 2.0.0
- */
-export * as Effect from "./Effect.js"
-
-/**
- * @since 2.0.0
- */
-export * as Effectable from "./Effectable.js"
-
-/**
- * @since 2.0.0
- */
-export * as Either from "./Either.js"
-
-/**
- * This module provides encoding & decoding functionality for:
- *
- * - base64 (RFC4648)
- * - base64 (URL)
- * - hex
- *
- * @since 2.0.0
- */
-export * as Encoding from "./Encoding.js"
-
-/**
- * @since 2.0.0
- */
-export * as Equal from "./Equal.js"
-
-/**
- * This module provides an implementation of the `Equivalence` type class, which defines a binary relation
- * that is reflexive, symmetric, and transitive. In other words, it defines a notion of equivalence between values of a certain type.
- * These properties are also known in mathematics as an "equivalence relation".
- *
- * @since 2.0.0
- */
-export * as Equivalence from "./Equivalence.js"
-
-/**
- * @since 3.16.0
- * @experimental
- */
-export * as ExecutionPlan from "./ExecutionPlan.js"
-
-/**
- * @since 2.0.0
- */
-export * as ExecutionStrategy from "./ExecutionStrategy.js"
-
-/**
- * @since 2.0.0
- */
-export * as Exit from "./Exit.js"
-
-/**
- * @since 3.10.0
- */
-export * as FastCheck from "./FastCheck.js"
-
-/**
- * @since 2.0.0
- */
-export * as Fiber from "./Fiber.js"
-
-/**
- * @since 2.0.0
- */
-export * as FiberHandle from "./FiberHandle.js"
-
-/**
- * @since 2.0.0
- */
-export * as FiberId from "./FiberId.js"
-
-/**
- * @since 2.0.0
- */
-export * as FiberMap from "./FiberMap.js"
-
-/**
- * @since 2.0.0
- */
-export * as FiberRef from "./FiberRef.js"
-
-/**
- * @since 2.0.0
- */
-export * as FiberRefs from "./FiberRefs.js"
-
-/**
- * @since 2.0.0
- */
-export * as FiberRefsPatch from "./FiberRefsPatch.js"
-
-/**
- * @since 2.0.0
- */
-export * as FiberSet from "./FiberSet.js"
-
-/**
- * @since 2.0.0
- */
-export * as FiberStatus from "./FiberStatus.js"
-
-/**
- * @since 2.0.0
- */
-export * as Function from "./Function.js"
-
-/**
- * The `GlobalValue` module ensures that a single instance of a value is created globally,
- * even when modules are imported multiple times (e.g., due to mixing CommonJS and ESM builds)
- * or during hot-reloading in development environments like Next.js or Remix.
- *
- * It achieves this by using a versioned global store, identified by a unique `Symbol` tied to
- * the current version of the `effect` library. The store holds values that are keyed by an identifier,
- * allowing the reuse of previously computed instances across imports or reloads.
- *
- * This pattern is particularly useful in scenarios where frequent reloading can cause services or
- * single-instance objects to be recreated unnecessarily, such as in development environments with hot-reloading.
- *
- * @since 2.0.0
- */
-export * as GlobalValue from "./GlobalValue.js"
-
-/**
- * @experimental
- * @since 3.18.0
- */
-export * as Graph from "./Graph.js"
-
-/**
- * @since 2.0.0
- */
-export * as GroupBy from "./GroupBy.js"
-
-/**
- * @since 2.0.0
- */
-export * as HKT from "./HKT.js"
-
-/**
- * @since 2.0.0
- */
-export * as Hash from "./Hash.js"
-
-/**
- * @since 2.0.0
- */
-export * as HashMap from "./HashMap.js"
-
-/**
- * @since 3.19.0
- * @experimental
- */
-export * as HashRing from "./HashRing.js"
-
-/**
- * # HashSet
- *
- * An immutable `HashSet` provides a collection of unique values with efficient
- * lookup, insertion and removal. Once created, a `HashSet` cannot be modified;
- * any operation that would alter the set instead returns a new `HashSet` with
- * the changes. This immutability offers benefits like predictable state
- * management and easier reasoning about your code.
- *
- * ## What Problem Does It Solve?
- *
- * `HashSet` solves the problem of maintaining an unsorted collection where each
- * value appears exactly once, with fast operations for checking membership and
- * adding/removing values.
- *
- * ## When to Use
- *
- * Use `HashSet` when you need:
- *
- * - A collection with no duplicate values
- * - Efficient membership testing (**`O(1)`** average complexity)
- * - Set operations like union, intersection, and difference
- * - An immutable data structure that preserves functional programming patterns
- *
- * ## Advanced Features
- *
- * HashSet provides operations for:
- *
- * - Transforming sets with map and flatMap
- * - Filtering elements with filter
- * - Combining sets with union, intersection and difference
- * - Performance optimizations via mutable operations in controlled contexts
- *
- * ## Performance Characteristics
- *
- * - **Lookup** operations ({@link module:HashSet.has}): **`O(1)`** average time
- *   complexity
- * - **Insertion** operations ({@link module:HashSet.add}): **`O(1)`** average time
- *   complexity
- * - **Removal** operations ({@link module:HashSet.remove}): **`O(1)`** average
- *   time complexity
- * - **Set** operations ({@link module:HashSet.union},
- *   {@link module:HashSet.intersection}): **`O(n)`** where n is the size of the
- *   smaller set
- * - **Iteration**: **`O(n)`** where n is the size of the set
- *
- * The HashSet data structure implements the following traits:
- *
- * - {@link Iterable}: allows iterating over the values in the set
- * - {@link Equal}: allows comparing two sets for value-based equality
- * - {@link Pipeable}: allows chaining operations with the pipe operator
- * - {@link Inspectable}: allows inspecting the contents of the set
- *
- * ## Operations Reference
- *
- * | Category     | Operation                           | Description                                 | Complexity |
- * | ------------ | ----------------------------------- | ------------------------------------------- | ---------- |
- * | constructors | {@link module:HashSet.empty}        | Creates an empty HashSet                    | O(1)       |
- * | constructors | {@link module:HashSet.fromIterable} | Creates a HashSet from an iterable          | O(n)       |
- * | constructors | {@link module:HashSet.make}         | Creates a HashSet from multiple values      | O(n)       |
- * |              |                                     |                                             |            |
- * | elements     | {@link module:HashSet.has}          | Checks if a value exists in the set         | O(1) avg   |
- * | elements     | {@link module:HashSet.some}         | Checks if any element satisfies a predicate | O(n)       |
- * | elements     | {@link module:HashSet.every}        | Checks if all elements satisfy a predicate  | O(n)       |
- * | elements     | {@link module:HashSet.isSubset}     | Checks if a set is a subset of another      | O(n)       |
- * |              |                                     |                                             |            |
- * | getters      | {@link module:HashSet.values}       | Gets an iterator of all values              | O(1)       |
- * | getters      | {@link module:HashSet.toValues}     | Gets an array of all values                 | O(n)       |
- * | getters      | {@link module:HashSet.size}         | Gets the number of elements                 | O(1)       |
- * |              |                                     |                                             |            |
- * | mutations    | {@link module:HashSet.add}          | Adds a value to the set                     | O(1) avg   |
- * | mutations    | {@link module:HashSet.remove}       | Removes a value from the set                | O(1) avg   |
- * | mutations    | {@link module:HashSet.toggle}       | Toggles a value's presence                  | O(1) avg   |
- * |              |                                     |                                             |            |
- * | operations   | {@link module:HashSet.difference}   | Computes set difference (A - B)             | O(n)       |
- * | operations   | {@link module:HashSet.intersection} | Computes set intersection (A ∩ B)           | O(n)       |
- * | operations   | {@link module:HashSet.union}        | Computes set union (A ∪ B)                  | O(n)       |
- * |              |                                     |                                             |            |
- * | mapping      | {@link module:HashSet.map}          | Transforms each element                     | O(n)       |
- * |              |                                     |                                             |            |
- * | sequencing   | {@link module:HashSet.flatMap}      | Transforms and flattens elements            | O(n)       |
- * |              |                                     |                                             |            |
- * | traversing   | {@link module:HashSet.forEach}      | Applies a function to each element          | O(n)       |
- * |              |                                     |                                             |            |
- * | folding      | {@link module:HashSet.reduce}       | Reduces the set to a single value           | O(n)       |
- * |              |                                     |                                             |            |
- * | filtering    | {@link module:HashSet.filter}       | Keeps elements that satisfy a predicate     | O(n)       |
- * |              |                                     |                                             |            |
- * | partitioning | {@link module:HashSet.partition}    | Splits into two sets by a predicate         | O(n)       |
- *
- * ## Notes
- *
- * ### Composability with the Effect Ecosystem:
- *
- * This `HashSet` is designed to work seamlessly within the Effect ecosystem. It
- * implements the {@link Iterable}, {@link Equal}, {@link Pipeable}, and
- * {@link Inspectable} traits from Effect. This ensures compatibility with other
- * Effect data structures and functionalities. For example, you can easily use
- * Effect's `pipe` method to chain operations on the `HashSet`.
- *
- * **Equality of Elements with Effect's {@link Equal `Equal`} Trait:**
- *
- * This `HashSet` relies on Effect's {@link Equal} trait to determine the
- * uniqueness of elements within the set. The way equality is checked depends on
- * the type of the elements:
- *
- * - **Primitive Values:** For primitive JavaScript values like strings, numbers,
- *   booleans, `null`, and `undefined`, equality is determined by their value
- *   (similar to the `===` operator).
- * - **Objects and Custom Types:** For objects and other custom types, equality is
- *   determined by whether those types implement the {@link Equal} interface
- *   themselves. If an element type implements `Equal`, the `HashSet` will
- *   delegate to that implementation to perform the equality check. This allows
- *   you to define custom logic for determining when two instances of your
- *   objects should be considered equal based on their properties, rather than
- *   just their object identity.
- *
- * ```ts
- * import { Equal, Hash, HashSet } from "effect"
- *
- * class Person implements Equal.Equal {
- *   constructor(
- *     readonly id: number, // Unique identifier
- *     readonly name: string,
- *     readonly age: number
- *   ) {}
- *
- *   // Define equality based on id, name, and age
- *   [Equal.symbol](that: Equal.Equal): boolean {
- *     if (that instanceof Person) {
- *       return (
- *         Equal.equals(this.id, that.id) &&
- *         Equal.equals(this.name, that.name) &&
- *         Equal.equals(this.age, that.age)
- *       )
- *     }
- *     return false
- *   }
- *
- *   // Generate a hash code based on the unique id
- *   [Hash.symbol](): number {
- *     return Hash.hash(this.id)
- *   }
- * }
- *
- * // Creating a HashSet with objects that implement the Equal interface
- * const set = HashSet.empty().pipe(
- *   HashSet.add(new Person(1, "Alice", 30)),
- *   HashSet.add(new Person(1, "Alice", 30))
- * )
- *
- * // HashSet recognizes them as equal, so only one element is stored
- * console.log(HashSet.size(set))
- * // Output: 1
- * ```
- *
- * **Simplifying Equality and Hashing with `Data` and `Schema`:**
- *
- * Effect's {@link Data} and {@link Schema `Schema.Data`} modules offer powerful
- * ways to automatically handle the implementation of both the {@link Equal} and
- * {@link Hash} traits for your custom data structures.
- *
- * - **`Data` Module:** By using constructors like `Data.struct`, `Data.tuple`,
- *   `Data.array`, or `Data.case` to define your data types, Effect
- *   automatically generates the necessary implementations for value-based
- *   equality and consistent hashing. This significantly reduces boilerplate and
- *   ensures correctness.
- *
- * ```ts
- * import { HashSet, Data, Equal } from "effect"
- * import assert from "node:assert/strict"
- *
- * // Data.* implements the `Equal` traits for us
- * const person1 = Data.struct({ id: 1, name: "Alice", age: 30 })
- * const person2 = Data.struct({ id: 1, name: "Alice", age: 30 })
- *
- * assert(Equal.equals(person1, person2))
- *
- * const set = HashSet.empty().pipe(
- *   HashSet.add(person1),
- *   HashSet.add(person2)
- * )
- *
- * // HashSet recognizes them as equal, so only one element is stored
- * console.log(HashSet.size(set)) // Output: 1
- * ```
- *
- * - **`Schema` Module:** When defining data schemas using the {@link Schema}
- *   module, you can use `Schema.Data` to automatically include the `Equal` and
- *   `Hash` traits in the decoded objects. This is particularly important when
- *   working with `HashSet`. **For decoded objects to be correctly recognized as
- *   equal within a `HashSet`, ensure that the schema for those objects is
- *   defined using `Schema.Data`.**
- *
- * ```ts
- * import { Equal, HashSet, Schema } from "effect"
- * import assert from "node:assert/strict"
- *
- * // Schema.Data implements the `Equal` traits for us
- * const PersonSchema = Schema.Data(
- *   Schema.Struct({
- *     id: Schema.Number,
- *     name: Schema.String,
- *     age: Schema.Number
- *   })
- * )
- *
- * const Person = Schema.decode(PersonSchema)
- *
- * const person1 = Person({ id: 1, name: "Alice", age: 30 })
- * const person2 = Person({ id: 1, name: "Alice", age: 30 })
- *
- * assert(Equal.equals(person1, person2)) // Output: true
- *
- * const set = HashSet.empty().pipe(
- *   HashSet.add(person1),
- *   HashSet.add(person2)
- * )
- *
- * // HashSet thanks to Schema.Data implementation of the `Equal` trait, recognizes the two Person as equal, so only one element is stored
- * console.log(HashSet.size(set)) // Output: 1
- * ```
- *
- * ### Interoperability with the JavaScript Runtime:
- *
- * To interoperate with the regular JavaScript runtime, Effect's `HashSet`
- * provides methods to access its elements in formats readily usable by
- * JavaScript APIs: {@link values `HashSet.values`},
- * {@link toValues `HashSet.toValues`}
- *
- * ```ts
- * import { HashSet } from "effect"
- *
- * const hashSet: HashSet.HashSet<number> = HashSet.make(1, 2, 3)
- *
- * // Using HashSet.values to convert HashSet.HashSet<A> to IterableIterator<A>
- * const iterable: IterableIterator<number> = HashSet.values(hashSet)
- *
- * console.log(...iterable) // Logs:  1 2 3
- *
- * // Using HashSet.toValues to convert HashSet.HashSet<A> to Array<A>
- * const array: Array<number> = HashSet.toValues(hashSet)
- *
- * console.log(array) // Logs: [ 1, 2, 3 ]
- * ```
- *
- * Be mindful of performance implications (both time and space complexity) when
- * frequently converting between Effect's immutable HashSet and mutable
- * JavaScript data structures, especially for large collections.
- *
- * @module HashSet
- * @since 2.0.0
- */
-export * as HashSet from "./HashSet.js"
-
-/**
- * @since 2.0.0
- */
-export * as Inspectable from "./Inspectable.js"
-
-/**
- * This module provides utility functions for working with Iterables in TypeScript.
- *
- * @since 2.0.0
- */
-export * as Iterable from "./Iterable.js"
-
-/**
- * @since 3.10.0
- */
-export * as JSONSchema from "./JSONSchema.js"
-
-/**
- * @since 2.0.0
- */
-export * as KeyedPool from "./KeyedPool.js"
-
-/**
- * A `Layer<ROut, E, RIn>` describes how to build one or more services in your
- * application. Services can be injected into effects via
- * `Effect.provideService`. Effects can require services via `Effect.service`.
- *
- * Layer can be thought of as recipes for producing bundles of services, given
- * their dependencies (other services).
- *
- * Construction of services can be effectful and utilize resources that must be
- * acquired and safely released when the services are done being utilized.
- *
- * By default layers are shared, meaning that if the same layer is used twice
- * the layer will only be allocated a single time.
- *
- * Because of their excellent composition properties, layers are the idiomatic
- * way in Effect-TS to create services that depend on other services.
- *
- * @since 2.0.0
- */
-export * as Layer from "./Layer.js"
-
-/**
- * @since 3.14.0
- * @experimental
- */
-export * as LayerMap from "./LayerMap.js"
-
-/**
- * A data type for immutable linked lists representing ordered collections of elements of type `A`.
- *
- * This data type is optimal for last-in-first-out (LIFO), stack-like access patterns. If you need another access pattern, for example, random access or FIFO, consider using a collection more suited to this than `List`.
- *
- * **Performance**
- *
- * - Time: `List` has `O(1)` prepend and head/tail access. Most other operations are `O(n)` on the number of elements in the list. This includes the index-based lookup of elements, `length`, `append` and `reverse`.
- * - Space: `List` implements structural sharing of the tail list. This means that many operations are either zero- or constant-memory cost.
- *
- * @since 2.0.0
- */
-export * as List from "./List.js"
-
-/**
- * @since 2.0.0
- */
-export * as LogLevel from "./LogLevel.js"
-
-/**
- * @since 2.0.0
- */
-export * as LogSpan from "./LogSpan.js"
-
-/**
- * @since 2.0.0
- */
-export * as Logger from "./Logger.js"
-
-/**
- * @since 3.8.0
- * @experimental
- */
-export * as Mailbox from "./Mailbox.js"
-
-/**
- * @since 2.0.0
- */
-export * as ManagedRuntime from "./ManagedRuntime.js"
-
-/**
- * The `effect/match` module provides a type-safe pattern matching system for
- * TypeScript. Inspired by functional programming, it simplifies conditional
- * logic by replacing verbose if/else or switch statements with a structured and
- * expressive API.
- *
- * This module supports matching against types, values, and discriminated unions
- * while enforcing exhaustiveness checking to ensure all cases are handled.
- *
- * Although pattern matching is not yet a native JavaScript feature,
- * `effect/match` offers a reliable implementation that is available today.
- *
- * **How Pattern Matching Works**
- *
- * Pattern matching follows a structured process:
- *
- * - **Creating a matcher**: Define a `Matcher` that operates on either a
- *   specific `Match.type` or `Match.value`.
- *
- * - **Defining patterns**: Use combinators such as `Match.when`, `Match.not`,
- *   and `Match.tag` to specify matching conditions.
- *
- * - **Completing the match**: Apply a finalizer such as `Match.exhaustive`,
- *   `Match.orElse`, or `Match.option` to determine how unmatched cases should
- *   be handled.
- *
- * @since 1.0.0
- */
-export * as Match from "./Match.js"
-
-/**
- * @since 2.0.0
- */
-export * as MergeDecision from "./MergeDecision.js"
-
-/**
- * @since 2.0.0
- */
-export * as MergeState from "./MergeState.js"
-
-/**
- * @since 2.0.0
- */
-export * as MergeStrategy from "./MergeStrategy.js"
-
-/**
- * @since 2.0.0
- */
-export * as Metric from "./Metric.js"
-
-/**
- * @since 2.0.0
- */
-export * as MetricBoundaries from "./MetricBoundaries.js"
-
-/**
- * @since 2.0.0
- */
-export * as MetricHook from "./MetricHook.js"
-
-/**
- * @since 2.0.0
- */
-export * as MetricKey from "./MetricKey.js"
-
-/**
- * @since 2.0.0
- */
-export * as MetricKeyType from "./MetricKeyType.js"
-
-/**
- * @since 2.0.0
- */
-export * as MetricLabel from "./MetricLabel.js"
-
-/**
- * @since 2.0.0
- */
-export * as MetricPair from "./MetricPair.js"
-
-/**
- * @since 2.0.0
- */
-export * as MetricPolling from "./MetricPolling.js"
-
-/**
- * @since 2.0.0
- */
-export * as MetricRegistry from "./MetricRegistry.js"
-
-/**
- * @since 2.0.0
- */
-export * as MetricState from "./MetricState.js"
-
-/**
- * A lightweight alternative to the `Effect` data type, with a subset of the functionality.
- *
- * @since 3.4.0
- * @experimental
- */
-export * as Micro from "./Micro.js"
-
-/**
- * @since 2.0.0
- *
- * Enables low level framework authors to run on their own isolated effect version
- */
-export * as ModuleVersion from "./ModuleVersion.js"
-
-/**
- * @since 2.0.0
- */
-export * as MutableHashMap from "./MutableHashMap.js"
-
-/**
- * # MutableHashSet
- *
- * A mutable `MutableHashSet` provides a collection of unique values with
- * efficient lookup, insertion and removal. Unlike its immutable sibling
- * {@link module:HashSet}, a `MutableHashSet` can be modified in-place;
- * operations like add, remove, and clear directly modify the original set
- * rather than creating a new one. This mutability offers benefits like improved
- * performance in scenarios where you need to build or modify a set
- * incrementally.
- *
- * ## What Problem Does It Solve?
- *
- * `MutableHashSet` solves the problem of maintaining an unsorted collection
- * where each value appears exactly once, with fast operations for checking
- * membership and adding/removing values, in contexts where mutability is
- * preferred for performance or implementation simplicity.
- *
- * ## When to Use
- *
- * Use `MutableHashSet` when you need:
- *
- * - A collection with no duplicate values
- * - Efficient membership testing (**`O(1)`** average complexity)
- * - In-place modifications for better performance
- * - A set that will be built or modified incrementally
- * - Local mutability in otherwise immutable code
- *
- * ## Advanced Features
- *
- * MutableHashSet provides operations for:
- *
- * - Adding and removing elements with direct mutation
- * - Checking for element existence
- * - Clearing all elements at once
- * - Converting to/from other collection types
- *
- * ## Performance Characteristics
- *
- * - **Lookup** operations ({@link module:MutableHashSet.has}): **`O(1)`** average
- *   time complexity
- * - **Insertion** operations ({@link module:MutableHashSet.add}): **`O(1)`**
- *   average time complexity
- * - **Removal** operations ({@link module:MutableHashSet.remove}): **`O(1)`**
- *   average time complexity
- * - **Iteration**: **`O(n)`** where n is the size of the set
- *
- * The MutableHashSet data structure implements the following traits:
- *
- * - {@link Iterable}: allows iterating over the values in the set
- * - {@link Pipeable}: allows chaining operations with the pipe operator
- * - {@link Inspectable}: allows inspecting the contents of the set
- *
- * ## Operations Reference
- *
- * | Category     | Operation                                  | Description                         | Complexity |
- * | ------------ | ------------------------------------------ | ----------------------------------- | ---------- |
- * | constructors | {@link module:MutableHashSet.empty}        | Creates an empty MutableHashSet     | O(1)       |
- * | constructors | {@link module:MutableHashSet.fromIterable} | Creates a set from an iterable      | O(n)       |
- * | constructors | {@link module:MutableHashSet.make}         | Creates a set from multiple values  | O(n)       |
- * |              |                                            |                                     |            |
- * | elements     | {@link module:MutableHashSet.has}          | Checks if a value exists in the set | O(1) avg   |
- * | elements     | {@link module:MutableHashSet.add}          | Adds a value to the set             | O(1) avg   |
- * | elements     | {@link module:MutableHashSet.remove}       | Removes a value from the set        | O(1) avg   |
- * | elements     | {@link module:MutableHashSet.size}         | Gets the number of elements         | O(1)       |
- * | elements     | {@link module:MutableHashSet.clear}        | Removes all values from the set     | O(1)       |
- *
- * ## Notes
- *
- * ### Mutability Considerations:
- *
- * Unlike most data structures in the Effect ecosystem, `MutableHashSet` is
- * mutable. This means that operations like `add`, `remove`, and `clear` modify
- * the original set rather than creating a new one. This can lead to more
- * efficient code in some scenarios, but requires careful handling to avoid
- * unexpected side effects.
- *
- * ### When to Choose `MutableHashSet` vs {@link module:HashSet}:
- *
- * - Use `MutableHashSet` when you need to build or modify a set incrementally and
- *   performance is a priority
- * - Use `HashSet` when you want immutability guarantees and functional
- *   programming patterns
- * - Consider using {@link module:HashSet}'s bounded mutation context (via
- *   {@link module:HashSet.beginMutation}, {@link module:HashSet.endMutation}, and
- *   {@link module:HashSet.mutate} methods) when you need temporary mutability
- *   within an otherwise immutable context - this approach might be sufficient
- *   for many use cases without requiring a separate `MutableHashSet`
- * - `MutableHashSet` is often useful for local operations where the mutability is
- *   contained and doesn't leak into the broader application
- *
- * @module MutableHashSet
- * @since 2.0.0
- */
-export * as MutableHashSet from "./MutableHashSet.js"
-
-/**
- * @since 2.0.0
- */
-export * as MutableList from "./MutableList.js"
-
-/**
- * @since 2.0.0
- */
-export * as MutableQueue from "./MutableQueue.js"
-
-/**
- * @since 2.0.0
- */
-export * as MutableRef from "./MutableRef.js"
-
-/**
- * @since 2.0.0
- */
-export * as NonEmptyIterable from "./NonEmptyIterable.js"
-
-/**
- * # Number
- *
- * This module provides utility functions and type class instances for working
- * with the `number` type in TypeScript. It includes functions for basic
- * arithmetic operations, as well as type class instances for `Equivalence` and
- * `Order`.
- *
- * ## Operations Reference
- *
- * | Category     | Operation                                  | Description                                             | Domain                         | Co-domain             |
- * | ------------ | ------------------------------------------ | ------------------------------------------------------- | ------------------------------ | --------------------- |
- * | constructors | {@link module:Number.parse}                | Safely parses a string to a number                      | `string`                       | `Option<number>`      |
- * |              |                                            |                                                         |                                |                       |
- * | math         | {@link module:Number.sum}                  | Adds two numbers                                        | `number`, `number`             | `number`              |
- * | math         | {@link module:Number.sumAll}               | Sums all numbers in a collection                        | `Iterable<number>`             | `number`              |
- * | math         | {@link module:Number.subtract}             | Subtracts one number from another                       | `number`, `number`             | `number`              |
- * | math         | {@link module:Number.multiply}             | Multiplies two numbers                                  | `number`, `number`             | `number`              |
- * | math         | {@link module:Number.multiplyAll}          | Multiplies all numbers in a collection                  | `Iterable<number>`             | `number`              |
- * | math         | {@link module:Number.divide}               | Safely divides handling division by zero                | `number`, `number`             | `Option<number>`      |
- * | math         | {@link module:Number.unsafeDivide}         | Divides but misbehaves for division by zero             | `number`, `number`             | `number`              |
- * | math         | {@link module:Number.remainder}            | Calculates remainder of division                        | `number`, `number`             | `number`              |
- * | math         | {@link module:Number.increment}            | Adds 1 to a number                                      | `number`                       | `number`              |
- * | math         | {@link module:Number.decrement}            | Subtracts 1 from a number                               | `number`                       | `number`              |
- * | math         | {@link module:Number.sign}                 | Determines the sign of a number                         | `number`                       | `Ordering`            |
- * | math         | {@link module:Number.nextPow2}             | Finds the next power of 2                               | `number`                       | `number`              |
- * | math         | {@link module:Number.round}                | Rounds a number with specified precision                | `number`, `number`             | `number`              |
- * |              |                                            |                                                         |                                |                       |
- * | predicates   | {@link module:Number.between}              | Checks if a number is in a range                        | `number`, `{minimum, maximum}` | `boolean`             |
- * | predicates   | {@link module:Number.lessThan}             | Checks if one number is less than another               | `number`, `number`             | `boolean`             |
- * | predicates   | {@link module:Number.lessThanOrEqualTo}    | Checks if one number is less than or equal              | `number`, `number`             | `boolean`             |
- * | predicates   | {@link module:Number.greaterThan}          | Checks if one number is greater than another            | `number`, `number`             | `boolean`             |
- * | predicates   | {@link module:Number.greaterThanOrEqualTo} | Checks if one number is greater or equal                | `number`, `number`             | `boolean`             |
- * |              |                                            |                                                         |                                |                       |
- * | guards       | {@link module:Number.isNumber}             | Type guard for JavaScript numbers                       | `unknown`                      | `boolean`             |
- * |              |                                            |                                                         |                                |                       |
- * | comparison   | {@link module:Number.min}                  | Returns the minimum of two numbers                      | `number`, `number`             | `number`              |
- * | comparison   | {@link module:Number.max}                  | Returns the maximum of two numbers                      | `number`, `number`             | `number`              |
- * | comparison   | {@link module:Number.clamp}                | Restricts a number to a range                           | `number`, `{minimum, maximum}` | `number`              |
- * |              |                                            |                                                         |                                |                       |
- * | instances    | {@link module:Number.Equivalence}          | Equivalence instance for numbers                        |                                | `Equivalence<number>` |
- * | instances    | {@link module:Number.Order}                | Order instance for numbers                              |                                | `Order<number>`       |
- * |              |                                            |                                                         |                                |                       |
- * | errors       | {@link module:Number.DivisionByZeroError}  | Error thrown by unsafeDivide                            |                                |                       |
- *
- * ## Composition Patterns and Type Safety
- *
- * When building function pipelines, understanding how types flow through
- * operations is critical:
- *
- * ### Composing with type-preserving operations
- *
- * Most operations in this module are type-preserving (`number → number`),
- * making them easily composable in pipelines:
- *
- * ```ts
- * import { pipe } from "effect"
- * import * as Number from "effect/Number"
- *
- * const result = pipe(
- *   10,
- *   Number.increment, // number → number
- *   Number.multiply(2), // number → number
- *   Number.round(1) // number → number
- * ) // Result: number (21)
- * ```
- *
- * ### Working with Option results
- *
- * Operations that might fail (like division by zero) return Option types and
- * require Option combinators:
- *
- * ```ts
- * import { pipe, Option } from "effect"
- * import * as Number from "effect/Number"
- *
- * const result = pipe(
- *   10,
- *   Number.divide(0), // number → Option<number>
- *   Option.getOrElse(() => 0) // Option<number> → number
- * ) // Result: number (0)
- * ```
- *
- * ### Composition best practices
- *
- * - Chain type-preserving operations for maximum composability
- * - Use Option combinators when working with potentially failing operations
- * - Consider using Effect for operations that might fail with specific errors
- * - Remember that all operations maintain JavaScript's floating-point precision
- *   limitations
- *
- * @module Number
- * @since 2.0.0
- * @see {@link module:BigInt} for more similar operations on `bigint` types
- * @see {@link module:BigDecimal} for more similar operations on `BigDecimal` types
- */
-export * as Number from "./Number.js"
-
-/**
- * @since 2.0.0
- */
-export * as Option from "./Option.js"
-
-/**
- * This module provides an implementation of the `Order` type class which is used to define a total ordering on some type `A`.
- * An order is defined by a relation `<=`, which obeys the following laws:
- *
- * - either `x <= y` or `y <= x` (totality)
- * - if `x <= y` and `y <= x`, then `x == y` (antisymmetry)
- * - if `x <= y` and `y <= z`, then `x <= z` (transitivity)
- *
- * The truth table for compare is defined as follows:
- *
- * | `x <= y` | `x >= y` | Ordering |                       |
- * | -------- | -------- | -------- | --------------------- |
- * | `true`   | `true`   | `0`      | corresponds to x == y |
- * | `true`   | `false`  | `< 0`    | corresponds to x < y  |
- * | `false`  | `true`   | `> 0`    | corresponds to x > y  |
- *
- * @since 2.0.0
- */
-export * as Order from "./Order.js"
-
-/**
- * @since 2.0.0
- */
-export * as Ordering from "./Ordering.js"
-
-/**
- * @since 3.10.0
- */
-export * as ParseResult from "./ParseResult.js"
-
-/**
- * @since 3.19.4
- * @experimental
- */
-export * as PartitionedSemaphore from "./PartitionedSemaphore.js"
-
-/**
- * @since 2.0.0
- */
-export * as Pipeable from "./Pipeable.js"
-
-/**
- * @since 2.0.0
- */
-export * as Pool from "./Pool.js"
-
-/**
- * This module provides a collection of functions for working with predicates and refinements.
- *
- * A `Predicate<A>` is a function that takes a value of type `A` and returns a boolean.
- * It is used to check if a value satisfies a certain condition.
- *
- * A `Refinement<A, B>` is a special type of predicate that not only checks a condition
- * but also provides a type guard, allowing TypeScript to narrow the type of the input
- * value from `A` to a more specific type `B` within a conditional block.
- *
- * The module includes:
- * - Basic predicates and refinements for common types (e.g., `isString`, `isNumber`).
- * - Combinators to create new predicates from existing ones (e.g., `and`, `or`, `not`).
- * - Advanced combinators for working with data structures (e.g., `tuple`, `struct`).
- * - Type-level utilities for inspecting predicate and refinement types.
- *
- * @since 2.0.0
- */
-export * as Predicate from "./Predicate.js"
-
-/**
- * @since 3.10.0
- */
-export * as Pretty from "./Pretty.js"
-
-/**
- * @since 2.0.0
- */
-export * as PrimaryKey from "./PrimaryKey.js"
-
-/**
- * @since 2.0.0
- */
-export * as PubSub from "./PubSub.js"
-
-/**
- * @since 2.0.0
- */
-export * as Queue from "./Queue.js"
-
-/**
- * @since 2.0.0
- */
-export * as Random from "./Random.js"
-
-/**
- * Limits the number of calls to a resource to a maximum amount in some interval.
- *
- * @since 2.0.0
- */
-export * as RateLimiter from "./RateLimiter.js"
-
-/**
- * @since 3.5.0
- */
-export * as RcMap from "./RcMap.js"
-
-/**
- * @since 3.5.0
- */
-export * as RcRef from "./RcRef.js"
-
-/**
- * @since 2.0.0
- */
-export * as Readable from "./Readable.js"
-
-/**
- * This module provides utility functions for working with records in TypeScript.
- *
- * @since 2.0.0
- */
-export * as Record from "./Record.js"
-
-/**
- * @since 2.0.0
- */
-export * as RedBlackTree from "./RedBlackTree.js"
-
-/**
- * The Redacted module provides functionality for handling sensitive information
- * securely within your application. By using the `Redacted` data type, you can
- * ensure that sensitive values are not accidentally exposed in logs or error
- * messages.
- *
- * @since 3.3.0
- */
-export * as Redacted from "./Redacted.js"
-
-/**
- * @since 2.0.0
- */
-export * as Ref from "./Ref.js"
-
-/**
- * This module provides utility functions for working with RegExp in TypeScript.
- *
- * @since 2.0.0
- */
-export * as RegExp from "./RegExp.js"
-
-/**
- * @since 2.0.0
- */
-export * as Reloadable from "./Reloadable.js"
-
-/**
- * @since 2.0.0
- */
-export * as Request from "./Request.js"
-
-/**
- * @since 2.0.0
- */
-export * as RequestBlock from "./RequestBlock.js"
-
-/**
- * @since 2.0.0
- */
-export * as RequestResolver from "./RequestResolver.js"
-
-/**
- * @since 2.0.0
- */
-export * as Resource from "./Resource.js"
-
-/**
- * @since 2.0.0
- */
-export * as Runtime from "./Runtime.js"
-
-/**
- * @since 2.0.0
- */
-export * as RuntimeFlags from "./RuntimeFlags.js"
-
-/**
- * @since 2.0.0
- */
-export * as RuntimeFlagsPatch from "./RuntimeFlagsPatch.js"
-
-/**
- * @since 2.0.0
- */
-export * as STM from "./STM.js"
-
-/**
- * @since 2.0.0
- */
-export * as Schedule from "./Schedule.js"
-
-/**
- * @since 2.0.0
- */
-export * as ScheduleDecision from "./ScheduleDecision.js"
-
-/**
- * @since 2.0.0
- */
-export * as ScheduleInterval from "./ScheduleInterval.js"
-
-/**
- * @since 2.0.0
- */
-export * as ScheduleIntervals from "./ScheduleIntervals.js"
-
-/**
- * @since 2.0.0
- */
-export * as Scheduler from "./Scheduler.js"
-
-/**
- * @since 3.10.0
- */
-export * as Schema from "./Schema.js"
-
-/**
- * @since 3.10.0
- */
-export * as SchemaAST from "./SchemaAST.js"
-
-/**
- * @since 2.0.0
- */
-export * as Scope from "./Scope.js"
-
-/**
- * @since 2.0.0
- */
-export * as ScopedCache from "./ScopedCache.js"
-
-/**
- * @since 2.0.0
- */
-export * as ScopedRef from "./ScopedRef.js"
-
-/**
- * @since 2.0.0
- * @deprecated
- */
-export * as Secret from "./Secret.js"
-
-/**
- * @since 2.0.0
- */
-export * as SingleProducerAsyncInput from "./SingleProducerAsyncInput.js"
-
-/**
- * @since 2.0.0
- */
-export * as Sink from "./Sink.js"
-
-/**
- * @since 2.0.0
- */
-export * as SortedMap from "./SortedMap.js"
-
-/**
- * @since 2.0.0
- */
-export * as SortedSet from "./SortedSet.js"
-
-/**
- * @since 2.0.0
- */
-export * as Stream from "./Stream.js"
-
-/**
- * @since 2.0.0
- */
-export * as StreamEmit from "./StreamEmit.js"
-
-/**
- * @since 2.0.0
- */
-export * as StreamHaltStrategy from "./StreamHaltStrategy.js"
-
-/**
- * @since 2.0.0
- */
-export * as Streamable from "./Streamable.js"
-
-/**
- * This module provides utility functions and type class instances for working with the `string` type in TypeScript.
- * It includes functions for basic string manipulation, as well as type class instances for
- * `Equivalence` and `Order`.
- *
- * @since 2.0.0
- */
-export * as String from "./String.js"
-
-/**
- * This module provides utility functions for working with structs in TypeScript.
- *
- * @since 2.0.0
- */
-export * as Struct from "./Struct.js"
-
-/**
- * @since 2.0.0
- */
-export * as Subscribable from "./Subscribable.js"
-
-/**
- * @since 2.0.0
- */
-export * as SubscriptionRef from "./SubscriptionRef.js"
-
-/**
- * A `Supervisor<T>` is allowed to supervise the launching and termination of
- * fibers, producing some visible value of type `T` from the supervision.
- *
- * @since 2.0.0
- */
-export * as Supervisor from "./Supervisor.js"
-
-/**
- * @since 2.0.0
- */
-export * as Symbol from "./Symbol.js"
-
-/**
- * @since 2.0.0
- */
-export * as SynchronizedRef from "./SynchronizedRef.js"
-
-/**
- * @since 2.0.0
- */
-export * as TArray from "./TArray.js"
-
-/**
- * @since 2.0.0
- */
-export * as TDeferred from "./TDeferred.js"
-
-/**
- * @since 2.0.0
- */
-export * as TMap from "./TMap.js"
-
-/**
- * @since 2.0.0
- */
-export * as TPriorityQueue from "./TPriorityQueue.js"
-
-/**
- * @since 2.0.0
- */
-export * as TPubSub from "./TPubSub.js"
-
-/**
- * @since 2.0.0
- */
-export * as TQueue from "./TQueue.js"
-
-/**
- * @since 2.0.0
- */
-export * as TRandom from "./TRandom.js"
-
-/**
- * @since 2.0.0
- */
-export * as TReentrantLock from "./TReentrantLock.js"
-
-/**
- * @since 2.0.0
- */
-export * as TRef from "./TRef.js"
-
-/**
- * @since 2.0.0
- */
-export * as TSemaphore from "./TSemaphore.js"
-
-/**
- * @since 2.0.0
- */
-export * as TSet from "./TSet.js"
-
-/**
- * @since 3.10.0
- */
-export * as TSubscriptionRef from "./TSubscriptionRef.js"
-
-/**
- * @since 2.0.0
- */
-export * as Take from "./Take.js"
-
-/**
- * @since 2.0.0
- */
-export * as TestAnnotation from "./TestAnnotation.js"
-
-/**
- * @since 2.0.0
- */
-export * as TestAnnotationMap from "./TestAnnotationMap.js"
-
-/**
- * @since 2.0.0
- */
-export * as TestAnnotations from "./TestAnnotations.js"
-
-/**
- * @since 2.0.0
- */
-export * as TestClock from "./TestClock.js"
-
-/**
- * @since 2.0.0
- */
-export * as TestConfig from "./TestConfig.js"
-
-/**
- * @since 2.0.0
- */
-export * as TestContext from "./TestContext.js"
-
-/**
- * @since 2.0.0
- */
-export * as TestLive from "./TestLive.js"
-
-/**
- * @since 2.0.0
- */
-export * as TestServices from "./TestServices.js"
-
-/**
- * @since 2.0.0
- */
-export * as TestSized from "./TestSized.js"
-
-/**
- * @since 2.0.0
- */
-export * as Tracer from "./Tracer.js"
-
-/**
- * A `Trie` is used for locating specific `string` keys from within a set.
- *
- * It works similar to `HashMap`, but with keys required to be `string`.
- * This constraint unlocks some performance optimizations and new methods to get string prefixes (e.g. `keysWithPrefix`, `longestPrefixOf`).
- *
- * Prefix search is also the main feature that makes a `Trie` more suited than `HashMap` for certain usecases.
- *
- * A `Trie` is often used to store a dictionary (list of words) that can be searched
- * in a manner that allows for efficient generation of completion lists
- * (e.g. predict the rest of a word a user is typing).
- *
- * A `Trie` has O(n) lookup time where `n` is the size of the key,
- * or even less than `n` on search misses.
- *
- * @since 2.0.0
- */
-export * as Trie from "./Trie.js"
-
-/**
- * This module provides utility functions for working with tuples in TypeScript.
- *
- * @since 2.0.0
- */
-export * as Tuple from "./Tuple.js"
-
-/**
- * A collection of types that are commonly used types.
- *
- * @since 2.0.0
- */
-export * as Types from "./Types.js"
-
-/**
- * @since 2.0.0
- */
-export * as Unify from "./Unify.js"
-
-/**
- * @since 2.0.0
- */
-export * as UpstreamPullRequest from "./UpstreamPullRequest.js"
-
-/**
- * @since 2.0.0
- */
-export * as UpstreamPullStrategy from "./UpstreamPullStrategy.js"
-
-/**
- * @since 2.0.0
- */
-export * as Utils from "./Utils.js"