@akterjs/cli 0.0.0-stage → 0.1.1

package/dist/Array-B4kuTQeW.mjs

@@ -0,0 +1,2323 @@
+import { Bt as hash, E as isNone, Et as format, F as PipeInspectableProto, It as equals, Kt as symbol$1, Lt as symbol, Pt as asEquivalence, S as none, Sn as identity, Yt as isBoolean, Zt as isFunction, _ as isSome, _t as SingleShotGen, bn as dual, gt as assignProperty, h as isNone$1, qt as hasProperty, w as some$1, wt as toJson, zt as combine } from "./Option-DkxSnBhp.mjs";
+import { m as min$1 } from "./Order-C1JC991I.mjs";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Equivalence.js
+/**
+* Creates a custom equivalence relation with an optimized reference equality check.
+*
+* **When to use**
+*
+* Use when you need an equality rule that the built-in instances and input
+* mapping helpers cannot express, and you can provide a law-abiding comparison.
+*
+* **Details**
+*
+* The returned equivalence first checks reference equality (`===`) for
+* performance. If the values are not the same reference, it falls back to the
+* provided equivalence function, which must satisfy reflexive, symmetric, and
+* transitive properties.
+*
+* **Example** (Case-insensitive string equivalence)
+*
+* ```ts import.meta.vitest
+* import { Equivalence } from "effect"
+*
+* const caseInsensitive = Equivalence.make<string>((a, b) =>
+*   a.toLowerCase() === b.toLowerCase()
+* )
+*
+* caseInsensitive("Hello", "HELLO") // => true
+* caseInsensitive("foo", "bar") // => false
+*
+* // Same reference optimization
+* const str = "test"
+* caseInsensitive(str, str) // => true
+* ```
+*
+* **Example** (Comparing numbers with tolerance)
+*
+* ```ts import.meta.vitest
+* import { Equivalence } from "effect"
+*
+* const tolerance = Equivalence.make<number>((a, b) => Math.abs(a - b) < 0.0001)
+*
+* tolerance(1.0, 1.001) // => false
+* tolerance(1.0, 1.00001) // => true
+* ```
+*
+* @see {@link strictEqual}
+* @see {@link mapInput}
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const make$1 = (isEquivalent) => (self, that) => self === that || isEquivalent(self, that);
+const isStrictEquivalent = (x, y) => x === y;
+/**
+* Creates an equivalence relation that uses strict equality (`===`) to compare values.
+*
+* **When to use**
+*
+* Use when you need strict equality (`===`) as the comparison.
+*
+* **Details**
+*
+* Uses JavaScript's strict equality operator (`===`). Primitives compare by
+* value. Objects compare by reference, so only the same object instance is
+* equivalent. Use this as a building block for more complex equivalences via
+* `mapInput` or `combine`.
+*
+* **Gotchas**
+*
+* `NaN !== NaN`, so `NaN` values are never considered equivalent.
+*
+* **Example** (Comparing primitive types)
+*
+* ```ts import.meta.vitest
+* import { Equivalence } from "effect"
+*
+* const strictEq = Equivalence.strictEqual<number>()
+*
+* strictEq(1, 1) // => true
+* strictEq(1, 2) // => false
+* strictEq(NaN, NaN) // => false
+* ```
+*
+* **Example** (Comparing objects by reference)
+*
+* ```ts import.meta.vitest
+* import { Equivalence } from "effect"
+*
+* const obj = { value: 42 }
+* const strictObjEq = Equivalence.strictEqual<typeof obj>()
+*
+* strictObjEq(obj, obj) // => true
+* strictObjEq(obj, { value: 42 }) // => false
+* ```
+*
+* @see {@link make}
+* @see `Equal` for structural equality
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const strictEqual = () => isStrictEquivalent;
+/**
+* Creates an equivalence for tuples with heterogeneous element types.
+*
+* **When to use**
+*
+* Use when you need an `Equivalence` for fixed-length tuples with per-position
+* equivalences.
+*
+* **Details**
+*
+* Tuples must have the same length; different lengths are never equivalent.
+* Each equivalence is applied to the corresponding element position. The result
+* returns `true` only if all elements are equivalent according to their
+* respective equivalences, and it also satisfies reflexive, symmetric, and
+* transitive properties.
+*
+* **Example** (Comparing homogeneous tuples)
+*
+* ```ts import.meta.vitest
+* import { Equivalence } from "effect"
+*
+* const stringTupleEq = Equivalence.Tuple([
+*   Equivalence.strictEqual<string>(),
+*   Equivalence.strictEqual<string>(),
+*   Equivalence.strictEqual<string>()
+* ])
+*
+* const tuple1 = ["hello", "world", "test"] as const
+* const tuple2 = ["hello", "world", "test"] as const
+* const tuple3 = ["hello", "world", "different"] as const
+*
+* stringTupleEq(tuple1, tuple2) // => true
+* stringTupleEq(tuple1, tuple3) // => false
+* ```
+*
+* **Example** (Comparing tuples with custom equivalences)
+*
+* ```ts import.meta.vitest
+* import { Equivalence } from "effect"
+*
+* const caseInsensitive = Equivalence.mapInput(
+*   Equivalence.strictEqual<string>(),
+*   (s: string) => s.toLowerCase()
+* )
+*
+* const customTupleEq = Equivalence.Tuple([
+*   caseInsensitive,
+*   caseInsensitive,
+*   caseInsensitive
+* ])
+*
+* customTupleEq(["Hello", "World", "Test"], ["HELLO", "WORLD", "TEST"]) // => true
+* ```
+*
+* @stability stable
+* @category combinators
+* @since 4.0.0
+*/
+function Tuple(elements) {
+	return make$1((self, that) => {
+		if (self.length !== that.length) return false;
+		for (let i = 0; i < self.length; i++) if (!elements[i](self[i], that[i])) return false;
+		return true;
+	});
+}
+/**
+* @since 4.0.0
+*/
+function Array_(item) {
+	return make$1((self, that) => {
+		if (self.length !== that.length) return false;
+		for (let i = 0; i < self.length; i++) if (!item(self[i], that[i])) return false;
+		return true;
+	});
+}
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/internal/result.js
+const TypeId = "~effect/Result";
+const CommonProto = {
+	[TypeId]: {
+		/* v8 ignore next 2 */
+		_A: (_) => _,
+		_E: (_) => _
+	},
+	...PipeInspectableProto,
+	[Symbol.iterator]() {
+		return new SingleShotGen(this);
+	}
+};
+const SuccessProto = /*#__PURE__*/ Object.assign(/*#__PURE__*/ Object.create(CommonProto), {
+	_tag: "Success",
+	_op: "Success",
+	[symbol](that) {
+		return isResult$1(that) && isSuccess$1(that) && equals(this.success, that.success);
+	},
+	[symbol$1]() {
+		return combine(hash(this._tag))(hash(this.success));
+	},
+	toString() {
+		return `success(${format(this.success)})`;
+	},
+	toJSON() {
+		return {
+			_id: "Result",
+			_tag: this._tag,
+			value: toJson(this.success)
+		};
+	}
+});
+const FailureProto = /*#__PURE__*/ Object.assign(/*#__PURE__*/ Object.create(CommonProto), {
+	_tag: "Failure",
+	_op: "Failure",
+	[symbol](that) {
+		return isResult$1(that) && isFailure$1(that) && equals(this.failure, that.failure);
+	},
+	[symbol$1]() {
+		return combine(hash(this._tag))(hash(this.failure));
+	},
+	toString() {
+		return `failure(${format(this.failure)})`;
+	},
+	toJSON() {
+		return {
+			_id: "Result",
+			_tag: this._tag,
+			failure: toJson(this.failure)
+		};
+	}
+});
+/** @internal */
+const isResult$1 = (input) => hasProperty(input, TypeId);
+/** @internal */
+const isFailure$1 = (result) => result._tag === "Failure";
+/** @internal */
+const isSuccess$1 = (result) => result._tag === "Success";
+/** @internal */
+const FailureImpl = function(failure) {
+	this.failure = failure;
+};
+FailureImpl.prototype = FailureProto;
+/** @internal */
+const fail$1 = (failure) => new FailureImpl(failure);
+/** @internal */
+const SuccessImpl = function(success) {
+	this.success = success;
+};
+SuccessImpl.prototype = SuccessProto;
+/** @internal */
+const succeed$1 = (success) => new SuccessImpl(success);
+/** @internal */
+const fromOption$1 = /*#__PURE__*/ dual(2, (self, onNone) => isNone(self) ? fail$1(onNone()) : succeed$1(self.value));
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/internal/array.js
+/**
+* @since 2.0.0
+*/
+/** @internal */
+const isArrayNonEmpty$1 = (self) => self.length > 0;
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/internal/count.js
+/**
+* Normalizes a collection count to a non-negative integer. `NaN` and
+* non-positive values become `0`; positive infinity is preserved.
+*
+* @internal
+*/
+const normalize = (n) => n > 0 ? Math.floor(n) : 0;
+/**
+* Normalizes a collection count to an integer greater than or equal to `1`.
+*
+* @internal
+*/
+const normalizeNonEmpty = (n) => Math.max(1, normalize(n));
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Result.js
+/**
+* Creates a `Result` holding a `Success` value.
+*
+* **Details**
+*
+* - Use when you have a value and want to lift it into the `Result` type
+* - The error type `E` defaults to `never`
+*
+* **Example** (Wrapping a value)
+*
+* ```ts import.meta.vitest
+* import { Result } from "effect"
+*
+* Result.succeed(42) // => Result.succeed(42)
+* ```
+*
+* @see {@link fail} to create a Failure
+* @see {@link void_ void} for a pre-built `Success<void>`
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const succeed = succeed$1;
+/**
+* Creates a `Result` holding a `Failure` value.
+*
+* **When to use**
+*
+* Use to represent a failed `Result` with a typed failure value.
+*
+* **Details**
+*
+* - The success type `A` defaults to `never`
+*
+* **Example** (Creating a failure)
+*
+* ```ts import.meta.vitest
+* import { Result } from "effect"
+*
+* Result.fail("Something went wrong") // => Result.fail("Something went wrong")
+* ```
+*
+* @see {@link succeed} to create a Success
+* @see {@link mapError} to transform the error
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const fail = fail$1;
+/**
+* Converts an `Option<A>` into a `Result<A, E>`.
+*
+* **When to use**
+*
+* Use when an existing `Option` should become a `Result`, preserving `Some` as
+* success and turning `None` into a caller-provided failure.
+*
+* **Details**
+*
+* - `Some<A>` becomes `Success<A>`
+* - `None` becomes `Failure<E>` using the provided function
+* - Supports both data-first and data-last (piped) usage
+*
+* **Example** (Converting an Option to a Result)
+*
+* ```ts import.meta.vitest
+* import { Option, Result } from "effect"
+*
+* Result.fromOption(Option.some(1), () => "missing") // => Result.succeed(1)
+*
+* Result.fromOption(Option.none(), () => "missing") // => Result.fail("missing")
+* ```
+*
+* @see {@link getSuccess} to extract the success value as an Option
+* @see {@link getFailure} to extract the failure value as an Option
+* @see {@link fromNullishOr} to build a Result from nullable values
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const fromOption = fromOption$1;
+const try_ = (evaluate) => {
+	if (isFunction(evaluate)) try {
+		return succeed(evaluate());
+	} catch (e) {
+		return fail(e);
+	}
+	else try {
+		return succeed(evaluate.try());
+	} catch (e) {
+		return fail(evaluate.catch(e));
+	}
+};
+/**
+* Checks whether a value is a `Result` (either `Success` or `Failure`).
+*
+* **When to use**
+*
+* Use to validate unknown input before operating on it as a `Result`.
+*
+* **Details**
+*
+* - Returns `true` for both `Success` and `Failure` variants
+* - Acts as a TypeScript type guard, narrowing to `Result<unknown, unknown>`
+*
+* **Example** (Checking if a value is a Result)
+*
+* ```ts import.meta.vitest
+* import { Result } from "effect"
+*
+* Result.isResult(Result.succeed(1)) // => true
+*
+* Result.isResult({ value: 1 }) // => false
+* ```
+*
+* @see {@link isSuccess} / {@link isFailure} to narrow to a specific variant
+*
+* @stability stable
+* @category guards
+* @since 4.0.0
+*/
+const isResult = isResult$1;
+/**
+* Checks whether a `Result` is a `Failure`.
+*
+* **When to use**
+*
+* Use to narrow a known `Result` to the `Failure` variant.
+*
+* **Details**
+*
+* - Acts as a TypeScript type guard, narrowing to `Failure<A, E>`
+* - After narrowing, you can access `.failure` to read the error value
+*
+* **Example** (Narrowing to failure)
+*
+* ```ts import.meta.vitest
+* import { Result } from "effect"
+*
+* const result = Result.fail("oops")
+*
+* if (Result.isFailure(result)) {
+*   result.failure // => "oops"
+* }
+* ```
+*
+* @see {@link isSuccess} for the opposite check
+* @see {@link isResult} to check if a value is any Result
+*
+* @stability stable
+* @category guards
+* @since 4.0.0
+*/
+const isFailure = isFailure$1;
+/**
+* Checks whether a `Result` is a `Success`.
+*
+* **When to use**
+*
+* Use to narrow a known `Result` to the `Success` variant.
+*
+* **Details**
+*
+* - Acts as a TypeScript type guard, narrowing to `Success<A, E>`
+* - After narrowing, you can access `.success` to read the value
+*
+* **Example** (Narrowing to success)
+*
+* ```ts import.meta.vitest
+* import { Result } from "effect"
+*
+* const result = Result.succeed(42)
+*
+* if (Result.isSuccess(result)) {
+*   result.success // => 42
+* }
+* ```
+*
+* @see {@link isFailure} for the opposite check
+* @see {@link isResult} to check if a value is any Result
+*
+* @stability stable
+* @category guards
+* @since 4.0.0
+*/
+const isSuccess = isSuccess$1;
+/**
+* Transforms the failure channel of a `Result`, leaving the success channel unchanged.
+*
+* **When to use**
+*
+* Use to transform only the failure channel while preserving success values.
+*
+* **Details**
+*
+* - If the result is a `Failure`, applies `f` to the error and returns a new `Failure`
+* - If the result is a `Success`, returns it as-is
+*
+* **Example** (Adding context to an error)
+*
+* ```ts import.meta.vitest
+* import { pipe, Result } from "effect"
+*
+* pipe(
+*   Result.fail("not found"),
+*   Result.mapError((e) => `Error: ${e}`)
+* ) // => Result.fail("Error: not found")
+* ```
+*
+* @see {@link map} to transform only the success value
+* @see {@link mapBoth} to transform both channels
+*
+* @stability stable
+* @category mapping
+* @since 4.0.0
+*/
+const mapError = /*#__PURE__*/ dual(2, (self, f) => isFailure(self) ? fail(f(self.failure)) : self);
+/**
+* Transforms the success channel of a `Result`, leaving the failure channel unchanged.
+*
+* **When to use**
+*
+* Use to apply a transformation to the success value of a `Result` while
+* preserving any existing failure.
+*
+* **Details**
+*
+* - If the result is a `Success`, applies `f` to the value and returns a new `Success`
+* - If the result is a `Failure`, returns it as-is
+* - Use {@link flatMap} if `f` returns a `Result` (to avoid nested Results)
+*
+* **Example** (Doubling the success value)
+*
+* ```ts import.meta.vitest
+* import { pipe, Result } from "effect"
+*
+* pipe(
+*   Result.succeed(3),
+*   Result.map((n) => n * 2)
+* ) // => Result.succeed(6)
+* ```
+*
+* @see {@link mapError} to transform only the error value
+* @see {@link mapBoth} to transform both channels
+* @see {@link flatMap} when `f` returns a `Result`
+*
+* @stability stable
+* @category mapping
+* @since 2.0.0
+*/
+const map$1 = /*#__PURE__*/ dual(2, (self, f) => isSuccess(self) ? succeed(f(self.success)) : self);
+/**
+* Folds a `Result` into a single value by applying one of two functions.
+*
+* **When to use**
+*
+* Use when a `Result`'s success and failure branches should be collapsed into
+* one plain output type.
+*
+* **Details**
+*
+* - Applies `onSuccess` if the result is a `Success`
+* - Applies `onFailure` if the result is a `Failure`
+* - Both branches must return the same type (or a common supertype)
+*
+* **Example** (Folding to a string)
+*
+* ```ts import.meta.vitest
+* import { pipe, Result } from "effect"
+*
+* const format = Result.match({
+*   onSuccess: (n: number) => `Got ${n}`,
+*   onFailure: (e: string) => `Err: ${e}`
+* })
+*
+* format(Result.succeed(42)) // => "Got 42"
+*
+* format(Result.fail("timeout")) // => "Err: timeout"
+* ```
+*
+* @see {@link merge} to extract `A | E` without mapping
+* @see {@link getOrElse} to unwrap only the success with a fallback
+*
+* @stability stable
+* @category pattern matching
+* @since 2.0.0
+*/
+const match$1 = /*#__PURE__*/ dual(2, (self, { onFailure, onSuccess }) => isFailure(self) ? onFailure(self.failure) : onSuccess(self.success));
+/**
+* Extracts the success value or throws the raw failure value `E`.
+*
+* **When to use**
+*
+* Use when unchecked boundaries should turn failures into thrown exceptions.
+*
+* **Details**
+*
+* - `Success<A>` returns `A`
+* - `Failure<E>` throws `E` directly
+* - Use {@link getOrThrowWith} for a custom error object
+*
+* **Example** (Unwrapping or throwing)
+*
+* ```ts import.meta.vitest
+* import { Result } from "effect"
+*
+* Result.getOrThrow(Result.succeed(1)) // => 1
+*
+* const failure = Result.try(() => Result.getOrThrow(Result.fail("error")))
+* Result.merge(failure) // => "error"
+* ```
+*
+* @see {@link getOrThrowWith} for custom error mapping
+* @see {@link getOrElse} for a non-throwing alternative
+*
+* @stability stable
+* @category getters
+* @since 2.0.0
+*/
+const getOrThrow = /*#__PURE__*/ (/* @__PURE__ */ dual(2, (self, onFailure) => {
+	if (isSuccess(self)) return self.success;
+	throw onFailure(self.failure);
+}))(identity);
+/**
+* Chains a function that returns a `Result` onto a successful value.
+*
+* **When to use**
+*
+* Use to sequence `Result`-returning computations that should short-circuit on
+* failure.
+*
+* **Details**
+*
+* - If `self` is a `Success`, applies `f` to the value and returns the resulting `Result`
+* - If `self` is a `Failure`, short-circuits and returns it unchanged
+* - The error types are merged into a union (`E | E2`)
+* - This is the monadic `bind` / `>>=` for `Result`
+*
+* **Example** (Validating sequentially)
+*
+* ```ts import.meta.vitest
+* import { pipe, Result } from "effect"
+*
+* pipe(
+*   Result.succeed(5),
+*   Result.flatMap((n) =>
+*     n > 0 ? Result.succeed(n * 2) : Result.fail("not positive")
+*   )
+* ) // => Result.succeed(10)
+* ```
+*
+* @see {@link andThen} for a more flexible variant that also accepts plain values
+* @see {@link map} when `f` does not return a `Result`
+*
+* @stability stable
+* @category sequencing
+* @since 2.0.0
+*/
+const flatMap$1 = /*#__PURE__*/ dual(2, (self, f) => isFailure(self) ? fail(self.failure) : f(self.success));
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Tuple.js
+/**
+* Creates a tuple from the provided arguments.
+*
+* **When to use**
+*
+* Use when you need a properly typed tuple without writing `[a, b, c] as const`
+* or another manual cast.
+*
+* **Details**
+*
+* The returned value has the exact tuple type, with each element's literal type
+* preserved.
+*
+* **Example** (Creating a tuple)
+*
+* ```ts import.meta.vitest
+* import { Tuple } from "effect"
+*
+* Tuple.make(10, 20, "red") // => [10, 20, "red"]
+* ```
+*
+* @see {@link get} – access a single element by index
+* @see {@link appendElement} – append an element to a tuple
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const make = (...elements) => elements;
+/**
+* Creates an `Equivalence` for tuples by comparing corresponding elements
+* using the provided per-position `Equivalence`s. Two tuples are equivalent
+* when all their corresponding elements are equivalent.
+*
+* **When to use**
+*
+* Use when you need an `Equivalence` to compare tuples element-by-element.
+*
+* **Details**
+*
+* This is an alias of `Equivalence.Tuple`.
+*
+* **Example** (Comparing tuples for equivalence)
+*
+* ```ts import.meta.vitest
+* import { Equivalence, Tuple } from "effect"
+*
+* const eq = Tuple.makeEquivalence([
+*   Equivalence.strictEqual<string>(),
+*   Equivalence.strictEqual<number>()
+* ])
+*
+* eq(["Alice", 30], ["Alice", 30]) // => true
+* eq(["Alice", 30], ["Bob", 30]) // => false
+* ```
+*
+* @see {@link makeOrder} – create an `Order` for tuples
+* @stability stable
+* @category instances
+* @since 4.0.0
+*/
+const makeEquivalence$1 = Tuple;
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Iterable.js
+/**
+* Gets the first element of an `Iterable` without returning an `Option`.
+*
+* **When to use**
+*
+* Use when the `Iterable` is known to be non-empty and direct access to the
+* first element is preferred over handling `Option.none`.
+*
+* **Gotchas**
+*
+* Throws if the `Iterable` is empty.
+*
+* **Example** (Getting the first element unsafely)
+*
+* ```ts import.meta.vitest
+* import { Iterable } from "effect"
+*
+* const numbers = [1, 2, 3]
+* Iterable.headUnsafe(numbers) // => 1
+*
+* const letters = "hello"
+* Iterable.headUnsafe(letters) // => "h"
+*
+* // Iterable.headUnsafe(Iterable.empty<number>())
+* // throws Error: "headUnsafe: empty iterable"
+*
+* // Use only when you're certain the iterable is non-empty
+* const nonEmpty = Iterable.range(1, 10)
+* Iterable.headUnsafe(nonEmpty) // => 1
+* ```
+*
+* @stability stable
+* @category getters
+* @since 4.0.0
+*/
+const headUnsafe = (self) => {
+	const result = self[Symbol.iterator]().next();
+	if (result.done) throw new Error("headUnsafe: empty iterable");
+	return result.value;
+};
+/**
+* Returns the first element that satisfies the specified
+* predicate, or `None` if no such element exists.
+*
+* **Example** (Finding the first match)
+*
+* ```ts import.meta.vitest
+* import { Iterable, Option } from "effect"
+*
+* const numbers = [1, 3, 4, 6, 8]
+* const firstEven = Iterable.findFirst(numbers, (x) => x % 2 === 0)
+* firstEven // => Option.some(4)
+*
+* const firstGreaterThan10 = Iterable.findFirst(numbers, (x) => x > 10)
+* firstGreaterThan10 // => Option.none()
+*
+* // With index
+* const letters = ["a", "b", "c", "d"]
+* const atEvenIndex = Iterable.findFirst(letters, (_, i) => i % 2 === 0)
+* atEvenIndex // => Option.some("a")
+*
+* // Type refinement
+* const mixed: Array<string | number> = [1, "hello", 2, "world"]
+* const firstString = Iterable.findFirst(
+*   mixed,
+*   (x): x is string => typeof x === "string"
+* )
+* firstString // => Option.some("hello")
+*
+* // Transform during search
+* const findSquareRoot = Iterable.findFirst([1, 4, 9, 16], (x) => {
+*   const sqrt = Math.sqrt(x)
+*   return Number.isInteger(sqrt) ? Option.some(sqrt) : Option.none()
+* })
+* findSquareRoot // => Option.some(1)
+* ```
+*
+* @stability stable
+* @category searching
+* @since 2.0.0
+*/
+const findFirst$1 = /*#__PURE__*/ dual(2, (self, f) => {
+	let i = 0;
+	for (const a of self) {
+		const o = f(a, i);
+		if (isBoolean(o)) {
+			if (o) return some$1(a);
+		} else if (isSome(o)) return o;
+		i++;
+	}
+	return none();
+});
+const constEmpty = { [Symbol.iterator]() {
+	return constEmptyIterator;
+} };
+const constEmptyIterator = { next() {
+	return {
+		done: true,
+		value: void 0
+	};
+} };
+/**
+* Creates an empty iterable that yields no elements.
+*
+* **When to use**
+*
+* Use when you need an empty iterable as a typed "no data" value or a base
+* case for iterable operations.
+*
+* **Example** (Creating an empty iterable)
+*
+* ```ts import.meta.vitest
+* import { Iterable } from "effect"
+*
+* Array.from(Iterable.empty<string>()) // => []
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const empty$1 = () => constEmpty;
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Array.js
+/**
+* Works with JavaScript arrays, readonly arrays, and non-empty arrays.
+*
+* The helpers cover common collection work such as creating arrays, reading
+* elements, transforming values, sorting, grouping, splitting, combining, and
+* reducing many values to one result. Helpers that change contents return new
+* arrays and preserve non-empty array types when the result is guaranteed to
+* contain values.
+*
+* @stability stable
+* @since 2.0.0
+*/
+/**
+* Exposes the global array constructor.
+*
+* **When to use**
+*
+* Use to access native JavaScript array constructor methods such as `isArray`
+* or `from` from the Effect module namespace.
+*
+* **Example** (Accessing the Array constructor)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.Array === globalThis.Array // => true
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const Array$1 = globalThis.Array;
+/**
+* Creates a `NonEmptyArray` of length `n` where element `i` is computed by `f(i)`.
+*
+* **When to use**
+*
+* Use when you need to compute each array element from its index.
+*
+* **Details**
+*
+* `n` is rounded down and normalized to an integer greater than or equal to 1.
+* `NaN` is treated as `1`, so this function always returns at least one
+* element. Supports both data-first and data-last usage.
+*
+* **Example** (Generating values from indices)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.makeBy(5, (n) => n * 2) // => [0, 2, 4, 6, 8]
+* ```
+*
+* @see {@link range} — create a range of integers
+* @see {@link replicate} — repeat a single value
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const makeBy = /*#__PURE__*/ dual(2, (n, f) => {
+	const max = normalizeNonEmpty(n);
+	const out = new Array$1(max);
+	for (let i = 0; i < max; i++) out[i] = f(i);
+	return out;
+});
+/**
+* Converts an `Iterable` to an `Array`.
+*
+* **When to use**
+*
+* Use to convert any `Iterable` (Set, Generator, etc.) into an array.
+*
+* **Details**
+*
+* If the input is already an array, this returns it by reference without
+* copying. Otherwise, it creates a new array from the iterable. Use `copy` if
+* you need a fresh array even when the input is already an array.
+*
+* **Example** (Converting a Set to an array)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.fromIterable(new Set([1, 2, 3])) // => [1, 2, 3]
+* ```
+*
+* @see {@link ensure} — wrap a single value or return an existing array
+* @see {@link copy} — create a shallow copy of an array
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const fromIterable = (collection) => Array$1.isArray(collection) ? collection : Array$1.from(collection);
+/**
+* Normalizes a value that is either a single element or an array into an array.
+*
+* **When to use**
+*
+* Use to normalize input that may be a single value or an array into a consistent
+* array.
+*
+* **Details**
+*
+* If the input is already an array, this returns it by reference. If the input
+* is a single value, this wraps it in a one-element array. This is useful for
+* APIs that accept `A | Array<A>`.
+*
+* **Example** (Normalizing input)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.ensure("a") // => ["a"]
+* Array.ensure(["a", "b", "c"]) // => ["a", "b", "c"]
+* ```
+*
+* @see {@link of} — always wrap in a single-element array
+* @see {@link fromIterable} — convert any iterable
+*
+* @stability stable
+* @category constructors
+* @since 3.3.0
+*/
+const ensure = (self) => Array$1.isArray(self) ? self : [self];
+/**
+* Pattern-matches on an array, handling empty and non-empty cases separately.
+*
+* **When to use**
+*
+* Use when you need to branch on whether an array is empty.
+*
+* **Details**
+*
+* `onNonEmpty` receives a `NonEmptyArray` for mutable arrays and a
+* `NonEmptyReadonlyArray` otherwise. Data-last calls default to the readonly
+* callback, so the returned function still accepts `ReadonlyArray`. Supports
+* both data-first and data-last usage.
+*
+* **Example** (Branching on emptiness)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* const describe = Array.match({
+*   onEmpty: () => "empty",
+*   onNonEmpty: ([head, ...tail]) => `head: ${head}, tail: ${tail.length}`
+* })
+*
+* describe([]) // => "empty"
+* describe([1, 2, 3]) // => "head: 1, tail: 2"
+* ```
+*
+* @see {@link matchLeft} — destructures into head + tail
+* @see {@link matchRight} — destructures into init + last
+*
+* @stability stable
+* @category pattern matching
+* @since 2.0.0
+*/
+const match = /*#__PURE__*/ dual(2, (self, { onEmpty, onNonEmpty }) => isReadonlyArrayNonEmpty(self) ? onNonEmpty(self) : onEmpty());
+/**
+* Pattern-matches on an array from the left, providing the first element and
+* the remaining elements separately.
+*
+* **When to use**
+*
+* Use when you need to branch on an array and handle the non-empty case as the
+* first element plus the remaining elements.
+*
+* **Details**
+*
+* `onNonEmpty` receives `(head, tail)` where `tail` is the rest of the array.
+*
+* **Example** (Destructuring head and tail)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* const matchLeft = Array.matchLeft({
+*   onEmpty: () => "empty",
+*   onNonEmpty: (head, tail) => `head: ${head}, tail: ${tail.length}`
+* })
+*
+* matchLeft([]) // => "empty"
+* matchLeft([1, 2, 3]) // => "head: 1, tail: 2"
+* ```
+*
+* @see {@link match} — receives the full non-empty array
+* @see {@link matchRight} — destructures into init + last
+*
+* @stability stable
+* @category pattern matching
+* @since 2.0.0
+*/
+const matchLeft = /*#__PURE__*/ dual(2, (self, { onEmpty, onNonEmpty }) => isReadonlyArrayNonEmpty(self) ? onNonEmpty(headNonEmpty(self), tailNonEmpty(self)) : onEmpty());
+/**
+* Adds a single element to the end of an iterable, returning a `NonEmptyArray`.
+*
+* **When to use**
+*
+* Use when you need to guarantee a non-empty result after adding a required
+* trailing value.
+*
+* **Example** (Appending an element)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.append([1, 2, 3], 4) // => [1, 2, 3, 4]
+* ```
+*
+* @see {@link prepend} — add to the front
+* @see {@link appendAll} — append multiple elements
+*
+* @stability stable
+* @category combining
+* @since 2.0.0
+*/
+const append = /*#__PURE__*/ dual(2, (self, last) => [...self, last]);
+/**
+* Concatenates two iterables into a single array.
+*
+* **When to use**
+*
+* Use to combine two iterable inputs into a new array with the second input's
+* elements after the first.
+*
+* **Details**
+*
+* If either input is non-empty, the result is a `NonEmptyArray`.
+*
+* **Example** (Concatenating arrays)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.appendAll([1, 2], [3, 4]) // => [1, 2, 3, 4]
+* ```
+*
+* @see {@link append} — add a single element to the end
+* @see {@link prependAll} — add elements to the front
+*
+* @stability stable
+* @category combining
+* @since 2.0.0
+*/
+const appendAll = /*#__PURE__*/ dual(2, (self, that) => fromIterable(self).concat(fromIterable(that)));
+/**
+* Checks whether a value is an `Array`.
+*
+* **When to use**
+*
+* Use to verify a value is a mutable array, narrowing its type to `Array<unknown>`.
+*
+* **Details**
+*
+* Acts as a type guard narrowing the input to `Array<unknown>` and delegates to
+* `globalThis.Array.isArray`.
+*
+* **Example** (Type-guarding an unknown value)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.isArray(null) // => false
+* Array.isArray([1, 2, 3]) // => true
+* ```
+*
+* @see {@link isArrayEmpty} — check for an empty array
+* @see {@link isArrayNonEmpty} — check for a non-empty array
+*
+* @stability stable
+* @category guards
+* @since 2.0.0
+*/
+const isArray = Array$1.isArray;
+/**
+* Checks whether a mutable `Array` is empty, narrowing the type to `[]`.
+*
+* **Example** (Checking for an empty array)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.isArrayEmpty([]) // => true
+* Array.isArrayEmpty([1, 2, 3]) // => false
+* ```
+*
+* @see {@link isReadonlyArrayEmpty} — readonly variant
+* @see {@link isArrayNonEmpty} — opposite check
+*
+* @stability stable
+* @category guards
+* @since 4.0.0
+*/
+const isArrayEmpty = (self) => self.length === 0;
+/**
+* Checks whether a `ReadonlyArray` is empty, narrowing the type to `readonly []`.
+*
+* **Example** (Checking for an empty readonly array)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.isReadonlyArrayEmpty([]) // => true
+* Array.isReadonlyArrayEmpty([1, 2, 3]) // => false
+* ```
+*
+* @see {@link isArrayEmpty} — mutable variant
+* @see {@link isReadonlyArrayNonEmpty} — opposite check
+*
+* @stability stable
+* @category guards
+* @since 4.0.0
+*/
+const isReadonlyArrayEmpty = isArrayEmpty;
+/**
+* Checks whether a mutable `Array` is non-empty, narrowing the type to
+* `NonEmptyArray`.
+*
+* **When to use**
+*
+* Use when you need the narrowed value to remain a mutable `Array` after proving
+* it has at least one element.
+*
+* **Example** (Checking for a non-empty array)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.isArrayNonEmpty([]) // => false
+* Array.isArrayNonEmpty([1, 2, 3]) // => true
+* ```
+*
+* @see {@link isReadonlyArrayNonEmpty} — readonly variant
+* @see {@link isArrayEmpty} — opposite check
+*
+* @stability stable
+* @category guards
+* @since 4.0.0
+*/
+const isArrayNonEmpty = isArrayNonEmpty$1;
+/**
+* Checks whether a `ReadonlyArray` is non-empty, narrowing the type to
+* `NonEmptyReadonlyArray`.
+*
+* **When to use**
+*
+* Use when you need to prove a readonly array has at least one element without
+* requiring mutable array methods afterward.
+*
+* **Example** (Checking for a non-empty readonly array)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.isReadonlyArrayNonEmpty([]) // => false
+* Array.isReadonlyArrayNonEmpty([1, 2, 3]) // => true
+* ```
+*
+* @see {@link isArrayNonEmpty} — mutable variant
+* @see {@link isReadonlyArrayEmpty} — opposite check
+*
+* @stability stable
+* @category guards
+* @since 4.0.0
+*/
+const isReadonlyArrayNonEmpty = isArrayNonEmpty$1;
+/**
+* Returns the number of elements in a `ReadonlyArray`.
+*
+* **When to use**
+*
+* Use when you need length as a composable function rather than a property access.
+*
+* **Example** (Getting the length)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.length([1, 2, 3]) // => 3
+* ```
+*
+* @stability stable
+* @category getters
+* @since 2.0.0
+*/
+const length = (self) => self.length;
+/**
+* Checks whether a string represents a JavaScript array index: a non-negative
+* integer below `2 ** 32 - 1`, written without leading zeroes, a sign, or
+* exponent notation.
+*
+* @internal
+*/
+function isCanonicalArrayIndex(key) {
+	const index = Number(key);
+	return String(index) === key && Number.isInteger(index) && index >= 0 && index < 2 ** 32 - 1;
+}
+/** @internal */
+function isOutOfBounds(i, as) {
+	return !Number.isFinite(i) || i < 0 || i >= as.length;
+}
+/**
+* Reads an element at the given index safely, returning `Option.some` or
+* `Option.none` if the index is out of bounds.
+*
+* **When to use**
+*
+* Use when you need to read an array element by index and handle an
+* out-of-bounds index as `Option.none`.
+*
+* **Details**
+*
+* The index is floored to an integer. This never throws.
+*
+* **Example** (Accessing indexes safely)
+*
+* ```ts import.meta.vitest
+* import { Array, Option } from "effect"
+*
+* Array.get([1, 2, 3], 1) // => Option.some(2)
+* Array.get([1, 2, 3], 10) // => Option.none()
+* ```
+*
+* @see {@link getUnsafe} for indexed access that throws when the index is out of bounds
+* @see {@link head} for reading the first element as an `Option`
+* @see {@link last} for reading the last element as an `Option`
+*
+* @stability stable
+* @category getters
+* @since 2.0.0
+*/
+const get = /*#__PURE__*/ dual(2, (self, index) => {
+	const i = Math.floor(index);
+	return isOutOfBounds(i, self) ? none() : some$1(self[i]);
+});
+/**
+* Reads an element at the given index, throwing if the index is out of bounds.
+*
+* **When to use**
+*
+* Use to read an array element at a known valid index when out-of-bounds would
+* be a programming error.
+*
+* **Details**
+*
+* Throws an `Error` with the message `"Index out of bounds: <i>"`. Prefer
+* `get` for safe access.
+*
+* **Example** (Accessing indexes unsafely)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.getUnsafe([1, 2, 3], 1) // => 2
+* // Array.getUnsafe([1, 2, 3], 10) // throws Error
+* ```
+*
+* @see {@link get} — safe version returning `Option`
+*
+* @stability stable
+* @category unsafe
+* @since 4.0.0
+*/
+const getUnsafe = /*#__PURE__*/ dual(2, (self, index) => {
+	const i = Math.floor(index);
+	if (isOutOfBounds(i, self)) throw new Error(`Index out of bounds: ${i}`);
+	return self[i];
+});
+/**
+* Returns the first element of an array safely wrapped in `Option.some`, or
+* `Option.none` if the array is empty.
+*
+* **When to use**
+*
+* Use to safely get the first element of an array that may be empty.
+*
+* **Example** (Getting the first element)
+*
+* ```ts import.meta.vitest
+* import { Array, Option } from "effect"
+*
+* Array.head([1, 2, 3]) // => Option.some(1)
+* Array.head([]) // => Option.none()
+* ```
+*
+* @see {@link headNonEmpty} — direct access when array is known non-empty
+* @see {@link last} — get the last element
+*
+* @stability stable
+* @category getters
+* @since 2.0.0
+*/
+const head = /*#__PURE__*/ get(0);
+/**
+* Returns the first element of a `NonEmptyReadonlyArray` directly (no `Option`
+* wrapper).
+*
+* **When to use**
+*
+* Use to get the first element without `Option` wrapping when the array is known
+* to be non-empty.
+*
+* **Example** (Getting the head of a non-empty array)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.headNonEmpty([1, 2, 3, 4]) // => 1
+* ```
+*
+* @see {@link head} — safe version for possibly-empty arrays
+*
+* @stability stable
+* @category getters
+* @since 2.0.0
+*/
+const headNonEmpty = /*#__PURE__*/ getUnsafe(0);
+/**
+* Returns the last element of an array safely wrapped in `Option.some`, or
+* `Option.none` if the array is empty.
+*
+* **When to use**
+*
+* Use to safely get the last element of an array that may be empty.
+*
+* **Example** (Getting the last element)
+*
+* ```ts import.meta.vitest
+* import { Array, Option } from "effect"
+*
+* Array.last([1, 2, 3]) // => Option.some(3)
+* Array.last([]) // => Option.none()
+* ```
+*
+* @see {@link lastNonEmpty} — direct access when array is known non-empty
+* @see {@link head} — get the first element
+*
+* @stability stable
+* @category getters
+* @since 2.0.0
+*/
+const last = (self) => isReadonlyArrayNonEmpty(self) ? some$1(lastNonEmpty(self)) : none();
+/**
+* Returns the last element of a `NonEmptyReadonlyArray` directly (no `Option`
+* wrapper).
+*
+* **When to use**
+*
+* Use to get the last element without `Option` wrapping when the array is known
+* to be non-empty.
+*
+* **Example** (Getting the last of a non-empty array)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.lastNonEmpty([1, 2, 3, 4]) // => 4
+* ```
+*
+* @see {@link last} — safe version for possibly-empty arrays
+*
+* @stability stable
+* @category getters
+* @since 2.0.0
+*/
+const lastNonEmpty = (self) => self[self.length - 1];
+/**
+* Returns all elements except the first of a `NonEmptyReadonlyArray`.
+*
+* **When to use**
+*
+* Use to get all elements after the first when the array is known to be non-empty.
+*
+* **Example** (Getting the tail of a non-empty array)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.tailNonEmpty([1, 2, 3, 4]) // => [2, 3, 4]
+* ```
+*
+* @see {@link tail} — safe version for possibly-empty arrays
+* @see {@link initNonEmpty} — all elements except the last
+*
+* @stability stable
+* @category getters
+* @since 2.0.0
+*/
+const tailNonEmpty = (self) => self.slice(1);
+const clampCount = (n, length) => Math.min(normalize(n), length);
+/**
+* Keeps the first `n` elements, creating a new array.
+*
+* **When to use**
+*
+* Use to keep up to the first `n` elements from an iterable as a new array.
+*
+* **Details**
+*
+* `n` is rounded down and clamped to `[0, length]`. `NaN` is treated as `0`.
+* Returns an empty array when `n <= 0`.
+*
+* **Example** (Taking from the start)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.take([1, 2, 3, 4, 5], 3) // => [1, 2, 3]
+* ```
+*
+* @see {@link takeRight} for keeping elements from the end
+* @see {@link takeWhile} for keeping an initial prefix while a predicate holds
+* @see {@link drop} for removing elements from the start
+*
+* @stability stable
+* @category getters
+* @since 2.0.0
+*/
+const take = /*#__PURE__*/ dual(2, (self, n) => {
+	const input = fromIterable(self);
+	return input.slice(0, clampCount(n, input.length));
+});
+/**
+* Keeps the last `n` elements, creating a new array.
+*
+* **When to use**
+*
+* Use to keep the last `n` elements of an iterable.
+*
+* **Details**
+*
+* `n` is rounded down and clamped to `[0, length]`. `NaN` is treated as `0`.
+* Returns an empty array when `n <= 0`.
+*
+* **Example** (Taking from the end)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.takeRight([1, 2, 3, 4, 5], 3) // => [3, 4, 5]
+* ```
+*
+* @see {@link take} — keep from the start
+* @see {@link dropRight} — remove from the end
+*
+* @stability stable
+* @category getters
+* @since 2.0.0
+*/
+const takeRight = /*#__PURE__*/ dual(2, (self, n) => {
+	const input = fromIterable(self);
+	const i = clampCount(n, input.length);
+	return i === 0 ? [] : input.slice(-i);
+});
+/**
+* Takes elements from the start while the predicate holds, stopping at the
+* first element that fails.
+*
+* **When to use**
+*
+* Use to keep the leading elements of an iterable while each element satisfies
+* a predicate, returning the retained prefix as an array.
+*
+* **Details**
+*
+* Supports refinements for type narrowing. The predicate receives
+* `(element, index)`.
+*
+* **Example** (Taking while condition holds)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.takeWhile([1, 3, 2, 4, 1, 2], (x) => x < 4) // => [1, 3, 2]
+* ```
+*
+* @see {@link take} for keeping a fixed number of leading elements
+* @see {@link dropWhile} for removing the matching prefix and keeping the rest
+* @see {@link span} for splitting the matching prefix from the remaining elements
+*
+* @stability stable
+* @category getters
+* @since 2.0.0
+*/
+const takeWhile = /*#__PURE__*/ dual(2, (self, predicate) => {
+	let i = 0;
+	const out = [];
+	for (const a of self) {
+		if (!predicate(a, i)) break;
+		out.push(a);
+		i++;
+	}
+	return out;
+});
+/**
+* Removes the first `n` elements, creating a new array.
+*
+* **When to use**
+*
+* Use to keep the suffix of an iterable after skipping a fixed number of
+* leading elements.
+*
+* **Details**
+*
+* `n` is rounded down and clamped to `[0, length]`. `NaN` is treated as `0`.
+* When `n <= 0`, this returns a copy of the full array.
+*
+* **Example** (Dropping from the start)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.drop([1, 2, 3, 4, 5], 2) // => [3, 4, 5]
+* ```
+*
+* @see {@link dropRight} for removing a fixed number of elements from the end
+* @see {@link dropWhile} for removing a prefix based on a predicate instead of a fixed count
+* @see {@link take} for keeping a fixed number of elements from the start
+*
+* @stability stable
+* @category getters
+* @since 2.0.0
+*/
+const drop = /*#__PURE__*/ dual(2, (self, n) => {
+	const input = fromIterable(self);
+	return input.slice(clampCount(n, input.length), input.length);
+});
+/**
+* Returns the index of the first element matching the predicate, wrapped in an
+* `Option`.
+*
+* **When to use**
+*
+* Use to find the index of the first matching element from the start of an
+* iterable.
+*
+* **Example** (Finding an index)
+*
+* ```ts import.meta.vitest
+* import { Array, Option } from "effect"
+*
+* Array.findFirstIndex([5, 3, 8, 9], (x) => x > 5) // => Option.some(2)
+* ```
+*
+* @see {@link findLastIndex} — search from the end
+* @see {@link findFirst} — get the element itself
+*
+* @stability stable
+* @category searching
+* @since 2.0.0
+*/
+const findFirstIndex = /*#__PURE__*/ dual(2, (self, predicate) => {
+	let i = 0;
+	for (const a of self) {
+		if (predicate(a, i)) return some$1(i);
+		i++;
+	}
+	return none();
+});
+/**
+* Returns the first element matching a predicate, refinement, or mapping
+* function, wrapped in `Option`.
+*
+* **When to use**
+*
+* Use to scan an iterable in iteration order and return the first selected
+* element or mapped value as an `Option`.
+*
+* **Details**
+*
+* Accepts a predicate `(a, i) => boolean`, a refinement, or a function
+* `(a, i) => Option<B>` for simultaneous find-and-transform. If no element
+* matches, this returns `Option.none()`.
+*
+* **Example** (Finding the first match)
+*
+* ```ts import.meta.vitest
+* import { Array, Option } from "effect"
+*
+* Array.findFirst([1, 2, 3, 4, 5], (x) => x > 3) // => Option.some(4)
+* ```
+*
+* @see {@link findLast} — search from the end
+* @see {@link findFirstIndex} — get the index instead
+* @see {@link findFirstWithIndex} — get both element and index
+*
+* @stability stable
+* @category searching
+* @since 2.0.0
+*/
+const findFirst = findFirst$1;
+/**
+* Returns the last element matching a predicate, refinement, or mapping
+* function, wrapped in `Option`.
+*
+* **When to use**
+*
+* Use to find the last matching element from the end of an array.
+*
+* **Details**
+*
+* Searches from the end of the array. If no element matches, this returns
+* `Option.none()`.
+*
+* **Example** (Finding the last match)
+*
+* ```ts import.meta.vitest
+* import { Array, Option } from "effect"
+*
+* Array.findLast([1, 2, 3, 4, 5], (n) => n % 2 === 0) // => Option.some(4)
+* ```
+*
+* @see {@link findFirst} — search from the start
+* @see {@link findLastIndex} — get the index instead
+*
+* @stability stable
+* @category searching
+* @since 2.0.0
+*/
+const findLast = /*#__PURE__*/ dual(2, (self, f) => {
+	const input = fromIterable(self);
+	for (let i = input.length - 1; i >= 0; i--) {
+		const a = input[i];
+		const o = f(a, i);
+		if (typeof o === "boolean") {
+			if (o) return some$1(a);
+		} else if (isSome(o)) return o;
+	}
+	return none();
+});
+/**
+* Sorts an array by the given `Order`, returning a new array.
+*
+* **When to use**
+*
+* Use to sort an array using a single `Order` comparator.
+*
+* **Details**
+*
+* Preserves `NonEmptyArray` in the return type. Use `sortWith` to sort by a
+* derived key, or `sortBy` for multi-key sorting.
+*
+* **Example** (Sorting numbers)
+*
+* ```ts import.meta.vitest
+* import { Array, Order } from "effect"
+*
+* Array.sort([3, 1, 4, 1, 5], Order.Number) // => [1, 1, 3, 4, 5]
+* ```
+*
+* @see {@link sortWith} — sort by a mapping function
+* @see {@link sortBy} — sort by multiple orders
+*
+* @stability stable
+* @category sorting
+* @since 2.0.0
+*/
+const sort = /*#__PURE__*/ dual(2, (self, O) => {
+	const out = Array$1.from(self);
+	out.sort(O);
+	return out;
+});
+/**
+* Sorts an array by a derived key using a mapping function and an `Order` for
+* that key.
+*
+* **When to use**
+*
+* Use when you need to sort values by a derived key, such as a string length or
+* object field, while keeping the original values.
+*
+* **Details**
+*
+* Equivalent to `sort(Order.mapInput(order, f))`, but more convenient.
+*
+* **Example** (Sorting strings by length)
+*
+* ```ts import.meta.vitest
+* import { Array, Order } from "effect"
+*
+* Array.sortWith(["aaa", "b", "cc"], (s) => s.length, Order.Number) // => ["b", "cc", "aaa"]
+* ```
+*
+* @see {@link sort} for sorting with an `Order` that compares the elements directly
+* @see {@link sortBy} for sorting with multiple `Order`s applied in sequence
+*
+* @stability stable
+* @category sorting
+* @since 2.0.0
+*/
+const sortWith = /*#__PURE__*/ dual(3, (self, f, order) => Array$1.from(self).map((a) => [a, f(a)]).sort(([, a], [, b]) => order(a, b)).map(([_]) => _));
+/**
+* Pairs elements from two iterables by position. If the iterables differ in
+* length, the extra elements from the longer one are discarded.
+*
+* **When to use**
+*
+* Use when you need simple pairs of corresponding elements from two iterables.
+*
+* **Details**
+*
+* Returns `NonEmptyArray` when both inputs are non-empty.
+*
+* **Example** (Zipping two arrays)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.zip([1, 2, 3], ["a", "b"]) // => [[1, "a"], [2, "b"]]
+* ```
+*
+* @see {@link zipWith} — zip with a combiner function
+* @see {@link unzip} — inverse operation
+*
+* @stability stable
+* @category zipping
+* @since 2.0.0
+*/
+const zip = /*#__PURE__*/ dual(2, (self, that) => zipWith(self, that, make));
+/**
+* Combines elements from two iterables pairwise using a function. If the
+* iterables differ in length, extra elements are discarded.
+*
+* **When to use**
+*
+* Use when zipping two iterables in an array pipeline and each pair should
+* become a computed array element instead of a tuple.
+*
+* **Example** (Zipping with addition)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.zipWith([1, 2, 3], [4, 5, 6], (a, b) => a + b) // => [5, 7, 9]
+* ```
+*
+* @see {@link zip} — zip into tuples
+*
+* @stability stable
+* @category zipping
+* @since 2.0.0
+*/
+const zipWith = /*#__PURE__*/ dual(3, (self, that, f) => {
+	const as = fromIterable(self);
+	const bs = fromIterable(that);
+	if (isReadonlyArrayNonEmpty(as) && isReadonlyArrayNonEmpty(bs)) {
+		const out = [f(headNonEmpty(as), headNonEmpty(bs))];
+		const len = Math.min(as.length, bs.length);
+		for (let i = 1; i < len; i++) out[i] = f(as[i], bs[i]);
+		return out;
+	}
+	return [];
+});
+/**
+* Returns a membership-test function using a custom equivalence.
+*
+* **When to use**
+*
+* Use when checking membership with caller-provided equality instead of
+* `Equal.asEquivalence()`.
+*
+* **Example** (Checking with custom equality)
+*
+* ```ts import.meta.vitest
+* import { Array, pipe } from "effect"
+*
+* const containsNumber = Array.containsWith((a: number, b: number) => a === b)
+*
+* pipe([1, 2, 3, 4], containsNumber(3)) // => true
+* ```
+*
+* @see {@link contains} for the `Equal.asEquivalence()` variant
+*
+* @stability stable
+* @category predicates
+* @since 2.0.0
+*/
+const containsWith = (isEquivalent) => dual(2, (self, a) => {
+	for (const i of self) if (isEquivalent(a, i)) return true;
+	return false;
+});
+/**
+* Checks whether an array contains a value, using `Equal.asEquivalence()` for
+* comparison.
+*
+* **When to use**
+*
+* Use to check whether an iterable contains a value using Effect's default
+* equality instead of providing a comparison function.
+*
+* **Example** (Checking membership)
+*
+* ```ts import.meta.vitest
+* import { Array, pipe } from "effect"
+*
+* pipe(["a", "b", "c", "d"], Array.contains("c")) // => true
+* ```
+*
+* @see {@link containsWith} — use custom equality
+*
+* @stability stable
+* @category predicates
+* @since 2.0.0
+*/
+const contains = /*#__PURE__*/ containsWith(/*#__PURE__*/ asEquivalence());
+/**
+* Groups elements into a record by a key-returning function. Each key maps
+* to a `NonEmptyArray` of elements that produced that key.
+*
+* **When to use**
+*
+* Use to build buckets of elements indexed by a computed string or symbol key.
+*
+* **Details**
+*
+* Unlike `group` and `groupWith`, elements do not need to be adjacent to be
+* grouped together. The key function must return a `string` or `symbol`.
+*
+* **Gotchas**
+*
+* When the key function returns a finite union of string literals or unique
+* symbols, the result preserves those keys as optional properties because the
+* input may not produce every key. Open `string` and `symbol` key types retain
+* their record index signatures.
+*
+* **Example** (Grouping by a property)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* const people = [
+*   { name: "Alice", group: "A" },
+*   { name: "Bob", group: "B" },
+*   { name: "Charlie", group: "A" }
+* ]
+*
+* Object.keys(Array.groupBy(people, (person) => person.group)).join(",") // => "A,B"
+* ```
+*
+* @see {@link group} — group adjacent equal elements
+* @see {@link groupWith} — group adjacent elements by custom equality
+*
+* @stability stable
+* @category grouping
+* @since 2.0.0
+*/
+const groupBy = /*#__PURE__*/ dual(2, (self, f) => {
+	const out = {};
+	for (const a of self) {
+		const k = f(a);
+		if (Object.hasOwn(out, k)) out[k].push(a);
+		else assignProperty(out, k, [a]);
+	}
+	return out;
+});
+const hashBucketsAdd = (buckets, value) => {
+	const hash$1 = hash(value);
+	const bucket = buckets.get(hash$1);
+	if (bucket === void 0) {
+		buckets.set(hash$1, [value]);
+		return true;
+	}
+	for (const previous of bucket) if (equals(previous, value)) return false;
+	bucket.push(value);
+	return true;
+};
+/**
+* Creates an empty array.
+*
+* **When to use**
+*
+* Use to create a typed empty array without allocating placeholder elements.
+*
+* **Example** (Creating an empty array)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.empty<number>() // => []
+* ```
+*
+* @see {@link of} — create a single-element array
+* @see {@link make} — create from multiple values
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const empty = () => [];
+/**
+* Wraps a single value in a `NonEmptyArray`.
+*
+* **Example** (Creating a single-element array)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.of(1) // => [1]
+* ```
+*
+* @see {@link make} — create from multiple values
+* @see {@link empty} — create an empty array
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const of = (a) => [a];
+/**
+* Transforms each element using a function, returning a new array.
+*
+* **When to use**
+*
+* Use to transform each element independently while preserving the array shape.
+*
+* **Details**
+*
+* The function receives `(element, index)`. The return type preserves
+* `NonEmptyArray`.
+*
+* **Example** (Doubling values)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.map([1, 2, 3], (x) => x * 2) // => [2, 4, 6]
+* ```
+*
+* @see {@link flatMap} — map and flatten
+*
+* @stability stable
+* @category mapping
+* @since 2.0.0
+*/
+const map = /*#__PURE__*/ dual(2, (self, f) => self.map(f));
+/**
+* Maps each element to an array and flattens the results into a single array.
+*
+* **When to use**
+*
+* Use to map each array element to zero or more values and concatenate the
+* results in one pass.
+*
+* **Details**
+*
+* The function receives `(element, index)`. This returns `NonEmptyArray` when
+* both the input and mapped arrays are non-empty.
+*
+* **Example** (Flat mapping an array)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.flatMap([1, 2, 3], (x) => [x, x * 2]) // => [1, 2, 2, 4, 3, 6]
+* ```
+*
+* @see {@link map} — transform without flattening
+* @see {@link flatten} — flatten without mapping
+*
+* @stability stable
+* @category sequencing
+* @since 2.0.0
+*/
+const flatMap = /*#__PURE__*/ dual(2, (self, f) => {
+	if (isReadonlyArrayEmpty(self)) return [];
+	const out = [];
+	for (let i = 0; i < self.length; i++) {
+		const inner = f(self[i], i);
+		for (let j = 0; j < inner.length; j++) out.push(inner[j]);
+	}
+	return out;
+});
+/**
+* Flattens a nested array of arrays into a single array.
+*
+* **When to use**
+*
+* Use to collapse one level of nested arrays when no per-element mapping is
+* needed.
+*
+* **Example** (Flattening nested arrays)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.flatten([[1, 2], [], [3, 4], [], [5, 6]]) // => [1, 2, 3, 4, 5, 6]
+* ```
+*
+* @see {@link flatMap} — map then flatten in one step
+*
+* @stability stable
+* @category sequencing
+* @since 2.0.0
+*/
+const flatten = /*#__PURE__*/ flatMap(identity);
+/**
+* Extracts all `Some` values from an iterable of `Option`s, discarding `None`s.
+*
+* **When to use**
+*
+* Use to collect only present values from an iterable of `Option` values while
+* discarding `None` values.
+*
+* **Example** (Extracting Some values)
+*
+* ```ts import.meta.vitest
+* import { Array, Option } from "effect"
+*
+* Array.getSomes([Option.some(1), Option.none(), Option.some(2)]) // => [1, 2]
+* ```
+*
+* @see {@link fromOption} — convert a single Option
+* @see {@link getSuccesses} — extract successes from Results
+*
+* @stability stable
+* @category filtering
+* @since 2.0.0
+*/
+const getSomes = (self) => {
+	const out = [];
+	for (const a of self) if (isSome(a)) out.push(a.value);
+	return out;
+};
+/**
+* Keeps only elements satisfying a predicate (or refinement).
+*
+* **When to use**
+*
+* Use to filter an iterable into a new array of original elements that satisfy
+* a boolean predicate or refinement.
+*
+* **Details**
+*
+* The predicate receives `(element, index)`. Refinements are supported for type
+* narrowing.
+*
+* **Example** (Filtering even numbers)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.filter([1, 2, 3, 4], (x) => x % 2 === 0) // => [2, 4]
+* ```
+*
+* @see {@link partition} — split into matching and non-matching
+* @see {@link filterMap} for transforming while filtering
+*
+* @stability stable
+* @category filtering
+* @since 2.0.0
+*/
+const filter = /*#__PURE__*/ dual(2, (self, predicate) => {
+	const as = fromIterable(self);
+	const out = [];
+	for (let i = 0; i < as.length; i++) if (predicate(as[i], i)) out.push(as[i]);
+	return out;
+});
+/**
+* Splits an iterable using a `Filter` into successes and failures.
+*
+* **When to use**
+*
+* Use to partition an iterable by evaluating each element with a
+* `Result`-returning filter and keeping both success and failure values.
+*
+* **Details**
+*
+* Returns `[passes, fails]`. The filter receives `(element, index)`.
+*
+* **Example** (Partitioning with a filter)
+*
+* ```ts import.meta.vitest
+* import { Array, Result } from "effect"
+*
+* Array.partition([1, -2, 3], (n, i) =>
+*   n > 0 ? Result.succeed(n + i) : Result.fail(`negative:${n}`)
+* ) // => [[1, 5], ["negative:-2"]]
+* ```
+*
+* @see {@link filter} — keep only matching elements
+* @see {@link filterMap} for discarding failures
+* @see {@link separate} — split an iterable of `Result` values
+*
+* @stability stable
+* @category filtering
+* @since 2.0.0
+*/
+const partition = /*#__PURE__*/ dual(2, (self, f) => {
+	const passes = [];
+	const fails = [];
+	let i = 0;
+	for (const a of self) {
+		const result = f(a, i++);
+		if (isSuccess(result)) passes.push(result.success);
+		else fails.push(result.failure);
+	}
+	return [passes, fails];
+});
+/**
+* Folds an iterable from left to right into a single value.
+*
+* **When to use**
+*
+* Use to combine all elements into one accumulated value from left to right.
+*
+* **Details**
+*
+* The function receives `(accumulator, element, index)`.
+*
+* **Example** (Summing an array)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.reduce([1, 2, 3], 0, (acc, n) => acc + n) // => 6
+* ```
+*
+* @see {@link reduceRight} — fold from right to left
+* @see {@link scan} — fold keeping intermediate values
+*
+* @stability stable
+* @category folding
+* @since 2.0.0
+*/
+const reduce = /*#__PURE__*/ dual(3, (self, b, f) => fromIterable(self).reduce((b, a, i) => f(b, a, i), b));
+/**
+* Checks whether all elements satisfy the predicate. Supports refinements for
+* type narrowing.
+*
+* **When to use**
+*
+* Use to check whether every array element satisfies a predicate, including
+* refinement-based type narrowing.
+*
+* **Example** (Testing all elements)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.every([2, 4, 6], (x) => x % 2 === 0) // => true
+* Array.every([2, 3, 6], (x) => x % 2 === 0) // => false
+* ```
+*
+* @see {@link some} — test if any element matches
+*
+* @stability stable
+* @category guards
+* @since 2.0.0
+*/
+const every = /*#__PURE__*/ dual(2, (self, refinement) => self.every(refinement));
+/**
+* Checks whether at least one element satisfies the predicate. Narrows the type
+* to `NonEmptyReadonlyArray` on success.
+*
+* **Example** (Testing for any match)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.some([1, 3, 4], (x) => x % 2 === 0) // => true
+* Array.some([1, 3, 5], (x) => x % 2 === 0) // => false
+* ```
+*
+* @see {@link every} — test if all elements match
+* @see {@link contains} — test for a specific value
+*
+* @stability stable
+* @category guards
+* @since 2.0.0
+*/
+const some = /*#__PURE__*/ dual(2, (self, predicate) => self.some(predicate));
+/**
+* Returns the minimum element of a non-empty array according to the given
+* `Order`.
+*
+* **Example** (Finding the minimum)
+*
+* ```ts import.meta.vitest
+* import { Array, Order } from "effect"
+*
+* Array.min([3, 1, 2], Order.Number) // => 1
+* ```
+*
+* @see {@link max} — find the maximum
+* @see {@link sort} — sort the entire array
+*
+* @stability stable
+* @category getters
+* @since 2.0.0
+*/
+const min = /*#__PURE__*/ dual(2, (self, O) => self.reduce(min$1(O)));
+/**
+* Builds an array by repeatedly applying a function to a seed value. The
+* function returns `Option.some([element, nextSeed])` to continue, or
+* `Option.none()` to stop.
+*
+* **Example** (Generating a sequence)
+*
+* ```ts import.meta.vitest
+* import { Array, Option } from "effect"
+*
+* Array.unfold(1, (n) => n <= 5 ? Option.some([n, n + 1]) : Option.none()) // => [1, 2, 3, 4, 5]
+* ```
+*
+* @see {@link makeBy} — generate from index
+* @see {@link range} — generate a numeric range
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const unfold = (b, f) => {
+	const out = [];
+	let next = b;
+	while (true) {
+		const o = f(next);
+		if (isNone$1(o)) break;
+		const [a, b] = o.value;
+		out.push(a);
+		next = b;
+	}
+	return out;
+};
+/**
+* Creates an `Equivalence` for arrays based on an element `Equivalence`. Two
+* arrays are equivalent when they have the same length and all elements are
+* pairwise equivalent.
+*
+* **Example** (Comparing arrays for equality)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* const eq = Array.makeEquivalence<number>((a, b) => a === b)
+*
+* eq([1, 2, 3], [1, 2, 3]) // => true
+* ```
+*
+* @see {@link makeOrder} — create an ordering for arrays
+*
+* @stability stable
+* @category instances
+* @since 4.0.0
+*/
+const makeEquivalence = Array_;
+/**
+* Removes duplicates using `Equal.asEquivalence()`, preserving the order of the
+* first occurrence.
+*
+* **When to use**
+*
+* Use to remove repeated values from an iterable when Effect's default equality
+* is the right comparison, preserving the first occurrence.
+*
+* **Example** (Removing duplicates)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.dedupe([1, 2, 1, 3, 2, 4]) // => [1, 2, 3, 4]
+* ```
+*
+* @see {@link dedupeWith} — use custom equality
+* @see {@link dedupeAdjacent} — only dedupes consecutive elements
+*
+* @stability stable
+* @category deduplication
+* @since 2.0.0
+*/
+const dedupe = (self) => {
+	const input = fromIterable(self);
+	if (input.length < 2) return [...input];
+	const buckets = /* @__PURE__ */ new Map();
+	const out = [];
+	for (const value of input) if (hashBucketsAdd(buckets, value)) out.push(value);
+	return out;
+};
+/**
+* Joins string elements with a separator.
+*
+* **Example** (Joining strings)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.join(["a", "b", "c"], "-") // => "a-b-c"
+* ```
+*
+* @see {@link intersperse} — insert separator elements without joining
+*
+* @stability stable
+* @category folding
+* @since 2.0.0
+*/
+const join = /*#__PURE__*/ dual(2, (self, sep) => fromIterable(self).join(sep));
+export { isFailure as $, makeEquivalence as A, sortWith as B, isReadonlyArrayEmpty as C, lastNonEmpty as D, last as E, of as F, zip as G, takeRight as H, partition as I, makeEquivalence$1 as J, empty$1 as K, reduce as L, match as M, matchLeft as N, length as O, min as P, getOrThrow as Q, some as R, isCanonicalArrayIndex as S, join as T, takeWhile as U, take as V, unfold as W, flatMap$1 as X, fail as Y, fromOption as Z, getSomes as _, drop as a, succeed as at, isArray as b, every as c, normalizeNonEmpty as ct, findFirstIndex as d, strictEqual as dt, isResult as et, findLast as f, get as g, fromIterable as h, dedupe as i, match$1 as it, map as j, makeBy as k, filter as l, isArrayNonEmpty$1 as lt, flatten as m, appendAll as n, map$1 as nt, empty as o, try_ as ot, flatMap as p, headUnsafe as q, contains as r, mapError as rt, ensure as s, normalize as st, append as t, isSuccess as tt, findFirst as u, make$1 as ut, groupBy as v, isReadonlyArrayNonEmpty as w, isArrayNonEmpty as x, head as y, sort as z };