@deslop/coding-standards 0.1.1077 → 0.1.1079

package/dist/{MutableRef-KfyWrSvW.mjs → MutableList-BCF17jPH.mjs}

@@ -1,4 +1,4 @@
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/Pipeable.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Pipeable.js
 /**
 * The `Pipeable` module defines the shared interface and implementation helpers
 * for values that support Effect-style method chaining with `.pipe(...)`.
@@ -104,7 +104,7 @@ const Class$1 = /*#__PURE__*/ function() {
 	return PipeableBase;
 }();
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/Function.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Function.js
 /**
 * Creates a function that can be called in data-first style or data-last
 * (`pipe`-friendly) style.
@@ -399,7 +399,7 @@ function memoizeIdempotent(f) {
 	};
 }
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/internal/equal.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/equal.js
 /** @internal */
 const getAllObjectKeys = (obj) => {
 	const keys = new Set(Reflect.ownKeys(obj));
@@ -420,7 +420,7 @@ const byReferenceInstances = /*#__PURE__*/ new WeakSet();
 /** @internal */
 const viewBytes = (view) => new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/internal/hash.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/hash.js
 /**
 * Back-edge count used to avoid caching entry-point-dependent hashes.
 *
@@ -432,7 +432,7 @@ const addBackEdge = () => {
 	backEdges++;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/Predicate.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Predicate.js
 /**
 * Defines runtime checks for values.
 *
@@ -1066,8 +1066,37 @@ function isError(input) {
 function isIterable(input) {
 	return hasProperty(input, Symbol.iterator) || isString(input);
 }
+/**
+* Checks whether a value is a `RegExp`.
+*
+* **When to use**
+*
+* Use when you need a `Predicate` runtime guard for regular expressions.
+*
+* **Details**
+*
+* Uses `instanceof RegExp`.
+*
+* **Example** (Guarding RegExp values)
+*
+* ```ts import.meta.vitest
+* import { Predicate } from "effect"
+*
+* const data: unknown = /abc/
+*
+* Predicate.isRegExp(data) // => true
+* ```
+*
+* @see {@link isDate}
+* @stability stable
+* @category guards
+* @since 3.9.0
+*/
+function isRegExp(input) {
+	return input instanceof RegExp;
+}
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/Hash.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Hash.js
 /**
 * Computes Effect hash values and defines the interface for objects that want
 * to provide their own hash implementation. Hashes are small numeric
@@ -1463,7 +1492,7 @@ const randomHashCache = /*#__PURE__*/ new WeakMap();
 const hashCache = /*#__PURE__*/ new WeakMap();
 const visitedObjects = /*#__PURE__*/ new WeakSet();
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/Equal.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Equal.js
 /**
 * Defines the unique string identifier for the `Equal` interface.
 *
@@ -1728,7 +1757,7 @@ const byReferenceUnsafe = (obj) => {
 	return obj;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/Redactable.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Redactable.js
 /**
 * Defines the symbol used to identify objects that implement the {@link Redactable}
 * protocol.
@@ -1851,7 +1880,7 @@ const emptyContext = {
 	}
 };
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/Formatter.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Formatter.js
 /**
 * Formats JavaScript values into readable strings.
 *
@@ -2127,7 +2156,7 @@ function isJsonPrimitiveWrapper(object) {
 	return false;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/Inspectable.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Inspectable.js
 /**
 * Controls how values appear in logs and debugging output.
 *
@@ -2281,7 +2310,7 @@ const BaseProto = {
 	}
 };
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/internal/stackTraceLimit.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/stackTraceLimit.js
 /**
 * Check if `Error.stackTraceLimit` is writable.
 * Returns `false` if the property is frozen, non-writable, or `Error` is non-extensible.
@@ -2313,7 +2342,7 @@ const setStackTraceLimit = (value) => {
 	if (canWriteStackTraceLimit) Error.stackTraceLimit = value;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/Utils.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Utils.js
 /**
 * Yields its wrapped value exactly once, then completes with the value sent
 * back in.
@@ -2396,7 +2425,7 @@ const pickInternalCall = () => {
 /** @internal */
 const internalCall = /*#__PURE__*/ pickInternalCall();
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/internal/record.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/record.js
 /** @internal */
 function assignProperty(self, key, value) {
 	if (key === "__proto__") Object.defineProperty(self, key, {
@@ -2412,7 +2441,7 @@ function assignProperties(self, source) {
 	for (const key of Reflect.ownKeys(source)) if (Object.prototype.propertyIsEnumerable.call(source, key)) assignProperty(self, key, source[key]);
 }
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/internal/core.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/core.js
 /** @internal */
 const EffectTypeId = `~effect/Effect`;
 /** @internal */
@@ -2590,6 +2619,18 @@ const causeCombine = /*#__PURE__*/ dual(2, (self, that) => {
 	const newCause = new CauseImpl(dedupeReasons(self.reasons, that.reasons));
 	return equals(self, newCause) ? self : newCause;
 });
+/**
+* Appends the interrupts from `interrupts` that `self` does not contain yet.
+* Unlike `causeCombine`, it never calls hash or equality methods, which can be
+* user-defined, random, or throwing.
+*
+* @internal
+*/
+const causeAddInterrupts = (self, interrupts) => {
+	const reasons = self.reasons.slice();
+	for (const reason of interrupts.reasons) if (isInterruptReason(reason) && !reasons.some((r) => isInterruptReason(r) && r.fiberId === reason.fiberId && r.annotations === reason.annotations)) reasons.push(reason);
+	return reasons.length === self.reasons.length ? self : new CauseImpl(reasons);
+};
 /** @internal */
 const causeEmpty = /*#__PURE__*/ new CauseImpl([]);
 /** @internal */
@@ -2719,7 +2760,7 @@ const exitFailCause = /*#__PURE__*/ makeExit({
 				cont = fiber.getCont(contE);
 			}
 			if (skippedHandler) cause = causeFromReasons(cause.reasons.filter((reason) => reason._tag !== "Fail"));
-			cause = causeCombine(cause, interruptedCause);
+			cause = causeAddInterrupts(cause, interruptedCause);
 			annotated = true;
 		}
 		return cont ? cont[contE](cause, fiber, annotated ? void 0 : this) : fiber.yieldWith(annotated ? exitFailCause(cause) : this);
@@ -2804,7 +2845,7 @@ const done = (value) => {
 	return exitFail(Done(value));
 };
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/Equivalence.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Equivalence.js
 /**
 * Creates a custom equivalence relation with an optimized reference equality check.
 *
@@ -2854,7 +2895,7 @@ const done = (value) => {
 * @category constructors
 * @since 2.0.0
 */
-const make$2 = (isEquivalent) => (self, that) => self === that || isEquivalent(self, that);
+const make$3 = (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.
@@ -2964,7 +3005,7 @@ const strictEqual = () => isStrictEquivalent;
 * @since 4.0.0
 */
 function Tuple(elements) {
-	return make$2((self, that) => {
+	return make$3((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;
@@ -2974,14 +3015,14 @@ function Tuple(elements) {
 * @since 4.0.0
 */
 function Array_(item) {
-	return make$2((self, that) => {
+	return make$3((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;
 	});
 }
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/internal/option.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/option.js
 /**
 * @since 2.0.0
 */
@@ -3052,7 +3093,7 @@ SomeImpl.prototype = SomeProto;
 /** @internal */
 const some$2 = (value) => new SomeImpl(value);
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/internal/result.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/result.js
 const TypeId$1 = "~effect/Result";
 const CommonProto = {
 	[TypeId$1]: {
@@ -3128,7 +3169,7 @@ const succeed$1 = (success) => new SuccessImpl(success);
 /** @internal */
 const fromOption$1 = /*#__PURE__*/ dual(2, (self, onNone) => isNone$1(self) ? fail$1(onNone()) : succeed$1(self.value));
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/Order.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Order.js
 /**
 * Defines comparison functions for ordered values.
 *
@@ -3178,7 +3219,7 @@ const fromOption$1 = /*#__PURE__*/ dual(2, (self, onNone) => isNone$1(self) ? fa
 * @category constructors
 * @since 2.0.0
 */
-function make$1(compare) {
+function make$2(compare) {
 	return (self, that) => self === that ? 0 : compare(self, that);
 }
 /**
@@ -3209,7 +3250,7 @@ function make$1(compare) {
 * @category instances
 * @since 4.0.0
 */
-const String$2 = /*#__PURE__*/ make$1((self, that) => self < that ? -1 : 1);
+const String$2 = /*#__PURE__*/ make$2((self, that) => self < that ? -1 : 1);
 /**
 * Order instance for numbers that compares them numerically.
 *
@@ -3242,7 +3283,7 @@ const String$2 = /*#__PURE__*/ make$1((self, that) => self < that ? -1 : 1);
 * @category instances
 * @since 4.0.0
 */
-const Number$1 = /*#__PURE__*/ make$1((self, that) => {
+const Number$1 = /*#__PURE__*/ make$2((self, that) => {
 	if (globalThis.Number.isNaN(self) && globalThis.Number.isNaN(that)) return 0;
 	if (globalThis.Number.isNaN(self)) return -1;
 	if (globalThis.Number.isNaN(that)) return 1;
@@ -3276,7 +3317,7 @@ const Number$1 = /*#__PURE__*/ make$1((self, that) => {
 * @category instances
 * @since 4.0.0
 */
-const BigInt = /*#__PURE__*/ make$1((self, that) => self < that ? -1 : 1);
+const BigInt = /*#__PURE__*/ make$2((self, that) => self < that ? -1 : 1);
 /**
 * Transforms an `Order` on type `A` into an `Order` on type `B` by providing a function that
 * maps values of type `B` to values of type `A`.
@@ -3310,7 +3351,7 @@ const BigInt = /*#__PURE__*/ make$1((self, that) => self < that ? -1 : 1);
 * @category mapping
 * @since 2.0.0
 */
-const mapInput = /*#__PURE__*/ dual(2, (self, f) => make$1((b1, b2) => self(f(b1), f(b2))));
+const mapInput = /*#__PURE__*/ dual(2, (self, f) => make$2((b1, b2) => self(f(b1), f(b2))));
 /**
 * Order instance for `Date` objects that compares them chronologically by their timestamp.
 *
@@ -3469,7 +3510,7 @@ const isLessThanOrEqualTo = (O) => dual(2, (self, that) => O(self, that) !== 1);
 */
 const isGreaterThanOrEqualTo = (O) => dual(2, (self, that) => O(self, that) !== -1);
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/Option.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Option.js
 /**
 * Creates an `Option` representing the absence of a value.
 *
@@ -4103,6 +4144,35 @@ const all = (input) => {
 */
 const zipWith = /*#__PURE__*/ dual(3, (self, that, f) => map$3(product(self, that), ([a, b]) => f(a, b)));
 /**
+* Converts an `Option` into an `Array`.
+*
+* **When to use**
+*
+* Use when you need to pass an `Option` to array-based APIs or spread optional
+* values into collections.
+*
+* **Details**
+*
+* - `Some` → single-element array `[value]`
+* - `None` → empty array `[]`
+*
+* **Example** (Converting to an array)
+*
+* ```ts import.meta.vitest
+* import { Option } from "effect"
+*
+* Option.toArray(Option.some(1)) // => [1]
+* Option.toArray(Option.none()) // => []
+* ```
+*
+* @see {@link fromIterable} for the inverse direction
+*
+* @stability stable
+* @category converting
+* @since 2.0.0
+*/
+const toArray$1 = (self) => isNone(self) ? [] : [self.value];
+/**
 * Filters an `Option` using a predicate. Returns `None` if the predicate is
 * not satisfied or the input is `None`.
 *
@@ -4239,14 +4309,14 @@ const contains$1 = /*#__PURE__*/ containsWith$1(/*#__PURE__*/ asEquivalence());
 */
 const exists = /*#__PURE__*/ dual(2, (self, refinement) => isNone(self) ? false : refinement(self.value));
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/internal/array.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/array.js
 /**
 * @since 2.0.0
 */
 /** @internal */
 const isArrayNonEmpty$1 = (self) => self.length > 0;
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/internal/count.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/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.
@@ -4255,7 +4325,7 @@ const isArrayNonEmpty$1 = (self) => self.length > 0;
 */
 const normalize = (n) => n > 0 ? Math.floor(n) : 0;
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/Result.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Result.js
 /**
 * Creates a `Result` holding a `Success` value.
 *
@@ -4547,7 +4617,7 @@ const getOrThrow = /*#__PURE__*/ (/* @__PURE__ */ dual(2, (self, onFailure) => {
 */
 const flatMap$1 = /*#__PURE__*/ dual(2, (self, f) => isFailure(self) ? fail(self.failure) : f(self.success));
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/Iterable.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Iterable.js
 /**
 * Returns the first element that satisfies the specified
 * predicate, or `None` if no such element exists.
@@ -4601,7 +4671,7 @@ const findFirst$1 = /*#__PURE__*/ dual(2, (self, f) => {
 	return none();
 });
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/Record.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Record.js
 /**
 * Builds a record from an iterable of key-value pairs.
 *
@@ -4768,8 +4838,63 @@ const keys = (self) => Object.keys(self);
 * @since 2.0.0
 */
 const values = (self) => collect(self, (_, a) => a);
+/**
+* Checks whether all the keys and values in one record are also found in another record.
+* Uses the provided equivalence function to compare values.
+*
+* **Example** (Checking subrecords with a custom equivalence)
+*
+* ```ts import.meta.vitest
+* import { Equivalence, Record } from "effect"
+*
+* const isSubrecord = Record.isSubrecordBy(
+*   Equivalence.make<string>((self, that) => self.toLowerCase() === that.toLowerCase())
+* )
+*
+* const required: Record.ReadonlyRecord<string, string> = { role: "Admin" }
+* const available: Record.ReadonlyRecord<string, string> = {
+*   role: "admin",
+*   status: "active"
+* }
+*
+* isSubrecord(required, available) // => true
+* isSubrecord({ role: "Admin", status: "inactive" }, available) // => false
+* isSubrecord(required, { role: "editor", status: "active" }) // => false
+* ```
+*
+* @stability stable
+* @category predicates
+* @since 2.0.0
+*/
+const isSubrecordBy = (equivalence) => dual(2, (self, that) => {
+	for (const key of keys(self)) if (!has(that, key) || !equivalence(self[key], that[key])) return false;
+	return true;
+});
+/**
+* Create an `Equivalence` for records using the provided `Equivalence` for values.
+* Two records are considered equivalent if they have the same keys and their corresponding values are equivalent.
+*
+* **Example** (Comparing records with a value equivalence)
+*
+* ```ts import.meta.vitest
+* import { Equal, Record } from "effect"
+*
+* const recordEquivalence = Record.makeEquivalence(Equal.asEquivalence<number>())
+*
+* recordEquivalence({ a: 1, b: 2 }, { a: 1, b: 2 }) // => true
+* recordEquivalence({ a: 1, b: 2 }, { a: 1, b: 3 }) // => false
+* ```
+*
+* @stability stable
+* @category instances
+* @since 4.0.0
+*/
+const makeEquivalence$1 = (equivalence) => {
+	const is = isSubrecordBy(equivalence);
+	return (self, that) => is(self, that) && is(that, self);
+};
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/Array.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Array.js
 /**
 * Works with JavaScript arrays, readonly arrays, and non-empty arrays.
 *
@@ -4872,8 +4997,10 @@ const ensure = (self) => Array$1.isArray(self) ? self : [self];
 *
 * **Details**
 *
-* `onNonEmpty` receives a `NonEmptyReadonlyArray`. Supports both data-first and
-* data-last usage.
+* `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)
 *
@@ -4898,6 +5025,41 @@ const ensure = (self) => Array$1.isArray(self) ? self : [self];
 */
 const match$1 = /*#__PURE__*/ dual(2, (self, { onEmpty, onNonEmpty }) => isReadonlyArrayNonEmpty(self) ? onNonEmpty(self) : onEmpty());
 /**
+* Pattern-matches on an array from the right, providing all elements except the
+* last and the last element separately.
+*
+* **When to use**
+*
+* Use when you need to branch on an array and handle the non-empty case as the
+* elements before the last plus the last element.
+*
+* **Details**
+*
+* `onNonEmpty` receives `(init, last)` where `init` is everything but the last element.
+*
+* **Example** (Destructuring init and last)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* const matchRight = Array.matchRight({
+*   onEmpty: () => "empty",
+*   onNonEmpty: (init, last) => `init: ${init.length}, last: ${last}`
+* })
+*
+* matchRight([]) // => "empty"
+* matchRight([1, 2, 3]) // => "init: 2, last: 3"
+* ```
+*
+* @see {@link match} — receives the full non-empty array
+* @see {@link matchLeft} — destructures into head + tail
+*
+* @stability stable
+* @category pattern matching
+* @since 2.0.0
+*/
+const matchRight = /*#__PURE__*/ dual(2, (self, { onEmpty, onNonEmpty }) => isReadonlyArrayNonEmpty(self) ? onNonEmpty(initNonEmpty(self), lastNonEmpty(self)) : onEmpty());
+/**
 * Adds a single element to the front of an iterable, returning a `NonEmptyArray`.
 *
 * **When to use**
@@ -4944,7 +5106,7 @@ const prepend = /*#__PURE__*/ dual(2, (self, head) => [head, ...self]);
 * @category combining
 * @since 2.0.0
 */
-const append = /*#__PURE__*/ dual(2, (self, last) => [...self, last]);
+const append$1 = /*#__PURE__*/ dual(2, (self, last) => [...self, last]);
 /**
 * Concatenates two iterables into a single array.
 *
@@ -5189,68 +5351,61 @@ const last = (self) => isReadonlyArrayNonEmpty(self) ? some$1(lastNonEmpty(self)
 * @since 2.0.0
 */
 const lastNonEmpty = (self) => self[self.length - 1];
-const clampCount = (n, length) => Math.min(normalize(n), length);
 /**
-* Keeps the first `n` elements, creating a new array.
+* Returns all elements except the last of a `NonEmptyReadonlyArray`.
 *
 * **When to use**
 *
-* Use to keep up to the first `n` elements from an iterable as a new array.
-*
-* **Details**
+* Use to get all elements before the last when the array is known to be non-empty.
 *
-* `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)
+* **Example** (Getting init of a non-empty array)
 *
 * ```ts import.meta.vitest
 * import { Array } from "effect"
 *
-* Array.take([1, 2, 3, 4, 5], 3) // => [1, 2, 3]
+* Array.initNonEmpty([1, 2, 3, 4]) // => [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
+* @see {@link init} — safe version for possibly-empty arrays
+* @see {@link tailNonEmpty} — all elements except the first
 *
 * @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));
-});
+const initNonEmpty = (self) => self.slice(0, -1);
+const clampCount = (n, length) => Math.min(normalize(n), length);
 /**
-* Removes the last `n` elements, creating a new array.
+* Keeps the first `n` elements, creating a new array.
 *
 * **When to use**
 *
-* Use to remove the last `n` elements from an iterable.
+* 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** (Dropping from the end)
+* **Example** (Taking from the start)
 *
 * ```ts import.meta.vitest
 * import { Array } from "effect"
 *
-* Array.dropRight([1, 2, 3, 4, 5], 2) // => [1, 2, 3]
+* Array.take([1, 2, 3, 4, 5], 3) // => [1, 2, 3]
 * ```
 *
-* @see {@link drop} — remove from the start
-* @see {@link takeRight} — keep from the end
+* @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 dropRight = /*#__PURE__*/ dual(2, (self, n) => {
+const take$1 = /*#__PURE__*/ dual(2, (self, n) => {
 	const input = fromIterable(self);
-	return input.slice(0, input.length - clampCount(n, input.length));
+	return input.slice(0, clampCount(n, input.length));
 });
 /**
 * Returns the index of the first element matching the predicate, wrapped in an
@@ -5799,6 +5954,38 @@ const makeEquivalence = Array_;
 */
 const forEach = /*#__PURE__*/ dual(2, (self, f) => fromIterable(self).forEach((a, i) => f(a, i)));
 /**
+* Removes duplicates using a custom equivalence, preserving the order of the
+* first occurrence.
+*
+* **When to use**
+*
+* Use to remove all duplicate elements with a custom equivalence when default
+* equality is not appropriate.
+*
+* **Example** (Deduplicating with custom equality)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.dedupeWith([1, 2, 2, 3, 3, 3], (a, b) => a === b) // => [1, 2, 3]
+* ```
+*
+* @see {@link dedupe} — uses default equality
+* @see {@link dedupeAdjacentWith} — only dedupes consecutive elements
+*
+* @stability stable
+* @category deduplication
+* @since 2.0.0
+*/
+const dedupeWith = /*#__PURE__*/ dual(2, (self, isEquivalent) => {
+	const out = [];
+	next: for (const r of fromIterable(self)) {
+		for (let i = 0; i < out.length; i++) if (isEquivalent(r, out[i])) continue next;
+		out.push(r);
+	}
+	return out;
+});
+/**
 * Removes duplicates using `Equal.equivalence()`, preserving the order of the
 * first occurrence.
 *
@@ -6156,8 +6343,25 @@ const startsWith = (searchString, position) => (self) => self.startsWith(searchS
 * @since 2.0.0
 */
 const match = (regExp) => (self) => fromNullOr(self.match(regExp));
+/**
+* Replaces all occurrences of a substring or pattern in a string.
+*
+* **Example** (Replacing all matches)
+*
+* ```ts import.meta.vitest
+* import { pipe, String } from "effect"
+*
+* pipe("ababb", String.replaceAll("b", "c")) // => "acacc"
+* pipe("ababb", String.replaceAll(/ba/g, "cc")) // => "accbb"
+* ```
+*
+* @stability stable
+* @category transforming
+* @since 2.0.0
+*/
+const replaceAll = (searchValue, replaceValue) => (self) => self.replaceAll(searchValue, replaceValue);
 //#endregion
-//#region ../../node_modules/.pnpm/effect@4.0.4/node_modules/effect/dist/MutableRef.js
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/MutableRef.js
 const TypeId = "~effect/MutableRef";
 const MutableRefProto = {
 	[TypeId]: TypeId,
@@ -6202,7 +6406,7 @@ const MutableRefProto = {
 * @category constructors
 * @since 2.0.0
 */
-const make = (value) => {
+const make$1 = (value) => {
 	const ref = Object.create(MutableRefProto);
 	ref.current = value;
 	return ref;
@@ -6358,4 +6562,271 @@ const set = /*#__PURE__*/ dual(2, (self, value) => {
 */
 const update = /*#__PURE__*/ dual(2, (self, f) => set(self, f(get(self))));
 //#endregion
-export { values as $, symbol$1 as $n, TaggedError$1 as $t, fromIterable as A, getStackTraceLimit as An, Prototype as Ar, BigInt as At, makeEquivalence as B, currentFiberTypeId as Bn, Tuple as Bt, filterMap as C, isFailReason as Cn, constant as Cr, liftThrowable as Ct, flatMap as D, withFiber as Dn, memoizeIdempotent as Dr, orElse as Dt, findLast as E, makePrimitiveProto as En, memoize as Er, none as Et, isArrayNonEmpty as F, format as Fn, isGreaterThanOrEqualTo as Ft, reduce as G, combine as Gn, Done as Gt, match$1 as H, equals as Hn, strictEqual as Ht, isCanonicalArrayIndex as I, formatDate as In, isLessThan as It, take as J, optimize as Jn, Fail as Jt, some as K, hash as Kn, Error$2 as Kt, isReadonlyArrayNonEmpty as L, formatJson as Ln, isLessThanOrEqualTo as Lt, getSomes as M, BaseProto as Mn, Number$1 as Mt, head as N, NodeInspectSymbol as Nn, String$2 as Nt, flatten as O, assignProperty as On, pipe as Or, some$1 as Ot, isArrayEmpty as P, toStringUnknown as Pn, isGreaterThan as Pt, remove as Q, structureKeys as Qn, StackTraceKey as Qt, join as R, formatPath as Rn, make$1 as Rt, filter as S, isExit as Sn, constVoid as Sr, isSome as St, findFirstIndex as T, makePrimitive as Tn, identity as Tr, match$3 as Tt, of as U, symbol as Un, CauseImpl as Ut, map as V, byReferenceUnsafe as Vn, make$2 as Vt, prepend as W, array as Wn, Die as Wt, get$2 as X, string as Xn, PipeInspectableProto as Xt, fromEntries as Y, random as Yn, InterruptorStackTrace as Yt, map$1 as Z, structure as Zn, ReasonBase as Zt, dedupe as _, exitSucceed as _n, isUndefined as _r, fromNullishOr as _t, includes as a, causeEmpty as an, isIterable as ar, isSuccess as at, ensure as b, isDone as bn, constTrue as br, getOrUndefined as bt, startsWith as c, constEmptyAnnotations as cn, isNotUndefined as cr, succeed as ct, Error$1 as d, contE as dn, isObject as dr, contains$1 as dt, Yield as en, hasProperty as er, fail as et, TaggedError as f, done as fn, isObjectKeyword as fr, exists as ft, contains as g, exitFailCause as gn, isTagged as gr, flatten$1 as gt, appendAll as h, exitFail as hn, isString as hr, flatMap$2 as ht, Order as i, causeDie as in, isFunction as ir, isFailure as it, get$1 as j, setStackTraceLimit as jn, pipeArguments as jr, Date$1 as jt, forEach as k, internalCall as kn, Class$1 as kr, zipWith as kt, trim as l, contA as ln, isNullish as lr, normalize as lt, append as m, exitDie as mn, isReadonlyObject as mr, firstSomeOf as mt, make as n, causeAnnotate as nn, isBoolean as nr, fromOption as nt, match as o, causeFail as on, isNotNull as or, map$2 as ot, taggedEnum as p, evaluate as pn, isPropertyKey as pr, filter$1 as pt, sort as q, number as qn, ExitTypeId as qt, update as r, causeCombine as rn, isError as rr, getOrThrow as rt, split as s, causeFromReasons as sn, isNotNullish as sr, match$2 as st, get as t, args as tn, isBigInt as tr, flatMap$1 as tt, trimEnd as u, contAll as un, isNumber as ur, all as ut, dropRight as v, isCause as vn, isUnknown as vr, fromUndefinedOr as vt, findFirst as w, isInterruptReason as wn, dual as wr, map$3 as wt, every as x, isEffect as xn, constUndefined as xr, isNone as xt, empty as y, isDieReason as yn, constFalse as yr, getOrElse as yt, last as z, formatPropertyKey as zn, mapInput as zt };
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/MutableList.js
+/**
+* Defines the unique symbol used to represent an empty result when taking elements from a MutableList.
+* This symbol is returned by `take` when the list is empty, allowing for safe type checking.
+*
+* **When to use**
+*
+* Use to detect that `take` returned no element before handling the result as a
+* list item.
+*
+* **Example** (Checking for empty results)
+*
+* ```ts import.meta.vitest
+* import { MutableList } from "effect"
+*
+* const list = MutableList.make<string>()
+*
+* MutableList.take(list) === MutableList.Empty // => true
+* ```
+*
+* @stability stable
+* @category symbols
+* @since 4.0.0
+*/
+const Empty = /*#__PURE__*/ Symbol.for("effect/MutableList/Empty");
+/**
+* Creates an empty MutableList.
+*
+* **Example** (Creating an empty mutable list)
+*
+* ```ts import.meta.vitest
+* import { MutableList } from "effect"
+*
+* const list = MutableList.make<string>()
+*
+* list.length // => 0
+* MutableList.append(list, "first")
+* MutableList.take(list) // => "first"
+* list.length // => 0
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const make = () => ({
+	head: void 0,
+	tail: void 0,
+	length: 0
+});
+const compactHead = (self) => {
+	const head = self.head;
+	if (head.offset >= 1024 && head === self.tail && head.mutable && (head.array.length - head.offset) * 8 <= head.offset) self.head = self.tail = {
+		array: head.array.slice(head.offset),
+		mutable: true,
+		offset: 0,
+		next: void 0
+	};
+};
+const emptyBucket = () => ({
+	array: [],
+	mutable: true,
+	offset: 0,
+	next: void 0
+});
+/**
+* Appends an element to the end of the MutableList.
+* This operation is optimized for high-frequency usage.
+*
+* **Example** (Appending elements)
+*
+* ```ts import.meta.vitest
+* import { MutableList } from "effect"
+*
+* const list = MutableList.make<number>()
+* MutableList.append(list, 1)
+* MutableList.append(list, 2)
+* MutableList.append(list, 3)
+*
+* MutableList.toArray(list) // => [1, 2, 3]
+* list.length // => 3
+* ```
+*
+* @stability stable
+* @category mutations
+* @since 2.0.0
+*/
+const append = (self, message) => {
+	if (!self.tail) self.head = self.tail = emptyBucket();
+	else if (!self.tail.mutable) {
+		self.tail.next = emptyBucket();
+		self.tail = self.tail.next;
+	}
+	self.tail.array.push(message);
+	self.length++;
+};
+/**
+* Removes all elements from the MutableList, resetting it to an empty state.
+* This operation is highly optimized and releases all internal memory.
+*
+* **Example** (Clearing a mutable list)
+*
+* ```ts import.meta.vitest
+* import { MutableList } from "effect"
+*
+* const list = MutableList.make<number>()
+* MutableList.appendAll(list, [1, 2, 3, 4, 5])
+*
+* MutableList.clear(list)
+*
+* MutableList.toArray(list) // => []
+* list.length // => 0
+* MutableList.take(list) === MutableList.Empty // => true
+* ```
+*
+* @stability stable
+* @category mutations
+* @since 4.0.0
+*/
+const clear = (self) => {
+	self.head = self.tail = void 0;
+	self.length = 0;
+};
+/**
+* Takes up to N elements from the beginning of the MutableList and returns them as an array.
+* The taken elements are removed from the list. This operation is optimized for performance
+* and includes zero-copy optimizations when possible.
+*
+* **Details**
+*
+* Finite fractional values of `n` are rounded down. `NaN` and non-positive
+* values leave the list unchanged and return an empty array.
+*
+* **Example** (Taking batches)
+*
+* ```ts import.meta.vitest
+* import { MutableList } from "effect"
+*
+* const list = MutableList.make<number>()
+* MutableList.appendAll(list, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+*
+* MutableList.takeN(list, 3) // => [1, 2, 3]
+* MutableList.toArray(list) // => [4, 5, 6, 7, 8, 9, 10]
+* list.length // => 7
+* ```
+*
+* @stability stable
+* @category mutations
+* @since 4.0.0
+*/
+const takeN = (self, n) => {
+	n = normalize(n);
+	if (n <= 0 || !self.head) return [];
+	n = Math.min(n, self.length);
+	if (n === self.length && self.head?.offset === 0 && !self.head.next) {
+		const array = self.head.array;
+		clear(self);
+		return array;
+	}
+	const array = new Array(n);
+	let index = 0;
+	let chunk = self.head;
+	while (chunk) {
+		while (chunk.offset < chunk.array.length) {
+			array[index++] = chunk.array[chunk.offset];
+			if (chunk.mutable) chunk.array[chunk.offset] = void 0;
+			chunk.offset++;
+			if (index === n) {
+				self.head = chunk.offset === chunk.array.length && chunk.next ? chunk.next : chunk;
+				self.length -= n;
+				if (self.length === 0) clear(self);
+				else compactHead(self);
+				return array;
+			}
+		}
+		chunk = chunk.next;
+	}
+	clear(self);
+	return array;
+};
+/**
+* Takes a single element from the beginning of the MutableList.
+* Returns the element if available, or the Empty symbol if the list is empty.
+* The taken element is removed from the list.
+*
+* **Example** (Taking one element)
+*
+* ```ts import.meta.vitest
+* import { MutableList } from "effect"
+*
+* const list = MutableList.make<string>()
+* MutableList.appendAll(list, ["first", "second", "third"])
+*
+* MutableList.take(list) // => "first"
+* MutableList.toArray(list) // => ["second", "third"]
+* list.length // => 2
+* ```
+*
+* @stability stable
+* @category mutations
+* @since 4.0.0
+*/
+const take = (self) => {
+	if (!self.head) return Empty;
+	const message = self.head.array[self.head.offset];
+	if (self.head.mutable) self.head.array[self.head.offset] = void 0;
+	self.head.offset++;
+	self.length--;
+	if (self.head.offset === self.head.array.length) {
+		if (self.head.next) self.head = self.head.next;
+		else clear(self);
+	} else compactHead(self);
+	return message;
+};
+/**
+* Copies up to `n` elements from the beginning of the `MutableList` into a new
+* array without modifying the list.
+*
+* **When to use**
+*
+* Use when you need to inspect or snapshot a bounded prefix of the list without
+* consuming it.
+*
+* **Details**
+*
+* Finite fractional values of `n` are rounded down. `NaN` and non-positive
+* values return an empty array.
+*
+* @see {@link takeN} for removing up to `n` values and returning them as an array
+*
+* @stability stable
+* @category converting
+* @since 4.0.0
+*/
+const toArrayN = (self, n) => {
+	n = normalize(n);
+	if (n <= 0) return [];
+	const length = Math.min(n, self.length);
+	const out = new Array(length);
+	let index = 0;
+	let bucket = self.head;
+	while (bucket) {
+		for (let i = bucket.offset; i < bucket.array.length; i++) {
+			out[index++] = bucket.array[i];
+			if (index === length) return out;
+		}
+		bucket = bucket.next;
+	}
+	return out;
+};
+/**
+* Copies all current elements of the `MutableList` into a new array without
+* modifying the list.
+*
+* **When to use**
+*
+* Use when you need a snapshot of all current elements while keeping the list
+* unchanged.
+*
+* @see {@link takeAll} for converting all elements to an array and clearing the list
+*
+* @stability stable
+* @category converting
+* @since 4.0.0
+*/
+const toArray = (self) => toArrayN(self, self.length);
+//#endregion
+export { prepend as $, redact as $n, strictEqual as $t, filter as A, isCause as An, isString as Ar, getOrUndefined as At, getSomes as B, assignProperty as Bn, identity as Br, zipWith as Bt, contains as C, contE as Cn, isNullish as Cr, filter$1 as Ct, empty as D, exitFail as Dn, isPropertyKey as Dr, fromNullishOr as Dt, dedupeWith as E, exitDie as En, isObjectKeyword as Er, flatten$1 as Et, flatMap as F, isFailReason as Fn, constTrue as Fr, match$3 as Ft, isReadonlyArrayNonEmpty as G, NodeInspectSymbol as Gn, Prototype as Gr, isGreaterThan as Gt, isArrayEmpty as H, getStackTraceLimit as Hn, memoizeIdempotent as Hr, Date$1 as Ht, flatten as I, isInterruptReason as In, constUndefined as Ir, none as It, makeEquivalence as J, formatDate as Jn, isLessThanOrEqualTo as Jt, join as K, toStringUnknown as Kn, pipeArguments as Kr, isGreaterThanOrEqualTo as Kt, forEach as L, makePrimitive as Ln, constVoid as Lr, orElse as Lt, findFirst as M, isDone as Mn, isUndefined as Mr, isSome as Mt, findFirstIndex as N, isEffect as Nn, isUnknown as Nr, liftThrowable as Nt, ensure as O, exitFailCause as On, isReadonlyObject as Or, fromUndefinedOr as Ot, findLast as P, isExit as Pn, constFalse as Pr, map$3 as Pt, of as Q, currentFiberTypeId as Qn, make$3 as Qt, fromIterable as R, makePrimitiveProto as Rn, constant as Rr, some$1 as Rt, appendAll as S, contAll as Sn, isNotUndefined as Sr, exists as St, dedupe as T, evaluate as Tn, isObject as Tr, flatMap$2 as Tt, isArrayNonEmpty as U, setStackTraceLimit as Un, pipe as Ur, Number$1 as Ut, head as V, internalCall as Vn, memoize as Vr, BigInt as Vt, isCanonicalArrayIndex as W, BaseProto as Wn, Class$1 as Wr, String$2 as Wt, match$1 as X, formatPath as Xn, mapInput as Xt, map as Y, formatJson as Yn, make$2 as Yt, matchRight as Z, formatPropertyKey as Zn, Tuple as Zt, trimEnd as _, causeEmpty as _n, isError as _r, match$2 as _t, takeN as a, Fail as an, array as ar, get$2 as at, taggedEnum as b, constEmptyAnnotations as bn, isNotNull as br, all as bt, make$1 as c, ReasonBase as cn, number as cr, remove as ct, includes as d, Yield as dn, structure as dr, flatMap$1 as dt, CauseImpl as en, symbolRedactable as er, reduce as et, match as f, args as fn, structureKeys as fr, fromOption as ft, trim as g, causeDie as gn, isBoolean as gr, map$2 as gt, startsWith as h, causeCombine as hn, isBigInt as hr, isSuccess as ht, take as i, ExitTypeId as in, symbol as ir, fromEntries as it, filterMap as j, isDieReason as jn, isTagged as jr, isNone as jt, every as k, exitSucceed as kn, isRegExp as kr, getOrElse as kt, update as l, StackTraceKey as ln, optimize as lr, values as lt, split as m, causeAnnotate as mn, hasProperty as mr, isFailure as mt, clear as n, Done as nn, byReferenceUnsafe as nr, sort as nt, toArray as o, InterruptorStackTrace as on, combine as or, makeEquivalence$1 as ot, replaceAll as p, causeAddInterrupts as pn, symbol$1 as pr, getOrThrow as pt, last as q, format as qn, isLessThan as qt, make as r, Error$2 as rn, equals as rr, take$1 as rt, get as s, PipeInspectableProto as sn, hash as sr, map$1 as st, append as t, Die as tn, asEquivalence as tr, some as tt, Order as u, TaggedError$1 as un, string as ur, fail as ut, Error$1 as v, causeFail as vn, isFunction as vr, succeed as vt, containsWith as w, done as wn, isNumber as wr, firstSomeOf as wt, append$1 as x, contA as xn, isNotNullish as xr, contains$1 as xt, TaggedError as y, causeFromReasons as yn, isIterable as yr, normalize as yt, get$1 as z, withFiber as zn, dual as zr, toArray$1 as zt };