//#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(...)`.
*
* A `Pipeable` value can pass itself through a sequence of unary functions from
* left to right, so code can be written as `value.pipe(f, g, h)` instead of
* deeply nesting calls. This is the method form used by many Effect data types
* to compose transformations, validations, and effectful operations while
* keeping the original value as the starting point of the pipeline.
*
* @stability stable
* @since 2.0.0
*/
/**
* Applies a `pipe` method's variadic arguments to an initial value from left
* to right.
*
* **When to use**
*
* Use to implement a custom `.pipe(...)` method from JavaScript's `arguments`
* object.
*
* **Details**
*
* This helper is intended for implementing `Pipeable.pipe` methods that
* receive JavaScript's `arguments` object. With no functions it returns the
* original value; otherwise it feeds each result into the next function.
*
* **Example** (Implementing a pipe method)
*
* ```ts import.meta.vitest
* import { Pipeable } from "effect"
*
* class NumberBox {
* constructor(readonly value: number) {}
*
* pipe(..._fns: ReadonlyArray<(value: number) => number>): number {
* return Pipeable.pipeArguments(this.value, arguments) as number
* }
* }
*
* const result = new NumberBox(5).pipe(
* (n) => n + 2,
* (n) => n * 3
* )
* result // => 21
* ```
*
* @stability stable
* @category combinators
* @since 2.0.0
*/
const pipeArguments = (self, args) => {
switch (args.length) {
case 0: return self;
case 1: return args[0](self);
case 2: return args[1](args[0](self));
case 3: return args[2](args[1](args[0](self)));
case 4: return args[3](args[2](args[1](args[0](self))));
case 5: return args[4](args[3](args[2](args[1](args[0](self)))));
case 6: return args[5](args[4](args[3](args[2](args[1](args[0](self))))));
case 7: return args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))));
case 8: return args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self))))))));
case 9: return args[8](args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))))));
default: {
let ret = self;
for (let i = 0, len = args.length; i < len; i++) ret = args[i](ret);
return ret;
}
}
};
/**
* Reusable prototype that implements `Pipeable.pipe`.
*
* **When to use**
*
* Use when classes or object prototypes can reuse this value when they need the
* standard pipe implementation backed by `pipeArguments`.
*
* @stability stable
* @category prototypes
* @since 3.15.0
*/
const Prototype$1 = { pipe() {
return pipeArguments(this, arguments);
} };
/**
* Provides a base constructor whose instances implement the standard `Pipeable.pipe`
* method.
*
* **When to use**
*
* Use when you need to define a class that supports Effect-style method
* chaining through `.pipe(...)`.
*
* @stability stable
* @category constructors
* @since 3.15.0
*/
const Class$1 = /*#__PURE__*/ function() {
function PipeableBase() {}
PipeableBase.prototype = Prototype$1;
return PipeableBase;
}();
//#endregion
//#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.
*
* **When to use**
*
* Use to expose one implementation through both direct and `pipe`-friendly
* call styles.
*
* **Details**
*
* Pass either the arity of the uncurried function or a predicate that decides
* whether the current call is data-first. Arity is the common case. Use a
* predicate when optional arguments make arity ambiguous.
*
* **Example** (Selecting data-first or data-last style by arity)
*
* ```ts import.meta.vitest
* import { Function, pipe } from "effect"
*
* const sum = Function.dual<
* (that: number) => (self: number) => number,
* (self: number, that: number) => number
* >(2, (self, that) => self + that)
*
* sum(2, 3) // => 5
* pipe(2, sum(3)) // => 5
* ```
*
* **Example** (Defining overloads with call signatures)
*
* ```ts import.meta.vitest
* import { Function, pipe } from "effect"
*
* const sum: {
* (that: number): (self: number) => number
* (self: number, that: number): number
* } = Function.dual(2, (self: number, that: number): number => self + that)
*
* sum(2, 3) // => 5
* pipe(2, sum(3)) // => 5
* ```
*
* **Example** (Selecting data-first or data-last style with a predicate)
*
* ```ts import.meta.vitest
* import { Function, pipe } from "effect"
*
* const sum = Function.dual<
* (that: number) => (self: number) => number,
* (self: number, that: number) => number
* >(
* (args) => args.length === 2,
* (self, that) => self + that
* )
*
* sum(2, 3) // => 5
* pipe(2, sum(3)) // => 5
* ```
*
* @stability stable
* @category combinators
* @since 2.0.0
*/
const dual = function(arity, body) {
if (typeof arity === "function") return function() {
return arity(arguments) ? body.apply(this, arguments) : (self) => body(self, ...arguments);
};
switch (arity) {
case 0:
case 1: throw new RangeError(`Invalid arity ${arity}`);
case 2: return function(a, b) {
if (arguments.length >= 2) return body(a, b);
return function(self) {
return body(self, a);
};
};
case 3: return function(a, b, c) {
if (arguments.length >= 3) return body(a, b, c);
return function(self) {
return body(self, a, b);
};
};
default: return function() {
if (arguments.length >= arity) return body.apply(this, arguments);
const args = arguments;
return function(self) {
return body(self, ...args);
};
};
}
};
/**
* Returns its input argument unchanged.
*
* **When to use**
*
* Use to return a value unchanged where a function is required.
*
* **Example** (Returning the same value)
*
* ```ts import.meta.vitest
* import { identity } from "effect"
*
* identity(5) // => 5
* ```
*
* @stability stable
* @category combinators
* @since 2.0.0
*/
const identity = (a) => a;
/**
* Creates a zero-argument function that always returns the provided value.
*
* **When to use**
*
* Use when you need a thunk or callback that returns the same value on every
* invocation.
*
* **Example** (Creating a constant thunk)
*
* ```ts import.meta.vitest
* import { Function } from "effect"
*
* const constNull = Function.constant(null)
*
* constNull() // => null
* constNull() // => null
* ```
*
* @stability stable
* @category constructors
* @since 2.0.0
*/
const constant = (value) => () => value;
/**
* Returns `true` when called.
*
* **When to use**
*
* Use when you need a thunk that returns `true` on every invocation.
*
* **Example** (Returning true from a thunk)
*
* ```ts import.meta.vitest
* import { Function } from "effect"
*
* Function.constTrue() // => true
* ```
*
* @stability stable
* @category constants
* @since 2.0.0
*/
const constTrue = /*#__PURE__*/ constant(true);
/**
* Returns `undefined` when called.
*
* **When to use**
*
* Use when you need a thunk that returns `undefined` on every invocation.
*
* **Example** (Returning undefined from a thunk)
*
* ```ts import.meta.vitest
* import { Function } from "effect"
*
* Function.constUndefined() // => undefined
* ```
*
* @stability stable
* @category constants
* @since 2.0.0
*/
const constUndefined = /*#__PURE__*/ constant(void 0);
/**
* Returns no meaningful value when called.
*
* **When to use**
*
* Use when you need a thunk that is called only for its effect and has no
* meaningful return value.
*
* **Example** (Returning void from a thunk)
*
* ```ts import.meta.vitest
* import { Function } from "effect"
*
* Function.constVoid() // => undefined
* ```
*
* @stability stable
* @category constants
* @since 2.0.0
*/
const constVoid = constUndefined;
/**
* Creates a memoized function whose input is an object, caching results by
* object identity.
*
* **When to use**
*
* Use to reuse the result of a synchronous computation whose output is stable
* for a given object reference.
*
* **Details**
*
* Each memoized wrapper owns a private `WeakMap` keyed by object identity.
*
* **Gotchas**
*
* `undefined` is reserved to represent a cache miss and is therefore not
* supported as a return value.
*
* Structurally equal objects do not share cache entries. If the same object is
* mutated after its first call, later calls still return the cached result for
* that reference.
*
* @stability stable
* @category caching
* @since 4.0.0
*/
function memoize(f) {
const cache = /* @__PURE__ */ new WeakMap();
return (a) => {
const cached = cache.get(a);
if (cached !== void 0) return cached;
const result = f(a);
cache.set(a, result);
return result;
};
}
/**
* Creates a memoized idempotent object transformation that caches both inputs
* and their outputs by object identity.
*
* **When to use**
*
* Use when an object transformation is idempotent and its output can be safely
* reused as a fixed point.
*
* **Details**
*
* After computing an input, the returned function caches both the input and
* the output. Calling it with either reference returns the output without
* invoking the supplied function again.
*
* **Gotchas**
*
* The returned function treats each computed output as a fixed point. If
* applying the supplied function to an output would produce an observably
* different value, this memoization changes that behavior.
*
* @see {@link memoize} for memoizing functions without an idempotence requirement
* @stability stable
* @category caching
* @since 4.0.0
*/
function memoizeIdempotent(f) {
const cache = /* @__PURE__ */ new WeakMap();
return (a) => {
const cached = cache.get(a);
if (cached !== void 0) return cached;
const result = f(a);
cache.set(a, result);
if (result !== a) cache.set(result, result);
return result;
};
}
//#endregion
//#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));
if (obj.constructor === Object) return keys;
if (obj instanceof Error) keys.delete("stack");
const proto = Object.getPrototypeOf(obj);
let current = proto;
while (current !== null && current !== Object.prototype) {
const ownKeys = Reflect.ownKeys(current);
for (let i = 0; i < ownKeys.length; i++) keys.add(ownKeys[i]);
current = Object.getPrototypeOf(current);
}
if (keys.has("constructor") && typeof obj.constructor === "function" && proto === obj.constructor.prototype) keys.delete("constructor");
return keys;
};
/** @internal */
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.5/node_modules/effect/dist/internal/hash.js
/**
* Back-edge count used to avoid caching entry-point-dependent hashes.
*
* @internal
*/
let backEdges = 0;
/** @internal */
const addBackEdge = () => {
backEdges++;
};
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Predicate.js
/**
* Defines runtime checks for values.
*
* A `Predicate<A>` returns `true` or `false` for an `A`. A
* `Refinement<A, B>` is a predicate that also narrows the TypeScript type when
* it succeeds. This module includes guards for common JavaScript values,
* property and tag checks, tuple and struct checks, boolean combinators, and
* helpers for composing predicates and refinements.
*
* @stability stable
* @since 2.0.0
*/
/**
* Checks whether a value is a `string`.
*
* **When to use**
*
* Use when you need a `Predicate` guard to narrow an `unknown` value to a
* string.
*
* **Details**
*
* Uses `typeof input === "string"`.
*
* **Example** (Guarding strings)
*
* ```ts import.meta.vitest
* import { Predicate } from "effect"
*
* const data: unknown = "hi"
*
* if (Predicate.isString(data)) {
* data.toUpperCase() // => "HI"
* }
* ```
*
* @see {@link isNumber}
* @see {@link isBoolean}
* @see {@link Refinement}
* @stability stable
* @category guards
* @since 2.0.0
*/
function isString$1(input) {
return typeof input === "string";
}
/**
* Checks whether a value is a `number`.
*
* **When to use**
*
* Use when you need a `Predicate` guard to narrow an `unknown` value to a
* number.
*
* **Details**
*
* Uses `typeof input === "number"` and does not exclude `NaN` or `Infinity`.
*
* **Example** (Guarding numbers)
*
* ```ts import.meta.vitest
* import { Predicate } from "effect"
*
* const data: unknown = 42
*
* if (Predicate.isNumber(data)) {
* data + 1 // => 43
* }
* ```
*
* @see {@link isBigInt}
* @see {@link isString}
* @stability stable
* @category guards
* @since 2.0.0
*/
function isNumber(input) {
return typeof input === "number";
}
/**
* Checks whether a value is a `function`.
*
* **When to use**
*
* Use when you need a `Predicate` guard to narrow an `unknown` value to a
* callable function.
*
* **Details**
*
* Uses `typeof input === "function"`.
*
* **Example** (Guarding functions)
*
* ```ts import.meta.vitest
* import { Predicate } from "effect"
*
* const data: unknown = () => 1
*
* if (Predicate.isFunction(data)) {
* data() // => 1
* }
* ```
*
* @see {@link isObjectKeyword}
* @stability stable
* @category guards
* @since 2.0.0
*/
function isFunction(input) {
return typeof input === "function";
}
/**
* Checks whether a value is not `null` and not `undefined`.
*
* **When to use**
*
* Use when you need a `Predicate` refinement that filters out nullish values
* but keeps other falsy ones.
*
* **Details**
*
* Uses `input != null`.
*
* **Example** (Filtering non-nullish values)
*
* ```ts import.meta.vitest
* import { Predicate } from "effect"
*
* const values = [0, null, "", undefined]
* const present = values.filter(Predicate.isNotNullish) // => [0, ""]
* ```
*
* @see {@link isNullish}
* @see {@link isNotNull}
* @see {@link isNotUndefined}
* @stability stable
* @category guards
* @since 4.0.0
*/
function isNotNullish(input) {
return input != null;
}
/**
* Type guard that always returns `true`.
*
* **When to use**
*
* Use when you need a `Predicate` that always accepts, e.g. as a placeholder.
*
* **Example** (Matching every value)
*
* ```ts import.meta.vitest
* import { Predicate } from "effect"
*
* Predicate.isUnknown(123) // => true
* ```
*
* @see {@link isNever}
* @stability stable
* @category guards
* @since 2.0.0
*/
function isUnknown(_) {
return true;
}
/**
* Checks whether a value is an `object` in the JavaScript sense (objects, arrays, functions).
*
* **When to use**
*
* Use when you need a `Predicate` guard that accepts arrays and functions as
* well as objects.
*
* **Details**
*
* Returns `true` for arrays and functions, and `false` for `null`.
*
* **Example** (Checking object keywords)
*
* ```ts import.meta.vitest
* import { Predicate } from "effect"
*
* Predicate.isObjectKeyword(() => 1) // => true
* Predicate.isObjectKeyword(null) // => false
* ```
*
* @see {@link isObject}
* @see {@link isObjectOrArray}
* @stability stable
* @category guards
* @since 4.0.0
*/
function isObjectKeyword(input) {
return typeof input === "object" && input !== null || isFunction(input);
}
/**
* Checks whether a value has a given property key.
*
* **When to use**
*
* Use when you need a `Predicate` guard for property access on `unknown`
* values with a simple structural object check.
*
* **Details**
*
* Uses the `in` operator and `isObjectKeyword`. This does not check property
* value types.
*
* **Example** (Guarding object properties)
*
* ```ts import.meta.vitest
* import { Predicate } from "effect"
*
* const hasName = Predicate.hasProperty("name")
* const data: unknown = { name: "Ada" }
*
* if (hasName(data)) {
* data.name // => "Ada"
* }
* ```
*
* @see {@link isTagged}
* @see {@link isObjectKeyword}
* @stability stable
* @category guards
* @since 2.0.0
*/
const hasProperty = /*#__PURE__*/ dual(2, (self, property) => isObjectKeyword(self) && property in self);
//#endregion
//#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
* fingerprints used by Effect data structures to bucket values quickly; they
* are not cryptographic digests and they are not proof that two values are
* equal. The module also includes helpers for primitive, structure, array, and
* reference-based hashes, plus functions for combining and optimizing numeric
* hash values.
*
* @stability stable
* @since 2.0.0
*/
/**
* Defines the unique identifier used to identify objects that implement the Hash interface.
*
* **When to use**
*
* Use as the computed property key for the method that supplies a custom hash
* value on a `Hash` implementor.
*
* @see {@link Hash} for the interface implemented with this symbol
* @see {@link isHash} for checking whether a value implements `Hash`
* @see {@link hash} for computing hash values
*
* @stability stable
* @category symbols
* @since 2.0.0
*/
const symbol$1 = "~effect/Hash";
/**
* Computes a hash value for any given value.
*
* **When to use**
*
* Use to compute an Effect hash for primitives, collections, and hashable
* objects.
*
* **Details**
*
* This function can hash primitives (numbers, strings, booleans, etc.) as well as
* objects, arrays, and other complex data structures. It automatically handles
* different types and provides a consistent hash value for equivalent inputs.
*
* **Gotchas**
*
* Objects being hashed must be treated as immutable after their first hash
* computation. Hash results are cached, so mutating an object after hashing will
* lead to stale cached values and broken hash-based operations. For mutable
* objects, implement a custom `Hash` interface that hashes the object reference
* rather than its content.
*
* **Example** (Hashing different values)
*
* ```ts import.meta.vitest
* import { Hash } from "effect"
*
* Hash.hash(42) === Hash.hash(42) // => true
* Hash.hash("hello") === Hash.hash("hello") // => true
* Hash.hash([1, 2, 3]) === Hash.hash([1, 2, 3]) // => true
* ```
*
* @stability stable
* @category hashing
* @since 2.0.0
*/
const hash = (self) => {
switch (typeof self) {
case "number": return number$1(self);
case "bigint": return string$1(self.toString(10));
case "string": return string$1(self);
case "function":
case "object": if (self === null) break;
else if (self instanceof Date) {
if (Number.isNaN(self.getTime())) return string$1("Invalid Date");
return string$1(self.toISOString());
} else if (self instanceof RegExp) return string$1(self.toString());
else {
if (byReferenceInstances.has(self)) return random(self);
const cached = hashCache.get(self);
if (cached !== void 0) return cached;
if (visitedObjects.has(self)) {
addBackEdge();
return string$1("[Circular]");
}
visitedObjects.add(self);
const seen = backEdges;
let h;
try {
if ("~effect/Hash" in self) h = self[symbol$1]();
else if (typeof self === "function") h = random(self);
else if (self instanceof DataView) h = array(viewBytes(self));
else if (Array.isArray(self) || ArrayBuffer.isView(self)) h = array(self);
else if (self instanceof Map) h = hashMap(self);
else if (self instanceof Set) h = hashSet(self);
else h = structure(self);
} finally {
visitedObjects.delete(self);
}
if (seen === backEdges) hashCache.set(self, h);
return h;
}
}
return optimize(mix(string$1(String(self))));
};
/**
* Generates a random hash value for an object and caches it.
*
* **When to use**
*
* Use to hash an object by reference identity instead of structural content.
*
* **Details**
*
* This function creates a random hash value for objects that don't have their own
* hash implementation. The hash value is cached using a WeakMap, so the same object
* will always return the same hash value during its lifetime.
*
* **Example** (Hashing objects by reference)
*
* ```ts import.meta.vitest
* import { Hash } from "effect"
*
* const obj1 = { a: 1 }
* const obj2 = { a: 1 }
*
* Hash.random(obj1) === Hash.random(obj1) // => true
*
* typeof Hash.random(obj2) // => "number"
* ```
*
* @stability stable
* @category hashing
* @since 2.0.0
*/
const random = (self) => {
if (!randomHashCache.has(self)) randomHashCache.set(self, optimize(Math.random() * 4294967296 | 0));
return randomHashCache.get(self);
};
const mix = (h) => {
h ^= h >>> 16;
h = Math.imul(h, 2246822507);
h ^= h >>> 13;
h = Math.imul(h, 3266489909);
return h ^ h >>> 16;
};
/**
* Combines two hash values into a single hash value.
*
* **When to use**
*
* Use to build a hash for a composite value by folding together hash values for
* its parts.
*
* **Details**
*
* Supports direct and pipeable usage. Argument order affects the result.
*
* **Example** (Combining hash values)
*
* ```ts import.meta.vitest
* import { Hash, pipe } from "effect"
*
* const hash1 = Hash.hash("hello")
* const hash2 = Hash.hash("world")
*
* const combined = Hash.combine(hash2)(hash1)
* combined === pipe(hash1, Hash.combine(hash2)) // => true
* ```
*
* @see {@link hash} for computing hash values from arbitrary inputs
* @see {@link structureKeys} for hashing selected object fields without manual combination
*
* @stability stable
* @category hashing
* @since 2.0.0
*/
const combine = /*#__PURE__*/ dual(2, (self, b) => mix(Math.imul(self, 2654435761) + Math.imul(b, 2246822507)));
/**
* Applies bit manipulation techniques to optimize a hash value.
*
* **When to use**
*
* Use to improve the bit distribution of a raw numeric hash value.
*
* **Details**
*
* This function takes a hash value and applies bitwise operations to improve
* the distribution of hash values, reducing the likelihood of collisions.
*
* **Example** (Optimizing a hash value)
*
* ```ts import.meta.vitest
* import { Hash } from "effect"
*
* Hash.optimize(1234567890) // => 160826066
* ```
*
* @stability stable
* @category hashing
* @since 2.0.0
*/
const optimize = (n) => n & 3221225471 | n >>> 1 & 1073741824;
const float64 = /*#__PURE__*/ new DataView(/*#__PURE__*/ new ArrayBuffer(8));
/**
* Computes a hash value for a number.
*
* **When to use**
*
* Use to hash a JavaScript number with Effect's numeric hash semantics.
*
* **Details**
*
* Int32 values hash to themselves. Other numbers hash from their IEEE-754 bits,
* with a canonical representation for `NaN`.
*
* **Example** (Hashing numbers)
*
* ```ts import.meta.vitest
* import { Hash } from "effect"
*
* Number.isInteger(Hash.number(42)) // => true
* Number.isInteger(Hash.number(3.14)) // => true
* Hash.number(NaN) === Hash.number(NaN) // => true
* Hash.number(Infinity) === Hash.number(Infinity) // => true
* Hash.number(100) === Hash.number(100) // => true
* ```
*
* @stability stable
* @category hashing
* @since 2.0.0
*/
const number$1 = (n) => {
const h = n | 0;
if (h === n) return optimize(h);
float64.setFloat64(0, n !== n ? NaN : n);
return optimize(combine(float64.getInt32(0), float64.getInt32(4)));
};
/**
* Computes a hash value for a string using the djb2 algorithm.
*
* **When to use**
*
* Use when you need a string field to contribute to a custom structural hash
* implementation.
*
* **Details**
*
* This function implements a variation of the djb2 hash algorithm, which is
* known for its good distribution properties and speed. It processes each
* character of the string to produce a consistent hash value.
*
* **Example** (Hashing strings)
*
* ```ts import.meta.vitest
* import { Hash } from "effect"
*
* Hash.string("hello") // => 181380007
* Hash.string("world") // => 164394279
* Hash.string("") // => 5381
* Hash.string("test") === Hash.string("test") // => true
* ```
*
* @stability stable
* @category hashing
* @since 2.0.0
*/
const string$1 = (str) => {
let h = 5381, i = str.length;
while (i) h = h * 33 ^ str.charCodeAt(--i);
return optimize(h);
};
/**
* Computes a hash value for an object using only the specified keys.
*
* **When to use**
*
* Use to hash an object by a selected set of property keys.
*
* **Details**
*
* This function allows you to hash an object by considering only specific keys,
* which is useful when you want to create a hash based on a subset of an object's
* properties.
*
* **Example** (Hashing selected object keys)
*
* ```ts import.meta.vitest
* import { Hash } from "effect"
*
* const person = { name: "John", age: 30, city: "New York" }
*
* const hash1 = Hash.structureKeys(person, ["name", "age"])
* const hash2 = Hash.structureKeys(person, ["name", "city"])
*
* hash1 // => -731887653
* hash2 // => 148523102
*
* const person2 = { name: "John", age: 30, city: "Boston" }
* const hash3 = Hash.structureKeys(person2, ["name", "age"])
* hash1 === hash3 // => true
* ```
*
* @stability stable
* @category hashing
* @since 2.0.0
*/
const structureKeys = (o, keys) => {
let h = 12289;
for (const key of keys) h ^= combine(hash(key), hash(o[key]));
return optimize(h);
};
/**
* Computes a structural hash for an object using Effect's object key collection.
*
* **When to use**
*
* Use to hash an object from all structural keys collected by Effect.
*
* **Details**
*
* The hash is based on the object's structural keys and their values, including
* symbol keys and relevant prototype keys for non-plain objects.
*
* **Example** (Hashing object structures)
*
* ```ts import.meta.vitest
* import { Hash } from "effect"
*
* const obj1 = { name: "John", age: 30 }
* const obj2 = { name: "Jane", age: 25 }
* const obj3 = { name: "John", age: 30 }
*
* Hash.structure(obj1) // => -731887653
* Hash.structure(obj2) // => -222100417
* Hash.structure(obj3) // => -731887653
* Hash.structure(obj1) === Hash.structure(obj3) // => true
* ```
*
* @stability stable
* @category hashing
* @since 2.0.0
*/
const structure = (o) => structureKeys(o, getAllObjectKeys(o));
const unordered = (seed, f) => (iter) => {
let h = seed;
for (const element of iter) h ^= f(element);
return optimize(h);
};
/**
* Computes a hash value for an iterable by hashing all of its elements.
*
* **When to use**
*
* Use to hash the values yielded by an iterable with Effect hash semantics.
*
* **Details**
*
* Folds element hashes with {@link combine}, so order and length affect the
* result.
*
* **Gotchas**
*
* A hash is not an equality proof. Distinct inputs can still share a hash.
*
* **Example** (Hashing arrays)
*
* ```ts import.meta.vitest
* import { Hash } from "effect"
*
* const arr1 = [1, 2, 3]
* const arr2 = [1, 2, 3]
* const arr3 = [3, 2, 1]
*
* Hash.array(arr1) === Hash.array(arr2) // => true
* Hash.array(arr1) === Hash.array(arr3) // => false
* ```
*
* @see {@link hash} for the general-purpose hash dispatcher
*
* @stability stable
* @category hashing
* @since 2.0.0
*/
const array = (arr) => {
let h = 6151;
for (const element of arr) h = combine(h, hash(element));
return optimize(h);
};
const hashMap = /*#__PURE__*/ unordered(/*#__PURE__*/ string$1("Map"), ([k, v]) => combine(hash(k), hash(v)));
const setSeed = /*#__PURE__*/ string$1("Set");
const hashSet = /*#__PURE__*/ unordered(setSeed, (element) => combine(setSeed, hash(element)));
const randomHashCache = /*#__PURE__*/ new WeakMap();
const hashCache = /*#__PURE__*/ new WeakMap();
const visitedObjects = /*#__PURE__*/ new WeakSet();
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Equal.js
/**
* Defines the unique string identifier for the `Equal` interface.
*
* **When to use**
*
* Use when you implement custom equality and need the computed property key for
* the equality method.
*
* **Details**
*
* This is a pure constant with no allocation or side effects.
*
* **Example** (Implementing Equal on a class)
*
* ```ts import.meta.vitest
* import { Equal, Hash } from "effect"
*
* class UserId implements Equal.Equal {
* constructor(readonly id: string) {}
*
* [Equal.symbol](that: Equal.Equal): boolean {
* return that instanceof UserId && this.id === that.id
* }
*
* [Hash.symbol](): number {
* return Hash.string(this.id)
* }
* }
*
* Equal.equals(new UserId("1"), new UserId("1")) // => true
* Equal.equals(new UserId("1"), new UserId("2")) // => false
* ```
*
* @see {@link Equal} — the interface that uses this symbol
* @see {@link isEqual} — type guard for `Equal` implementors
* @stability stable
* @category symbols
* @since 2.0.0
*/
const symbol = "~effect/Equal";
function equals$1() {
if (arguments.length === 1) return (self) => compareBoth(self, arguments[0]);
return compareBoth(arguments[0], arguments[1]);
}
function compareBoth(self, that) {
if (self === that) return true;
if (self == null || that == null) return false;
const selfType = typeof self;
if (selfType !== typeof that) return false;
if (selfType === "number" && self !== self && that !== that) return true;
if (selfType !== "object" && selfType !== "function") return false;
if (byReferenceInstances.has(self) || byReferenceInstances.has(that)) return false;
return compareObjects(self, that);
}
function compareObjects(self, that) {
const depth = pathLeft.length;
for (let i = depth; i-- > 0;) if (pathLeft[i] === self && pathRight[i] === that) return true;
if (depth) return compareOnPath(self, that);
let known = results.get(self);
if (!known) results.set(self, known = /* @__PURE__ */ new WeakMap());
let result = known.get(that);
if (result === void 0) known.set(that, result = compareOnPath(self, that));
return result;
}
function compareOnPath(self, that) {
pathLeft.push(self);
pathRight.push(that);
try {
return compareStructure(self, that);
} finally {
pathLeft.pop();
pathRight.pop();
}
}
const pathLeft = [];
const pathRight = [];
const results = /*#__PURE__*/ new WeakMap();
function compareStructure(self, that) {
if (hash(self) !== hash(that)) return false;
else if (self instanceof Date) {
if (!(that instanceof Date)) return false;
const selfTime = self.getTime();
const thatTime = that.getTime();
return selfTime === thatTime || Number.isNaN(selfTime) && Number.isNaN(thatTime);
} else if (self instanceof RegExp) return that instanceof RegExp && self.toString() === that.toString();
const bothEquals = isEqual(self);
if (bothEquals !== isEqual(that) || typeof self === "function" && !bothEquals) return false;
else if (bothEquals) return self[symbol](that);
else if (Array.isArray(self)) {
if (!Array.isArray(that) || self.length !== that.length) return false;
return compareArrays(self, that);
} else if (ArrayBuffer.isView(self)) {
const selfIsDataView = self instanceof DataView;
if (!ArrayBuffer.isView(that) || self.byteLength !== that.byteLength || selfIsDataView !== that instanceof DataView) return false;
if (selfIsDataView) return compareTypedArrays(viewBytes(self), viewBytes(that));
return compareTypedArrays(self, that);
} else if (self instanceof Map) {
if (!(that instanceof Map) || self.size !== that.size) return false;
return compareHashed(self, that, entryHash, equalEntries);
} else if (self instanceof Set) {
if (!(that instanceof Set) || self.size !== that.size) return false;
return compareHashed(self, that, hash, compareBoth);
}
return compareRecords(self, that);
}
function compareArrays(self, that) {
for (let i = 0; i < self.length; i++) if (!compareBoth(self[i], that[i])) return false;
return true;
}
function compareTypedArrays(self, that) {
if (self.length !== that.length) return false;
for (let i = 0; i < self.length; i++) if (self[i] !== that[i]) return false;
return true;
}
function compareRecords(self, that) {
const selfKeys = getAllObjectKeys(self);
const thatKeys = getAllObjectKeys(that);
if (selfKeys.size !== thatKeys.size) return false;
for (const key of selfKeys) if (!thatKeys.has(key) || !compareBoth(self[key], that[key])) return false;
return true;
}
function compareHashed(self, that, hashOf, equivalent) {
const groups = /* @__PURE__ */ new Map();
let remaining = 0;
for (const item of that) {
const h = hashOf(item);
const group = groups.get(h);
if (group) group.push(item);
else groups.set(h, [item]);
remaining++;
}
outer: for (const item of self) {
const group = groups.get(hashOf(item));
if (group) {
for (let i = 0; i < group.length; i++) if (equivalent(item, group[i])) {
group[i] = group[group.length - 1];
group.pop();
remaining--;
continue outer;
}
}
return false;
}
return remaining === 0;
}
const entryHash = (entry) => hash(entry[0]);
const equalEntries = (self, that) => compareBoth(self[0], that[0]) && compareBoth(self[1], that[1]);
/**
* Checks whether a value implements the {@link Equal} interface.
*
* **When to use**
*
* Use when you need generic utility code to distinguish `Equal` implementors
* from plain values before calling `[Equal.symbol]` directly.
*
* **Details**
*
* - Pure function, no side effects.
* - Returns `true` if and only if `u` has a property keyed by
* {@link symbol}.
* - Acts as a TypeScript type guard, narrowing the input to {@link Equal}.
*
* **Example** (Checking Equal values)
*
* ```ts import.meta.vitest
* import { Equal, Hash } from "effect"
*
* class Token implements Equal.Equal {
* constructor(readonly value: string) {}
* [Equal.symbol](that: Equal.Equal): boolean {
* return that instanceof Token && this.value === that.value
* }
* [Hash.symbol](): number {
* return Hash.string(this.value)
* }
* }
*
* Equal.isEqual(new Token("abc")) // => true
* Equal.isEqual({ x: 1 }) // => false
* Equal.isEqual(42) // => false
* ```
*
* @see {@link Equal} — the interface being checked
* @see {@link symbol} — the property key that signals `Equal` support
* @stability stable
* @category guards
* @since 2.0.0
*/
const isEqual = (u) => hasProperty(u, symbol);
//#endregion
//#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.5/node_modules/effect/dist/internal/record.js
/** @internal */
function assignProperty(self, key, value) {
if (key === "__proto__") Object.defineProperty(self, key, {
value,
writable: true,
enumerable: true,
configurable: true
});
else self[key] = value;
}
/** @internal */
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.5/node_modules/effect/dist/Redactable.js
/**
* Defines the symbol used to identify objects that implement the {@link Redactable}
* protocol.
*
* **When to use**
*
* Use as the property key when implementing the `Redactable` protocol.
*
* **Details**
*
* Add a method under this key to make an object redactable. The method receives
* the current `Context` and must return the replacement value. The symbol is
* registered globally via `Symbol.for("~effect/Redactable")`, so it is
* identical across multiple copies of the library at runtime.
*
* **Example** (Masking an API key)
*
* ```ts import.meta.vitest
* import { Context, Redactable } from "effect"
*
* class ApiKey {
* constructor(readonly raw: string) {}
*
* [Redactable.symbolRedactable](_ctx: Context.Context<never>) {
* return this.raw.slice(0, 4) + "..."
* }
* }
*
* Redactable.redact(new ApiKey("secret-key")) // => "secr..."
* ```
*
* @see {@link Redactable} for the interface this symbol belongs to
* @see {@link isRedactable} to check whether a value has this symbol
* @stability stable
* @category symbols
* @since 3.10.0
*/
const symbolRedactable = /*#__PURE__*/ Symbol.for("~effect/Redactable");
/**
* Type guard that checks whether a value implements the {@link Redactable}
* interface.
*
* **When to use**
*
* Use to narrow an unknown value before calling redaction-specific helpers.
*
* @see {@link Redactable} for the interface being checked
* @see {@link redact} to apply redaction if the value is redactable
* @stability stable
* @category guards
* @since 3.10.0
*/
const isRedactable = (u) => hasProperty(u, symbolRedactable);
/**
* Returns a redacted value if it implements {@link Redactable}, otherwise returns it
* unchanged.
*
* **When to use**
*
* Use as the general-purpose entry point for redaction when the input may
* or may not implement the redaction protocol.
*
* **Details**
*
* This function calls {@link isRedactable} and, when it returns `true`,
* delegates to {@link getRedacted}.
*
* **Gotchas**
*
* Redaction is not recursive. Nested redactable values inside the returned
* object are not automatically redacted.
*
* @see {@link isRedactable} to check before redacting
* @see {@link getRedacted} for the lower-level variant for known redactables
* @stability stable
* @category destructors
* @since 3.10.0
*/
function redact$2(u) {
if (isRedactable(u)) return getRedacted(u);
return u;
}
/**
* Returns the result of calling `[symbolRedactable]` on a value that is
* already known to be {@link Redactable}.
*
* **When to use**
*
* Use when you need to read the redacted representation from a value already
* verified as `Redactable`.
*
* **Details**
*
* This function reads the current fiber's `Context` from the global fiber
* reference and passes it to the redaction method.
*
* **Gotchas**
*
* If no fiber is active, an empty `Context` is passed to the redaction method.
*
* @see {@link redact} for the higher-level variant that handles non-redactable values
* @see {@link isRedactable} for the type guard to verify before calling this
* @stability stable
* @category destructors
* @since 4.0.0
*/
function getRedacted(redactable) {
return redactable[symbolRedactable](globalThis["~effect/Fiber/currentFiber"]?.context ?? emptyContext$1);
}
/** @internal */
const currentFiberTypeId = "~effect/Fiber/currentFiber";
const emptyMap = /*#__PURE__*/ new Map();
const emptyContext$1 = {
"~effect/Context": {},
base: emptyMap,
depth: 0,
mapUnsafe: emptyMap,
pipe() {
return pipeArguments(this, arguments);
}
};
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Formatter.js
/**
* Formats JavaScript values into readable strings.
*
* `format` is intended for logs, diagnostics, and error messages. It handles
* primitives, objects, arrays, dates, regular expressions, maps, sets, class
* instances, errors, circular references, and redactable values. `formatJson`
* wraps JSON formatting with redaction and circular-reference handling, and the
* module also includes helpers for property keys, paths, and dates.
*
* @stability stable
* @since 4.0.0
*/
/**
* Converts any JavaScript value into a human-readable string.
*
* **When to use**
*
* Use when you need to format arbitrary JavaScript values for debugging,
* logging, or error messages.
*
* **Details**
*
* - Output is **not** valid JSON; use {@link formatJson} when you need
* parseable JSON.
* - Handles `BigInt`, `Symbol`, `Set`, `Map`, `Date`, `RegExp`, and class
* instances that `JSON.stringify` cannot represent.
* - Circular references are shown as `"[Circular]"` instead of throwing.
* - Failures while inspecting a value are rendered as diagnostic placeholders instead of throwing.
* - Primitives: stringified naturally (`null`, `undefined`, `123`, `true`).
* Strings are JSON-quoted.
* - Objects with a custom `toString` (not `Object.prototype.toString`):
* `toString()` is called unless `ignoreToString` is `true`.
* - Errors with a `cause`: formatted as `"<message> (cause: <cause>)"`.
* - Iterables (`Set`, `Map`, etc.): formatted as
* `ClassName([...elements])`.
* - Class instances: wrapped as `ClassName({...})`.
* - `Redactable` values are automatically redacted.
* - Arrays/objects with 0–1 entries are inline; larger ones are
* pretty-printed when `space` is set.
* - `space` — indentation unit (number of spaces, or a string like
* `"\t"`). Defaults to `0` (compact).
* - `ignoreToString` — skip calling `toString()`. Defaults to `false`.
*
* **Example** (Formatting compact output)
*
* ```ts import.meta.vitest
* import { Formatter } from "effect"
*
* Formatter.format({ a: 1, b: [2, 3] }) // => "{\"a\":1,\"b\":[2,3]}"
* ```
*
* **Example** (Pretty-printed output)
*
* ```ts import.meta.vitest
* import { Formatter } from "effect"
*
* const output = Formatter.format({ a: 1, b: [2, 3] }, { space: 2 })
* output // => "{\n \"a\": 1,\n \"b\": [\n 2,\n 3\n ]\n}"
* ```
*
* **Example** (Handling circular references)
*
* ```ts import.meta.vitest
* import { Formatter } from "effect"
*
* const obj: any = { name: "loop" }
* obj.self = obj
* Formatter.format(obj) // => "{\"name\":\"loop\",\"self\":[Circular]}"
* ```
*
* @see {@link formatJson}
* @see {@link Formatter}
* @stability stable
* @category formatting
* @since 2.0.0
*/
function format$1(input, options) {
const space = options?.space ?? 0;
const ancestors = /* @__PURE__ */ new WeakSet();
const gap = !space ? "" : typeof space === "number" ? " ".repeat(space) : space;
const ind = (d) => gap.repeat(d);
const wrap = (v, body) => {
const ctor = v?.constructor;
return ctor && ctor !== Object.prototype.constructor && ctor.name ? `${ctor.name}(${body})` : body;
};
const ownKeys = (o) => {
try {
return Reflect.ownKeys(o);
} catch {
return ["[ownKeys threw]"];
}
};
function recur(v, d = 0) {
try {
return recurUnsafe(v, d);
} catch {
if (typeof v === "object" && v !== null || typeof v === "function") ancestors.delete(v);
return "[inspection threw]";
}
}
function recurUnsafe(v, d = 0) {
if (typeof v === "string") return JSON.stringify(v);
if (typeof v === "number" || v == null || typeof v === "boolean" || typeof v === "symbol") return String(v);
if (typeof v === "bigint") return String(v) + "n";
if (typeof v === "object" || typeof v === "function") {
if (ancestors.has(v)) return CIRCULAR;
ancestors.add(v);
let output;
if (symbolRedactable in v) output = recur(getRedacted(v), d);
else if (Array.isArray(v)) output = !gap || v.length <= 1 ? `[${v.map((x) => recur(x, d)).join(",")}]` : `[\n${ind(d + 1)}${v.map((x) => recur(x, d + 1)).join(",\n" + ind(d + 1))}\n${ind(d)}]`;
else if (v instanceof Date) output = formatDate(v);
else if (!options?.ignoreToString && hasProperty(v, "toString") && typeof v["toString"] === "function" && v["toString"] !== Object.prototype.toString && v["toString"] !== Array.prototype.toString) {
const s = safeToString(v);
output = v instanceof Error && v.cause !== void 0 ? `${s} (cause: ${recur(v.cause, d)})` : s;
} else if (Symbol.iterator in v) output = `${v.constructor.name}(${recur(Array.from(v), d)})`;
else {
const keys = ownKeys(v);
if (!gap || keys.length <= 1) {
const body = `{${keys.map((k) => `${formatPropertyKey(k)}:${recur(safeGet(v, k), d)}`).join(",")}}`;
output = wrap(v, body);
} else {
const body = `{\n${keys.map((k) => `${ind(d + 1)}${formatPropertyKey(k)}: ${recur(safeGet(v, k), d + 1)}`).join(",\n")}\n${ind(d)}}`;
output = wrap(v, body);
}
}
ancestors.delete(v);
return output;
}
return String(v);
}
return recur(input, 0);
}
const CIRCULAR = "[Circular]";
/**
* @internal
*/
function formatPropertyKey(name) {
return typeof name === "string" ? JSON.stringify(name) : String(name);
}
/**
* Formats an array of property keys as a bracket-notation path string.
*
* @internal
*/
function formatPath(path) {
return path.map((key) => `[${formatPropertyKey(key)}]`).join("");
}
/**
* Formats a `Date` as an ISO 8601 string, returning `"Invalid Date"` for
* invalid dates instead of throwing.
*
* @internal
*/
function formatDate(date) {
try {
return date.toISOString();
} catch {
return "Invalid Date";
}
}
function safeToString(input) {
try {
const s = input.toString();
return typeof s === "string" ? s : String(s);
} catch {
return "[toString threw]";
}
}
function safeGet(input, key) {
try {
return input[key];
} catch {
return "[property access threw]";
}
}
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Inspectable.js
/**
* Controls how values appear in logs and debugging output.
*
* Effect data types use `Inspectable` to provide stable string, JSON, and
* Node.js inspection output. This keeps custom values readable in logs, REPLs,
* test failures, and diagnostics. This module defines the Node inspect symbol,
* the `Inspectable` interface, safe conversion helpers, and shared prototype or
* class implementations for custom values.
*
* @stability stable
* @since 2.0.0
*/
/**
* Defines the symbol used by Node.js for custom object inspection.
*
* **When to use**
*
* Use to implement Node.js custom inspection for a value.
*
* **Details**
*
* This symbol is recognized by Node.js's `util.inspect()` function and the REPL
* for custom object representation. When an object has a method with this symbol,
* it will be called to determine how the object should be displayed.
*
* **Example** (Defining custom Node inspection)
*
* ```ts import.meta.vitest
* import { Inspectable } from "effect"
*
* class CustomObject {
* constructor(private value: string) {}
*
* [Inspectable.NodeInspectSymbol]() {
* return `CustomObject(${this.value})`
* }
* }
*
* const obj = new CustomObject("hello")
* obj[Inspectable.NodeInspectSymbol]() // => "CustomObject(hello)"
* ```
*
* @stability stable
* @category symbols
* @since 2.0.0
*/
const NodeInspectSymbol = /*#__PURE__*/ Symbol.for("nodejs.util.inspect.custom");
/**
* Converts a value to its structured inspection representation.
*
* **When to use**
*
* Use when you need the structured representation of an inspectable value
* without risking unhandled errors.
*
* **Details**
*
* This function applies redaction before extracting data from objects that
* implement `toJSON`, recursively processes arrays, and handles errors
* gracefully. Plain objects are returned unchanged, so the result is not
* guaranteed to be accepted by `JSON.stringify`; it may still contain values
* such as `BigInt`, functions, or circular references.
*
* @see {@link toStringUnknown} for converting unknown values to strings
*
* @stability stable
* @category converting
* @since 4.0.0
*/
const toJson = (input) => {
try {
input = redact$2(input);
if (hasProperty(input, "toJSON") && isFunction(input["toJSON"]) && input["toJSON"].length === 0) return input.toJSON();
else if (Array.isArray(input)) return input.map(toJson);
return input;
} catch {
return "[toJSON threw]";
}
};
/**
* A base prototype object that implements the {@link Inspectable} interface.
*
* **When to use**
*
* Use as a prototype for plain objects that should share standard inspectable behavior.
*
* **Details**
*
* This object provides default implementations for the {@link Inspectable} methods.
* It can be used as a prototype for objects that want to be inspectable,
* or as a mixin to add inspection capabilities to existing objects.
*
* **Example** (Using the base inspectable prototype)
*
* ```ts import.meta.vitest
* import { Inspectable } from "effect"
*
* // Use as prototype
* const myObject = Object.create(Inspectable.BaseProto)
* myObject.name = "example"
* myObject.value = 42
*
* myObject.toString() // => "\"[toJSON threw]\""
*
* // Or extend in a constructor
* function MyClass(this: any, name: string) {
* this.name = name
* }
* MyClass.prototype = Object.create(Inspectable.BaseProto)
* MyClass.prototype.constructor = MyClass
* ```
*
* @stability stable
* @category prototypes
* @since 2.0.0
*/
const BaseProto = {
toJSON() {
return toJson(this);
},
[NodeInspectSymbol]() {
return this.toJSON();
},
toString() {
return format$1(this.toJSON());
}
};
//#endregion
//#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.
*
* @internal
*/
const isStackTraceLimitWritable = () => {
const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
if (desc === void 0) return Object.isExtensible(Error);
return Object.hasOwn(desc, "writable") ? desc.writable === true : desc.set !== void 0;
};
const canWriteStackTraceLimit = /*#__PURE__*/ isStackTraceLimitWritable();
/**
* Get the current `Error.stackTraceLimit` value.
* Returns `undefined` if the property doesn't exist.
*
* @internal
*/
const getStackTraceLimit = () => Error.stackTraceLimit;
/**
* Safely set `Error.stackTraceLimit` if possible, otherwise no-op.
*
* Accepts `undefined` so a value read via {@link getStackTraceLimit} can be
* restored faithfully.
*
* @internal
*/
const setStackTraceLimit = (value) => {
if (canWriteStackTraceLimit) Error.stackTraceLimit = value;
};
//#endregion
//#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.
*
* **When to use**
*
* Use to implement `[Symbol.iterator]()` on Effect-like types so they can be
* `yield*`-ed inside generator functions, such as `Effect.gen` and
* `Option.gen`.
*
* **Details**
*
* The first call to `next()` returns a fresh `{ value: self, done: false }`.
* Every subsequent call returns `{ value: a, done: true }` where `a` is the
* argument passed to `next()`. To keep `yield*` cheap, the completion result
* is the iterator itself rather than a new object, so only the iterator and
* the single yielded result are allocated per `yield*`.
*
* **Example** (Yielding a wrapped value in a generator)
*
* ```ts import.meta.vitest
* import { Utils } from "effect"
*
* const gen = new Utils.SingleShotGen<string, number>("hello")
*
* gen.next(0).value // => "hello"
*
* gen.next(42).value // => 42
* ```
*
* @see {@link Gen} for the type-level signature that relies on `SingleShotGen`
* @stability stable
* @category constructors
* @since 2.0.0
*/
var SingleShotGen = class {
constructor(self) {
this.value = self;
this.done = false;
}
/**
* Yields the stored value once, then completes with the value sent back in.
*
* **When to use**
*
* Use to advance a `SingleShotGen` through its single yield and completion
* step.
*
* @since 2.0.0
*/
next(a) {
if (this.done) {
this.value = a;
return this;
}
this.done = true;
return {
value: this.value,
done: false
};
}
};
const pickInternalCall = () => {
const InternalTypeId = "~effect/Utils/internal";
const standard = { [InternalTypeId]: (body) => {
return body();
} };
const forced = { [InternalTypeId]: (body) => {
try {
return body();
} finally {}
} };
const limit = getStackTraceLimit();
if (limit === 0) return forced[InternalTypeId];
setStackTraceLimit(2);
const error = standard[InternalTypeId](() => /* @__PURE__ */ new Error());
setStackTraceLimit(limit);
return error.stack?.includes(InternalTypeId) === true ? standard[InternalTypeId] : forced[InternalTypeId];
};
/** @internal */
const internalCall = /*#__PURE__*/ pickInternalCall();
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/core.js
/** @internal */
const EffectTypeId = `~effect/Effect`;
/** @internal */
const ExitTypeId = `~effect/Exit`;
const effectVariance = {
_A: identity,
_E: identity,
_R: identity
};
/** @internal */
const identifier = `${EffectTypeId}/identifier`;
/** @internal */
const args = `${EffectTypeId}/args`;
/** @internal */
const evaluate = `${EffectTypeId}/evaluate`;
/** @internal */
const contA = `${EffectTypeId}/successCont`;
/** @internal */
const contE = `${EffectTypeId}/failureCont`;
/** @internal */
const contAll = `${EffectTypeId}/ensureCont`;
/** @internal */
const Yield = /*#__PURE__*/ Symbol.for("effect/Effect/Yield");
/** @internal */
const PipeInspectableProto = {
pipe() {
return pipeArguments(this, arguments);
},
toJSON() {
return { ...this };
},
toString() {
return format$1(this.toJSON(), {
ignoreToString: true,
space: 2
});
},
[NodeInspectSymbol]() {
return this.toJSON();
}
};
/** @internal */
const EffectProto = {
[EffectTypeId]: effectVariance,
...PipeInspectableProto,
[Symbol.iterator]() {
return new SingleShotGen(this);
},
toJSON() {
return {
_id: "Effect",
op: this[identifier],
..."~effect/Effect/args" in this ? { args: this[args] } : void 0
};
}
};
/** @internal */
const isExit = (u) => hasProperty(u, ExitTypeId);
/** @internal */
const CauseTypeId = "~effect/Cause";
/** @internal */
const CauseReasonTypeId = "~effect/Cause/Reason";
/** @internal */
const isCause = (self) => hasProperty(self, CauseTypeId);
/** @internal */
var CauseImpl = class {
constructor(failures) {
this[CauseTypeId] = CauseTypeId;
this.reasons = failures;
}
pipe() {
return pipeArguments(this, arguments);
}
toJSON() {
return {
_id: "Cause",
failures: this.reasons.map((f) => f.toJSON())
};
}
toString() {
return `Cause(${format$1(this.reasons)})`;
}
[NodeInspectSymbol]() {
return this.toJSON();
}
[symbol](that) {
return isCause(that) && this.reasons.length === that.reasons.length && this.reasons.every((e, i) => equals$1(e, that.reasons[i]));
}
[symbol$1]() {
return array(this.reasons);
}
};
const annotationsMap = /*#__PURE__*/ new WeakMap();
/** @internal */
var ReasonBase = class {
[CauseReasonTypeId];
annotations;
_tag;
constructor(_tag, annotations, originalError) {
this[CauseReasonTypeId] = CauseReasonTypeId;
this._tag = _tag;
if (annotations !== constEmptyAnnotations && typeof originalError === "object" && originalError !== null && annotations.size > 0) {
const prevAnnotations = annotationsMap.get(originalError);
if (prevAnnotations) annotations = new Map([...prevAnnotations, ...annotations]);
annotationsMap.set(originalError, annotations);
}
this.annotations = annotations;
}
annotate(annotations, options) {
if (annotations.mapUnsafe.size === 0) return this;
const newAnnotations = new Map(this.annotations);
annotations.mapUnsafe.forEach((value, key) => {
if (options?.overwrite !== true && newAnnotations.has(key)) return;
newAnnotations.set(key, value);
});
const self = Object.assign(Object.create(Object.getPrototypeOf(this)), this);
self.annotations = newAnnotations;
return self;
}
pipe() {
return pipeArguments(this, arguments);
}
toString() {
return format$1(this);
}
[NodeInspectSymbol]() {
return this.toString();
}
};
/** @internal */
const constEmptyAnnotations = /*#__PURE__*/ new Map();
/** @internal */
var Fail = class extends ReasonBase {
constructor(error, annotations = constEmptyAnnotations) {
super("Fail", annotations, error);
this.error = error;
}
toString() {
return `Fail(${format$1(this.error)})`;
}
toJSON() {
return {
_tag: "Fail",
error: this.error
};
}
[symbol](that) {
return isFailReason$1(that) && equals$1(this.error, that.error) && equals$1(this.annotations, that.annotations);
}
[symbol$1]() {
return combine(string$1(this._tag))(combine(hash(this.error))(hash(this.annotations)));
}
};
/** @internal */
const causeFromReasons = (reasons) => new CauseImpl(reasons);
const dedupeReasons = (self, that) => {
const buckets = /* @__PURE__ */ new Map();
const out = [];
for (const reason of self.concat(that)) {
const hash$2 = hash(reason);
const bucket = buckets.get(hash$2);
if (bucket === void 0) buckets.set(hash$2, [reason]);
else if (bucket.some((previous) => equals$1(previous, reason))) continue;
else bucket.push(reason);
out.push(reason);
}
return out;
};
/** @internal */
const causeCombine = /*#__PURE__*/ dual(2, (self, that) => {
if (self.reasons.length === 0) return that;
else if (that.reasons.length === 0) return self;
const newCause = new CauseImpl(dedupeReasons(self.reasons, that.reasons));
return equals$1(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 causeFail = (error) => new CauseImpl([new Fail(error)]);
/** @internal */
var Die = class extends ReasonBase {
constructor(defect, annotations = constEmptyAnnotations) {
super("Die", annotations, defect);
this.defect = defect;
}
toString() {
return `Die(${format$1(this.defect)})`;
}
toJSON() {
return {
_tag: "Die",
defect: this.defect
};
}
[symbol](that) {
return isDieReason(that) && equals$1(this.defect, that.defect) && equals$1(this.annotations, that.annotations);
}
[symbol$1]() {
return combine(string$1(this._tag))(combine(hash(this.defect))(hash(this.annotations)));
}
};
/** @internal */
const causeDie = (defect) => new CauseImpl([new Die(defect)]);
/** @internal */
const causeAnnotate = /*#__PURE__*/ dual((args) => isCause(args[0]), (self, annotations, options) => {
if (annotations.mapUnsafe.size === 0) return self;
return new CauseImpl(self.reasons.map((f) => f.annotate(annotations, options)));
});
/** @internal */
const isFailReason$1 = (self) => self._tag === "Fail";
/** @internal */
const isDieReason = (self) => self._tag === "Die";
/** @internal */
const isInterruptReason = (self) => self._tag === "Interrupt";
function defaultEvaluate(_fiber) {
return exitDie(`Effect.evaluate: Not implemented`);
}
/** @internal */
const makePrimitiveProto = (options) => ({
...EffectProto,
[identifier]: options.op,
[evaluate]: options["~effect/Effect/evaluate"] ?? defaultEvaluate,
[contA]: options[contA],
[contE]: options[contE],
[contAll]: options[contAll]
});
/** @internal */
const makePrimitive = (options) => {
const Proto = makePrimitiveProto(options);
const PrimitiveImpl = function(value) {
this[args] = value;
};
PrimitiveImpl.prototype = Proto;
return function(value) {
return new PrimitiveImpl(value);
};
};
/** @internal */
const makeExit = (options) => {
const Proto = {
[ExitTypeId]: ExitTypeId,
_tag: options.op,
get [options.prop]() {
return this[args];
},
...makePrimitiveProto(options),
toString() {
return `${options.op}(${format$1(this[args])})`;
},
toJSON() {
return {
_id: "Exit",
_tag: options.op,
[options.prop]: this[args]
};
},
[symbol](that) {
return isExit(that) && that._tag === this._tag && equals$1(this["~effect/Effect/args"], that["~effect/Effect/args"]);
},
[symbol$1]() {
return combine(string$1(options.op), hash(this[args]));
}
};
const ExitPrimitive = function(value) {
this[args] = value;
};
ExitPrimitive.prototype = Proto;
return function(value) {
return new ExitPrimitive(value);
};
};
/** @internal */
const exitSucceed = /*#__PURE__*/ makeExit({
op: "Success",
prop: "value",
[evaluate](fiber) {
const cont = fiber.getCont(contA);
return cont ? cont[contA](this[args], fiber, this) : fiber.yieldWith(this);
}
});
/** @internal */
const StackTraceKey = { key: "effect/Cause/StackTrace" };
/** @internal */
const InterruptorStackTrace = { key: "effect/Cause/InterruptorStackTrace" };
/** @internal */
const exitFailCause = /*#__PURE__*/ makeExit({
op: "Failure",
prop: "cause",
[evaluate](fiber) {
let cause = this[args];
let annotated = false;
if (fiber.cache.stackFrame) {
cause = causeAnnotate(cause, { mapUnsafe: /* @__PURE__ */ new Map([[StackTraceKey.key, fiber.cache.stackFrame]]) });
annotated = true;
}
let cont = fiber.getCont(contE);
const interruptedCause = fiber._interruptedCause;
if (interruptedCause && fiber.interruptible) {
let skippedHandler = false;
while (cont && fiber.interruptible) {
skippedHandler ||= identifier in cont;
cont = fiber.getCont(contE);
}
if (skippedHandler) cause = causeFromReasons(cause.reasons.filter((reason) => reason._tag !== "Fail"));
cause = causeAddInterrupts(cause, interruptedCause);
annotated = true;
}
return cont ? cont[contE](cause, fiber, annotated ? void 0 : this) : fiber.yieldWith(annotated ? exitFailCause(cause) : this);
}
});
/** @internal */
const exitFail = (e) => exitFailCause(causeFail(e));
/** @internal */
const exitDie = (defect) => exitFailCause(causeDie(defect));
/** @internal */
const withFiber = /*#__PURE__*/ makePrimitive({
op: "WithFiber",
[evaluate](fiber) {
return this[args](fiber);
}
});
/** @internal */
const YieldableError = /*#__PURE__*/ function() {
class YieldableError extends globalThis.Error {}
const proto = /*#__PURE__*/ makePrimitiveProto({
op: "YieldableError",
[evaluate]() {
return exitFail(this);
}
});
delete proto.toString;
Object.assign(YieldableError.prototype, proto);
return YieldableError;
}();
/** @internal */
const Error$2 = /*#__PURE__*/ function() {
const plainArgsSymbol = /*#__PURE__*/ Symbol.for("effect/Data/Error/plainArgs");
return class Base extends YieldableError {
constructor(args) {
super(args?.message, args?.cause ? { cause: args.cause } : void 0);
if (args) {
assignProperties(this, args);
Object.defineProperty(this, plainArgsSymbol, {
value: args,
enumerable: false
});
}
}
toJSON() {
return {
...this[plainArgsSymbol],
...this
};
}
};
}();
/** @internal */
const TaggedError$1 = (tag) => {
class Base extends Error$2 {
_tag = tag;
}
Base.prototype.name = tag;
return Base;
};
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/option.js
/**
* @since 2.0.0
*/
const TypeId$15 = "~effect/Option";
const CommonProto$1 = {
[TypeId$15]: { _A: (_) => _ },
...PipeInspectableProto,
[Symbol.iterator]() {
return new SingleShotGen(this);
}
};
const SomeProto = /*#__PURE__*/ Object.defineProperty(/*#__PURE__*/ Object.assign(/*#__PURE__*/ Object.create(CommonProto$1), {
_tag: "Some",
_op: "Some",
[symbol](that) {
return isOption(that) && isSome$1(that) && equals$1(this.value, that.value);
},
[symbol$1]() {
return combine(hash(this._tag))(hash(this.value));
},
toString() {
return `some(${format$1(this.value)})`;
},
toJSON() {
return {
_id: "Option",
_tag: this._tag,
value: toJson(this.value)
};
}
}), "valueOrUndefined", { get() {
return this.value;
} });
const NoneHash = /*#__PURE__*/ hash("None");
const NoneProto = /*#__PURE__*/ Object.assign(/*#__PURE__*/ Object.create(CommonProto$1), {
_tag: "None",
_op: "None",
valueOrUndefined: void 0,
[symbol](that) {
return isOption(that) && isNone$1(that);
},
[symbol$1]() {
return NoneHash;
},
toString() {
return `none()`;
},
toJSON() {
return {
_id: "Option",
_tag: this._tag
};
}
});
/** @internal */
const isOption = (input) => hasProperty(input, TypeId$15);
/** @internal */
const isNone$1 = (fa) => fa._tag === "None";
/** @internal */
const isSome$1 = (fa) => fa._tag === "Some";
/** @internal */
const none$1 = /*#__PURE__*/ Object.create(NoneProto);
/** @internal */
const SomeImpl = function(value) {
this.value = value;
};
SomeImpl.prototype = SomeProto;
/** @internal */
const some$1 = (value) => new SomeImpl(value);
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/result.js
const TypeId$14 = "~effect/Result";
const CommonProto = {
[TypeId$14]: {
/* 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(that) && isSuccess$2(that) && equals$1(this.success, that.success);
},
[symbol$1]() {
return combine(hash(this._tag))(hash(this.success));
},
toString() {
return `success(${format$1(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(that) && isFailure$1(that) && equals$1(this.failure, that.failure);
},
[symbol$1]() {
return combine(hash(this._tag))(hash(this.failure));
},
toString() {
return `failure(${format$1(this.failure)})`;
},
toJSON() {
return {
_id: "Result",
_tag: this._tag,
failure: toJson(this.failure)
};
}
});
/** @internal */
const isResult = (input) => hasProperty(input, TypeId$14);
/** @internal */
const isFailure$1 = (result) => result._tag === "Failure";
/** @internal */
const isSuccess$2 = (result) => result._tag === "Success";
/** @internal */
const FailureImpl = function(failure) {
this.failure = failure;
};
FailureImpl.prototype = FailureProto;
/** @internal */
const SuccessImpl = function(success) {
this.success = success;
};
SuccessImpl.prototype = SuccessProto;
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Order.js
/**
* Defines comparison functions for ordered values.
*
* An `Order<A>` compares two `A` values and returns whether the first is less
* than, equal to, or greater than the second. Orders are used for sorting,
* choosing minimum or maximum values, checking ranges, and building ordered data
* structures. This module includes built-in orders, constructors for custom
* orders, tools for reversing and combining comparisons, tuple and struct
* helpers, comparison predicates, clamping, and reducer support.
*
* @stability stable
* @since 2.0.0
*/
/**
* Creates a new `Order` instance from a comparison function.
*
* **When to use**
*
* Use when you need a sorting rule not covered by the built-in orders or input
* mapping helpers, and you can provide a total comparison.
*
* **Details**
*
* Uses reference equality (`===`) as a shortcut: if `self === that`, it returns
* `0` without calling the comparison function. The comparison function should
* return `-1`, `0`, or `1`, and the returned order satisfies total ordering
* laws when the comparison function does.
*
* **Example** (Creating an Order)
*
* ```ts import.meta.vitest
* import { Order } from "effect"
*
* const byAge = Order.make<{ name: string; age: number }>((self, that) => {
* if (self.age < that.age) return -1
* if (self.age > that.age) return 1
* return 0
* })
*
* byAge({ name: "Alice", age: 30 }, { name: "Bob", age: 25 }) // => 1
* byAge({ name: "Alice", age: 25 }, { name: "Bob", age: 30 }) // => -1
* ```
*
* @see {@link mapInput} to transform an order by mapping the input type
* @see {@link combine} to combine multiple orders
* @stability stable
* @category constructors
* @since 2.0.0
*/
function make$10(compare) {
return (self, that) => self === that ? 0 : compare(self, that);
}
/**
* Order instance for strings that compares them lexicographically using JavaScript's `<` operator.
*
* **When to use**
*
* Use when you need lexicographic string ordering.
*
* **Details**
*
* Uses lexicographic dictionary ordering. The empty string is less than any
* non-empty string, and comparisons are case-sensitive.
*
* **Example** (Ordering strings)
*
* ```ts import.meta.vitest
* import { Order } from "effect"
*
* Order.String("apple", "banana") // => -1
* Order.String("banana", "apple") // => 1
* Order.String("apple", "apple") // => 0
* ```
*
* @see {@link mapInput} to compare objects by a string property
* @see {@link Struct} to combine with other orders for struct comparison
* @stability stable
* @category instances
* @since 4.0.0
*/
const String$4 = /*#__PURE__*/ make$10((self, that) => self < that ? -1 : 1);
/**
* Order instance for numbers that compares them numerically.
*
* **When to use**
*
* Use when you need numeric ordering for numbers.
*
* **Details**
*
* `0` is considered equal to `-0`. All `NaN` values are considered equal to
* each other, and any `NaN` is considered less than any non-`NaN` number. All
* other values use standard numeric comparison.
*
* **Example** (Ordering numbers)
*
* ```ts import.meta.vitest
* import { Order } from "effect"
*
* Order.Number(1, 1) // => 0
* Order.Number(1, 2) // => -1
* Order.Number(2, 1) // => 1
*
* Order.Number(0, -0) // => 0
* Order.Number(NaN, 1) // => -1
* ```
*
* @see {@link mapInput} to compare objects by a number property
* @see {@link BigInt} for bigint comparisons
* @stability stable
* @category instances
* @since 4.0.0
*/
const Number$4 = /*#__PURE__*/ make$10((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;
return self < that ? -1 : 1;
});
/**
* Checks whether one value is less than or equal to another according to the given order.
*
* **When to use**
*
* Use when you need a boolean less-than-or-equal predicate using an `Order`.
*
* **Details**
*
* Returns `true` if the order returns `-1` or `0`, and returns `false` only if
* the order returns `1`.
*
* **Example** (Checking less-than-or-equal comparisons)
*
* ```ts import.meta.vitest
* import { Order } from "effect"
*
* const isLessThanOrEqualToNumber = Order.isLessThanOrEqualTo(Order.Number)
*
* isLessThanOrEqualToNumber(1, 2) // => true
* isLessThanOrEqualToNumber(1, 1) // => true
* isLessThanOrEqualToNumber(2, 1) // => false
* ```
*
* @see {@link isLessThan} for strict less than
* @see {@link isGreaterThan} for strict greater than
* @stability stable
* @category predicates
* @since 4.0.0
*/
const isLessThanOrEqualTo$1 = (O) => dual(2, (self, that) => O(self, that) !== 1);
/**
* Checks whether one value is greater than or equal to another according to the given order.
*
* **When to use**
*
* Use when you need a boolean greater-than-or-equal predicate using an
* `Order`.
*
* **Details**
*
* Returns `true` if the order returns `1` or `0`, and returns `false` only if
* the order returns `-1`.
*
* **Example** (Checking greater-than-or-equal comparisons)
*
* ```ts import.meta.vitest
* import { Order } from "effect"
*
* const isGreaterThanOrEqualToNumber = Order.isGreaterThanOrEqualTo(Order.Number)
*
* isGreaterThanOrEqualToNumber(2, 1) // => true
* isGreaterThanOrEqualToNumber(1, 1) // => true
* isGreaterThanOrEqualToNumber(1, 2) // => false
* ```
*
* @see {@link isGreaterThan} for strict greater than
* @see {@link isLessThanOrEqualTo} for less than or equal
* @stability stable
* @category predicates
* @since 4.0.0
*/
const isGreaterThanOrEqualTo$1 = (O) => dual(2, (self, that) => O(self, that) !== -1);
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Option.js
/**
* Creates an `Option` representing the absence of a value.
*
* **When to use**
*
* Use to represent a missing or uninitialized value, such as returning "no
* result" from a function.
*
* **Details**
*
* - Returns `Option<never>`, which is a subtype of `Option<A>` for any `A`
* - Always returns the same singleton instance
*
* **Example** (Creating an empty Option)
*
* ```ts import.meta.vitest
* import { Option } from "effect"
*
* // ┌─── Option<never>
* // â–¼
* const noValue = Option.none() // => Option.none()
* ```
*
* @see {@link some} for the opposite operation.
*
* @stability stable
* @category constructors
* @since 2.0.0
*/
const none = () => none$1;
/**
* Wraps the given value into an `Option` to represent its presence.
*
* **When to use**
*
* Use to wrap a known present value as `Option`
* - Returning a successful result from a partial function
*
* **Details**
*
* - Always returns `Some<A>`
* - Does not filter `null` or `undefined`; use {@link fromNullishOr} for that
*
* **Example** (Wrapping a value)
*
* ```ts import.meta.vitest
* import { Option } from "effect"
*
* // ┌─── Option<number>
* // â–¼
* const value = Option.some(1) // => Option.some(1)
* ```
*
* @see {@link none} for the opposite operation.
*
* @stability stable
* @category constructors
* @since 2.0.0
*/
const some = some$1;
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Array.js
/**
* 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;
/**
* 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]);
Array$1.isArray;
/**
* 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;
/**
* 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$1 = () => [];
/**
* 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$2 = /*#__PURE__*/ dual(2, (self, f) => self.map(f));
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/BigDecimal.js
/**
* Decimal numbers and arithmetic for cases where JavaScript `number` rounding
* is not precise enough. A `BigDecimal` stores digits as a `bigint` plus a
* decimal scale, which lets the module parse, compare, add, subtract, multiply,
* divide, round, and format decimal values such as money, quantities, and
* measurements.
*
* @stability stable
* @since 2.0.0
*/
const TypeId$13 = "~effect/BigDecimal";
const BigDecimalProto = {
[TypeId$13]: TypeId$13,
[symbol$1]() {
const normalized = normalize(this);
return combine(string$1(String(normalized.value)), number$1(normalized.scale));
},
[symbol](that) {
return isBigDecimal(that) && compare(this, that) === 0;
},
toString() {
return `BigDecimal(${format(this)})`;
},
toJSON() {
return {
_id: "BigDecimal",
value: String(this.value),
scale: this.scale
};
},
[NodeInspectSymbol]() {
return this.toJSON();
},
pipe() {
return pipeArguments(this, arguments);
}
};
/**
* Checks whether a given value is a `BigDecimal`.
*
* **When to use**
*
* Use to validate unknown input and narrow it to `BigDecimal`.
*
* **Example** (Checking BigDecimal values)
*
* ```ts import.meta.vitest
* import { BigDecimal } from "effect"
*
* const decimal = BigDecimal.fromNumber(123.45)
* BigDecimal.isBigDecimal(decimal) // => false
* BigDecimal.isBigDecimal(BigDecimal.fromStringUnsafe("123.45")) // => true
* BigDecimal.isBigDecimal(123.45) // => false
* BigDecimal.isBigDecimal("123.45") // => false
* ```
*
* @stability stable
* @category guards
* @since 2.0.0
*/
const isBigDecimal = (u) => hasProperty(u, TypeId$13);
/**
* Creates a `BigDecimal` from a `bigint` value and a safe integer scale.
*
* **When to use**
*
* Use to construct a decimal directly from its unscaled integer value and
* decimal scale.
*
* **Gotchas**
*
* Throws a `RangeError` if `scale` is not a safe integer.
*
* **Example** (Creating decimals from bigint and scale)
*
* ```ts import.meta.vitest
* import { BigDecimal } from "effect"
*
* // Create 123.45 (12345 with scale 2)
* const decimal = BigDecimal.make(12345n, 2)
* decimal // => BigDecimal.fromStringUnsafe("123.45")
*
* // Create 42 (42 with scale 0)
* const integer = BigDecimal.make(42n, 0)
* integer // => BigDecimal.fromBigInt(42n)
* ```
*
* @see {@link fromBigInt} for constructing an integer decimal from a `bigint`
*
* @stability stable
* @category constructors
* @since 2.0.0
*/
const make$9 = (value, scale) => {
if (!Number.isSafeInteger(scale)) throw new RangeError(`Scale must be a safe integer, got ${scale}`);
const o = Object.create(BigDecimalProto);
o.value = value;
o.scale = scale;
return o;
};
const makeNormalized = (value, scale) => {
const o = make$9(value, scale);
o.normalized = o;
return o;
};
const bigint0$1 = /*#__PURE__*/ BigInt(0);
const bigint1$1 = /*#__PURE__*/ BigInt(1);
const bigint10$1 = /*#__PURE__*/ BigInt(10);
const zero$1 = /*#__PURE__*/ makeNormalized(bigint0$1, 0);
/**
* Normalizes a given `BigDecimal` by removing trailing zeros.
*
* **When to use**
*
* Use to canonicalize decimals that have equivalent values but different
* internal scales.
*
* **Example** (Normalizing trailing zeros)
*
* ```ts import.meta.vitest
* import { BigDecimal } from "effect"
*
* const decimal = BigDecimal.normalize(BigDecimal.fromStringUnsafe("123.00000"))
* const decimalStorage = [decimal.value, decimal.scale] // => [123n, 0]
*
* const largeDecimal = BigDecimal.normalize(BigDecimal.fromStringUnsafe("12300000"))
* const largeDecimalStorage = [largeDecimal.value, largeDecimal.scale] // => [123n, -5]
* ```
*
* @see {@link format} for rendering normalized decimals as strings
*
* @stability stable
* @category scaling
* @since 2.0.0
*/
const normalize = (self) => {
if (self.normalized === void 0) {
if (self.value === bigint0$1) self.normalized = zero$1;
else {
const digits = `${self.value}`;
let end = digits.length;
while (digits[end - 1] === "0") end--;
self.normalized = makeNormalized(BigInt(digits.slice(0, end)), self.scale - (digits.length - end));
}
}
return self.normalized;
};
const MAX_COMPARISON_SCALE_ALIGNMENT = 100;
const comparisonPowersOfTen = [bigint1$1];
const compareBigInt = (self, that) => self === that ? 0 : self < that ? -1 : 1;
const compareMagnitude = (self, that) => {
const selfDigits = `${self.value < bigint0$1 ? -self.value : self.value}`;
const thatDigits = `${that.value < bigint0$1 ? -that.value : that.value}`;
const exponentDifference = BigInt(selfDigits.length - thatDigits.length) - BigInt(self.scale) + BigInt(that.scale);
if (exponentDifference !== bigint0$1) return exponentDifference < bigint0$1 ? -1 : 1;
const length = Math.max(selfDigits.length, thatDigits.length);
return String$4(selfDigits.padEnd(length, "0"), thatDigits.padEnd(length, "0"));
};
const compare = (self, that) => {
if (self.scale === that.scale) return compareBigInt(self.value, that.value);
const selfSign = sign(self);
const thatSign = sign(that);
if (selfSign !== thatSign) return selfSign < thatSign ? -1 : 1;
if (selfSign === 0) return 0;
const scaleDifference = self.scale - that.scale;
const absoluteScaleDifference = Math.abs(scaleDifference);
if (absoluteScaleDifference > MAX_COMPARISON_SCALE_ALIGNMENT) return selfSign === -1 ? compareMagnitude(that, self) : compareMagnitude(self, that);
const powerOfTen = comparisonPowersOfTen[absoluteScaleDifference] ??= bigint10$1 ** BigInt(absoluteScaleDifference);
return scaleDifference > 0 ? compareBigInt(self.value, that.value * powerOfTen) : compareBigInt(self.value * powerOfTen, that.value);
};
/**
* Determines the sign of a given `BigDecimal`.
*
* **When to use**
*
* Use to classify a `BigDecimal` as negative, zero, or positive.
*
* **Example** (Reading decimal signs)
*
* ```ts import.meta.vitest
* import { BigDecimal } from "effect"
*
* BigDecimal.sign(BigDecimal.fromStringUnsafe("-5")) // => -1
* BigDecimal.sign(BigDecimal.fromStringUnsafe("0")) // => 0
* BigDecimal.sign(BigDecimal.fromStringUnsafe("5")) // => 1
* ```
*
* @stability stable
* @category math
* @since 2.0.0
*/
const sign = (n) => n.value === bigint0$1 ? 0 : n.value < bigint0$1 ? -1 : 1;
/**
* Formats a `BigDecimal` as a string.
*
* **When to use**
*
* Use to render a `BigDecimal` as plain decimal text when possible.
*
* **Details**
*
* The value is normalized before formatting. Scientific notation is used when
* the absolute value of the normalized scale is at least `16`; otherwise plain
* decimal notation is used.
*
* **Example** (Formatting decimals)
*
* ```ts import.meta.vitest
* import { BigDecimal } from "effect"
*
* BigDecimal.format(BigDecimal.fromStringUnsafe("-5")) // => "-5"
* BigDecimal.format(BigDecimal.fromStringUnsafe("123.456")) // => "123.456"
* BigDecimal.format(BigDecimal.fromStringUnsafe("-0.00000123")) // => "-0.00000123"
* ```
*
* @see {@link toExponential} for always rendering scientific notation
*
* @stability stable
* @category converting
* @since 2.0.0
*/
const format = (n) => {
const normalized = normalize(n);
if (Math.abs(normalized.scale) >= 16) return toExponential(normalized);
const negative = normalized.value < bigint0$1;
const absolute = `${negative ? -normalized.value : normalized.value}`;
const digits = normalized.scale > 0 ? absolute.padStart(normalized.scale + 1, "0") : absolute.padEnd(absolute.length - normalized.scale, "0");
const point = digits.length - normalized.scale;
const complete = normalized.scale > 0 ? `${digits.slice(0, point)}.${digits.slice(point)}` : digits;
return negative ? `-${complete}` : complete;
};
/**
* Formats a given `BigDecimal` as a `string` in scientific notation.
*
* **When to use**
*
* Use to render a `BigDecimal` in scientific notation.
*
* **Example** (Formatting decimals exponentially)
*
* ```ts import.meta.vitest
* import { BigDecimal } from "effect"
*
* BigDecimal.toExponential(BigDecimal.make(123456n, -5)) // => "1.23456e+10"
* ```
*
* @see {@link format} for plain decimal formatting when possible
*
* @stability stable
* @category converting
* @since 3.11.0
*/
const toExponential = (n) => {
if (isZero(n)) return "0e+0";
const normalized = normalize(n);
const digits = `${normalized.value}`;
const point = normalized.value < bigint0$1 ? 2 : 1;
const head = digits.slice(0, point);
const tail = digits.slice(point);
const exp = tail.length - normalized.scale;
return `${head}${tail === "" ? "" : `.${tail}`}e${exp >= 0 ? "+" : ""}${exp}`;
};
/**
* Checks whether a given `BigDecimal` is `0`.
*
* **When to use**
*
* Use to test whether a `BigDecimal` is exactly zero.
*
* **Example** (Checking zero decimals)
*
* ```ts import.meta.vitest
* import { BigDecimal } from "effect"
*
* BigDecimal.isZero(BigDecimal.fromStringUnsafe("0")) // => true
* BigDecimal.isZero(BigDecimal.fromStringUnsafe("1")) // => false
* ```
*
* @stability stable
* @category predicates
* @since 2.0.0
*/
const isZero = (n) => n.value === bigint0$1;
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Effectable.js
/**
* Create a low-level `Effect` prototype.
*
* **When to use**
*
* Use when you need to create a custom Effect-like value without extending a
* class, by providing a label and an evaluate function that receives the
* current fiber.
*
* **Details**
*
* When the effect is evaluated, it calls `evaluate` with the current fiber.
*
* @see {@link Class} for a class-based approach to defining custom Effect values
* @see {@link Mixin} for wrapping an existing class constructor
*
* @stability stable
* @category prototypes
* @since 4.0.0
*/
const Prototype = (options) => makePrimitiveProto({
op: options.label,
[evaluate]: options.evaluate
});
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Context.js
/**
* Runtime type identifier attached to `Context` service keys and used by
* `isKey` to recognize them.
*
* @stability stable
* @category type IDs
* @since 4.0.0
*/
const ServiceTypeId = "~effect/Context/Service";
/**
* Creates a `Context` service key.
*
* **When to use**
*
* Use when you need to define a context service key for a dependency that must
* be provided by the surrounding context.
*
* **Details**
*
* Call `Context.Service("Key")` for a function-style key, or use the two-stage
* form `Context.Service<Self, Shape>()("Key")` for class-style service
* declarations. The returned key can be yielded as an Effect and passed to
* `Context.make`, `Context.add`, and the Context getter functions.
*
* **Gotchas**
*
* The string key is the runtime identity of the service. Reusing the same key
* string for unrelated services makes them occupy the same slot in a
* `Context`.
*
* **Example** (Creating service keys)
*
* ```ts import.meta.vitest
* import { Context } from "effect"
*
* // Create a simple service
* const Database = Context.Service<{
* query: (sql: string) => string
* }>("Database")
*
* // Create a service class
* class Config extends Context.Service<Config, {
* port: number
* }>()("Config") {}
*
* // Use the services to create contexts
* const db = Context.make(Database, {
* query: (sql) => `Result: ${sql}`
* })
* const config = Context.make(Config, { port: 8080 })
* Context.get(db, Database).query("SELECT 1") // => "Result: SELECT 1"
* Context.get(config, Config).port // => 8080
* ```
*
* @see {@link Reference} for service keys with default values
*
* @stability stable
* @category services
* @since 4.0.0
*/
const Service = function() {
function KeyClass() {}
const self = KeyClass;
Object.setPrototypeOf(self, ServiceProto);
const init = (key, options) => {
self.key = key;
if (options?.defaultValue) {
self[ReferenceTypeId] = ReferenceTypeId;
self.defaultValue = options.defaultValue;
}
if (options?.make) self.make = options.make;
if (options?.fiberCached) cacheKeys.add(key);
return self;
};
return arguments.length > 0 ? init(arguments[0], arguments[1]) : init;
};
const ServiceProto = {
[ServiceTypeId]: ServiceTypeId,
.../*#__PURE__*/ Prototype({
label: "Service",
evaluate(fiber) {
return exitSucceed(get(fiber.context, this));
}
}),
toJSON() {
return {
_id: "Service",
key: this.key
};
},
of(self) {
return self;
},
context(self) {
return make$8(this, self);
},
use(f) {
return withFiber((fiber) => f(get(fiber.context, this)));
},
useSync(f) {
return withFiber((fiber) => exitSucceed(f(get(fiber.context, this))));
}
};
const cacheKeys = /*#__PURE__*/ new Set();
const ReferenceTypeId = "~effect/Context/Reference";
const TypeId$12 = "~effect/Context";
const MaxDepth = 8;
const FlattenAfterBaseHits = 8;
const makeImpl = (cacheRoot, base, overlay, depth) => {
const self = Object.create(Proto$5);
self.cacheRoot = cacheRoot ?? self;
self.base = base;
self.overlay = overlay;
self.depth = depth;
self._flat = void 0;
self.baseHits = 0;
return self;
};
const applyOverlays = (map, overlay) => {
if (!overlay) return;
applyOverlays(map, overlay.parent);
map.set(overlay.key, overlay.value);
};
const flatten = (self) => {
if (self._flat) return self._flat;
if (!self.overlay) return self._flat = self.base;
const map = new Map(self.base);
applyOverlays(map, self.overlay);
return self._flat = map;
};
const notFound = /*#__PURE__*/ Symbol();
const lookup = (self, key) => {
const impl = self;
for (let overlay = impl.overlay; overlay; overlay = overlay.parent) if (overlay.key === key) return overlay.value;
const value = impl.base.get(key);
if (value === void 0 && !impl.base.has(key)) return notFound;
if (impl.overlay && ++impl.baseHits >= impl.base.size && impl.baseHits >= FlattenAfterBaseHits) {
impl.base = flatten(impl);
impl.overlay = void 0;
impl.depth = 0;
}
return value;
};
/**
* Creates a `Context` from an existing service map.
*
* **When to use**
*
* Use when constructing a low-level `Context` from a trusted map whose lifecycle
* you control.
*
* **Gotchas**
*
* The provided map is retained without copying and must not be mutated after
* construction. Prefer `empty`, `make`, `add`, or `merge` for normal Context
* construction.
*
* **Example** (Creating a context from a map)
*
* ```ts import.meta.vitest
* import { Context } from "effect"
*
* // Create a context from a Map (unsafe)
* const map = new Map([
* ["Logger", { log: (_msg: string) => {} }]
* ])
*
* const context = Context.makeUnsafe(map)
* context.mapUnsafe.size // => 1
* ```
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const makeUnsafe$2 = (mapUnsafe) => makeImpl(void 0, mapUnsafe, void 0, 0);
const Proto$5 = {
get mapUnsafe() {
return flatten(this);
},
...PipeInspectableProto,
[TypeId$12]: { _Services: (_) => _ },
toJSON() {
return {
_id: "Context",
services: Array.from(this.mapUnsafe).map(([key, value]) => ({
key,
value
}))
};
},
[symbol](that) {
if (!isContext(that)) return false;
const self = this.mapUnsafe;
const other = that.mapUnsafe;
if (self.size !== other.size) return false;
for (const [key, value] of self) if (!other.has(key) || !equals$1(value, other.get(key))) return false;
return true;
},
[symbol$1]() {
return number$1(this.mapUnsafe.size);
}
};
/** @internal */
const hasSameCache = (self, that) => self.cacheRoot === that.cacheRoot;
/**
* Checks whether the provided argument is a `Context`.
*
* **When to use**
*
* Use to narrow an unknown value before passing it to APIs that require a
* `Context`.
*
* **Details**
*
* This checks the runtime `Context` marker and does not inspect which services
* the context contains.
*
* **Gotchas**
*
* This guard only proves that the value is a `Context`; it does not prove that
* any specific service is present.
*
* **Example** (Checking for contexts)
*
* ```ts import.meta.vitest
* import { Context } from "effect"
* Context.isContext(Context.empty()) // => true
* ```
*
* @see {@link isKey} for checking service keys
* @see {@link isReference} for checking references with defaults
*
* @stability stable
* @category guards
* @since 2.0.0
*/
const isContext = (u) => hasProperty(u, TypeId$12);
/**
* Checks whether the provided argument is a `Reference`.
*
* **Example** (Checking for references)
*
* ```ts import.meta.vitest
* import { Context } from "effect"
*
* const LoggerRef = Context.Reference("Logger", {
* defaultValue: () => ({ log: (_msg: string) => {} })
* })
*
* Context.isReference(LoggerRef) // => true
* Context.isReference(Context.Service("Key")) // => false
* ```
*
* @stability stable
* @category guards
* @since 3.11.0
*/
const isReference = (u) => !!u[ReferenceTypeId];
/**
* Returns an empty `Context`.
*
* **Example** (Creating an empty context)
*
* ```ts import.meta.vitest
* import { Context } from "effect"
* Context.empty().mapUnsafe.size // => 0
* ```
*
* @stability stable
* @category constructors
* @since 2.0.0
*/
const empty = () => emptyContext;
const emptyContext = /*#__PURE__*/ makeUnsafe$2(/*#__PURE__*/ new Map());
/**
* Creates a new `Context` with a single service associated to the key.
*
* **Example** (Creating a context with one service)
*
* ```ts import.meta.vitest
* import { Context } from "effect"
*
* const Port = Context.Service<{ PORT: number }>("Port")
*
* const context = Context.make(Port, { PORT: 8080 })
*
* Context.get(context, Port).PORT // => 8080
* ```
*
* @stability stable
* @category constructors
* @since 2.0.0
*/
const make$8 = (key, service) => makeUnsafe$2(/* @__PURE__ */ new Map([[key.key, service]]));
/**
* Adds a service to a given `Context`.
*
* **When to use**
*
* Use when you need to store a known service value in a `Context`.
*
* **Details**
*
* If the context already contains the same service key, the new service
* replaces the previous one.
*
* **Example** (Adding a service to a context)
*
* ```ts import.meta.vitest
* import { Context, pipe } from "effect"
*
* const Port = Context.Service<{ PORT: number }>("Port")
* const Timeout = Context.Service<{ TIMEOUT: number }>("Timeout")
*
* const someContext = Context.make(Port, { PORT: 8080 })
*
* const context = pipe(
* someContext,
* Context.add(Timeout, { TIMEOUT: 5000 })
* )
*
* const values = [Context.get(context, Port).PORT, Context.get(context, Timeout).TIMEOUT]
* values // => [8080, 5000]
* ```
*
* @see {@link addOrOmit} for adding or removing a service from an `Option`
*
* @stability stable
* @category combining
* @since 2.0.0
*/
const add = /*#__PURE__*/ dual(3, (self, key, service) => addUnsafe(self, key.key, service));
/**
* Adds a service by key to a given `Context` using a string key.
*
* @stability stable
* @category combining
* @since 4.0.0
*/
const addUnsafe = (self, key, service) => {
const impl = self;
const cacheRoot = cacheKeys.has(key) ? void 0 : impl.cacheRoot;
if (impl.depth >= MaxDepth) {
const map = new Map(impl._flat ?? impl.base);
if (!impl._flat) applyOverlays(map, impl.overlay);
map.set(key, service);
return makeImpl(cacheRoot, map, void 0, 0);
}
return makeImpl(cacheRoot, impl.base, {
key,
value: service,
parent: impl.overlay
}, impl.depth + 1);
};
/** @internal */
const getOrUndefinedUnsafe = (self, key) => {
const value = lookup(self, key);
return value === notFound ? void 0 : value;
};
/**
* Gets a service from the context that corresponds to the given key.
*
* **When to use**
*
* Use when you need type-checked access to a service already included in the
* context type.
*
* **Example** (Getting a service from a context)
*
* ```ts import.meta.vitest
* import { Context, pipe } from "effect"
*
* const Port = Context.Service<{ PORT: number }>("Port")
* const Timeout = Context.Service<{ TIMEOUT: number }>("Timeout")
*
* const context = pipe(
* Context.make(Port, { PORT: 8080 }),
* Context.add(Timeout, { TIMEOUT: 5000 })
* )
*
* Context.get(context, Timeout).TIMEOUT // => 5000
* ```
*
* @see {@link getOption} for optional service access
* @see {@link getOrElse} for fallback values
*
* @stability stable
* @category getters
* @since 2.0.0
*/
const get = /* @__PURE__ */ dual(2, (self, service) => {
const value = lookup(self, service.key);
if (value === notFound) {
if (isReference(service)) return getDefaultValue(service);
throw serviceNotFoundError(service);
}
return value;
});
const defaultValueCacheKey = "~effect/Context/defaultValue";
const getDefaultValue = (ref) => {
if (defaultValueCacheKey in ref) return ref[defaultValueCacheKey];
return ref[defaultValueCacheKey] = ref.defaultValue();
};
const serviceNotFoundError = (service) => {
const error = /* @__PURE__ */ new Error(`Service not found${service.key ? `: ${String(service.key)}` : ""}`);
if (error.stack) {
const lines = error.stack.split("\n");
lines.splice(1, 3);
error.stack = lines.join("\n");
}
return error;
};
/**
* Creates a context key with a default value.
*
* **When to use**
*
* Use when you need to define a context key with a lazily computed default
* value.
*
* **Details**
*
* `Context.Reference` allows you to create a key that can hold a value. You
* can provide a default value for the service, which will automatically be used
* when the context is accessed, or override it with a custom implementation
* when needed. The default value is computed lazily and cached on the
* reference.
*
* **Example** (Creating references with default values)
*
* ```ts import.meta.vitest
* import { Context } from "effect"
*
* // Create a reference with a default value
* const messages: Array<string> = []
* const LoggerRef = Context.Reference("Logger", {
* defaultValue: () => ({ log: (msg: string) => messages.push(`Default: ${msg}`) })
* })
*
* // The reference provides the default value when accessed from an empty context
* const context = Context.empty()
* const logger = Context.get(context, LoggerRef)
*
* // You can also override the default value
* const customContext = Context.make(LoggerRef, {
* log: (msg: string) => messages.push(`Custom: ${msg}`)
* })
* const customLogger = Context.get(customContext, LoggerRef)
* logger.log("default")
* customLogger.log("message")
* messages // => ["Default: default", "Custom: message"]
* ```
*
* @see {@link Service} for required services without default values
*
* @stability stable
* @category services
* @since 3.11.0
*/
const Reference = Service;
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Duration.js
const TypeId$11 = "~effect/Duration";
const bigint0 = /*#__PURE__*/ BigInt(0);
const bigint1 = /*#__PURE__*/ BigInt(1);
const bigint2 = /*#__PURE__*/ BigInt(2);
const bigint10 = /*#__PURE__*/ BigInt(10);
const bigint1e3 = /*#__PURE__*/ BigInt(1e3);
const bigint1e6 = /*#__PURE__*/ BigInt(1e6);
const roundTiesAwayFromZero = (input) => BigInt(Math.sign(input) * Math.round(Math.abs(input)));
const roundMillisToNanos = (millis) => Number.isInteger(millis) ? BigInt(millis) * bigint1e6 : roundTiesAwayFromZero(millis * 1e6);
const fromNanosNumber = (nanos) => make$7(Number.isFinite(nanos) ? roundTiesAwayFromZero(nanos) : nanos);
const parseNanos = (input, scale) => {
const decimalIndex = input.indexOf(".");
if (decimalIndex === -1) return BigInt(input) * scale;
const isNegative = input[0] === "-";
const fractional = input.slice(decimalIndex + 1);
const fractionalScale = bigint10 ** BigInt(fractional.length);
const scaled = (BigInt(input.slice(isNegative ? 1 : 0, decimalIndex)) * fractionalScale + BigInt(fractional)) * scale;
return divideTiesAwayFromZero(isNegative ? -scaled : scaled, fractionalScale);
};
const divideTiesAwayFromZero = (numerator, denominator) => {
const absolute = numerator < bigint0 ? -numerator : numerator;
const rounded = absolute / denominator + (absolute % denominator * bigint2 >= denominator ? bigint1 : bigint0);
return numerator < bigint0 ? -rounded : rounded;
};
const DURATION_REGEXP = /^(-?\d+(?:\.\d+)?)\s+(nanos?|micros?|millis?|seconds?|minutes?|hours?|days?|weeks?)$/;
/**
* Decodes a `Duration.Input` into a `Duration`.
*
* **When to use**
*
* Use when the input has already been validated or comes from a trusted source
* and throwing is acceptable for invalid duration syntax.
*
* **Gotchas**
*
* If the input is not a valid `Duration.Input`, it throws an error.
*
* **Example** (Decoding duration inputs)
*
* ```ts import.meta.vitest
* import { Duration } from "effect"
*
* Duration.fromInputUnsafe(1000) // => Duration.millis(1000)
* Duration.fromInputUnsafe("5 seconds") // => Duration.seconds(5)
* Duration.fromInputUnsafe("Infinity") // => Duration.infinity
* Duration.fromInputUnsafe([2, 500_000_000]) // => Duration.nanos(2_500_000_000n)
* ```
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const fromInputUnsafe = (input) => {
switch (typeof input) {
case "number": return millis(input);
case "bigint": return nanos(input);
case "string": {
if (input === "Infinity") return infinity;
if (input === "-Infinity") return negativeInfinity;
const match = DURATION_REGEXP.exec(input);
if (!match) break;
const [_, valueStr, unit] = match;
if (unit === "nano" || unit === "nanos") return nanos(parseNanos(valueStr, bigint1));
if (unit === "micro" || unit === "micros") return nanos(parseNanos(valueStr, bigint1e3));
const value = Number(valueStr);
switch (unit) {
case "milli":
case "millis": return millis(value);
case "second":
case "seconds": return seconds(value);
case "minute":
case "minutes": return minutes(value);
case "hour":
case "hours": return hours(value);
case "day":
case "days": return days(value);
case "week":
case "weeks": return weeks(value);
}
break;
}
case "object": {
if (input === null) break;
if (TypeId$11 in input) return input;
if (Array.isArray(input)) {
if (input.length !== 2 || !input.every(isNumber)) return invalid$1(input);
if (Number.isNaN(input[0]) || Number.isNaN(input[1])) return zero;
if (input[0] === -Infinity || input[1] === -Infinity) return negativeInfinity;
if (input[0] === Infinity || input[1] === Infinity) return infinity;
return fromNanosNumber(input[0] * 1e9 + input[1]);
}
const obj = input;
let millis = 0;
if (obj.weeks) millis += obj.weeks * 6048e5;
if (obj.days) millis += obj.days * 864e5;
if (obj.hours) millis += obj.hours * 36e5;
if (obj.minutes) millis += obj.minutes * 6e4;
if (obj.seconds) millis += obj.seconds * 1e3;
if (obj.milliseconds) millis += obj.milliseconds;
if (!obj.microseconds && !obj.nanoseconds) return make$7(millis);
return fromNanosNumber(millis * 1e6 + (obj.microseconds ?? 0) * 1e3 + (obj.nanoseconds ?? 0));
}
}
return invalid$1(input);
};
const invalid$1 = (input) => {
throw new Error(`Invalid Input: ${input}`);
};
const zeroDurationValue = {
_tag: "Millis",
millis: 0
};
const infinityDurationValue = { _tag: "Infinity" };
const negativeInfinityDurationValue = { _tag: "NegativeInfinity" };
const DurationProto = {
[TypeId$11]: TypeId$11,
[symbol$1]() {
switch (this.value._tag) {
case "Millis": return hash(roundMillisToNanos(this.value.millis));
case "Nanos": return hash(this.value.nanos);
default: return structure(this.value);
}
},
[symbol](that) {
return isDuration(that) && equals(this, that);
},
toString() {
switch (this.value._tag) {
case "Infinity": return "Infinity";
case "NegativeInfinity": return "-Infinity";
case "Nanos": return `${this.value.nanos} nanos`;
case "Millis": return `${this.value.millis} millis`;
}
},
toJSON() {
switch (this.value._tag) {
case "Millis": return {
_id: "Duration",
_tag: "Millis",
millis: this.value.millis
};
case "Nanos": return {
_id: "Duration",
_tag: "Nanos",
nanos: String(this.value.nanos)
};
case "Infinity": return {
_id: "Duration",
_tag: "Infinity"
};
case "NegativeInfinity": return {
_id: "Duration",
_tag: "NegativeInfinity"
};
}
},
[NodeInspectSymbol]() {
return this.toJSON();
},
pipe() {
return pipeArguments(this, arguments);
}
};
const make$7 = (input) => {
const duration = Object.create(DurationProto);
if (typeof input === "number") {
if (isNaN(input) || input === 0 || Object.is(input, -0)) duration.value = zeroDurationValue;
else if (!Number.isFinite(input)) duration.value = input > 0 ? infinityDurationValue : negativeInfinityDurationValue;
else if (!Number.isInteger(input)) duration.value = {
_tag: "Nanos",
nanos: roundMillisToNanos(input)
};
else duration.value = {
_tag: "Millis",
millis: input
};
} else if (input === bigint0) duration.value = zeroDurationValue;
else duration.value = {
_tag: "Nanos",
nanos: input
};
return duration;
};
/**
* Checks whether a value is a Duration.
*
* **Example** (Checking for durations)
*
* ```ts import.meta.vitest
* import { Duration } from "effect"
*
* Duration.isDuration(Duration.seconds(1)) // => true
* Duration.isDuration(1000) // => false
* ```
*
* @stability stable
* @category guards
* @since 2.0.0
*/
const isDuration = (u) => hasProperty(u, TypeId$11);
/**
* A Duration representing zero time.
*
* **Example** (Referencing the zero duration)
*
* ```ts import.meta.vitest
* import { Duration } from "effect"
*
* Duration.toMillis(Duration.zero) // => 0
* ```
*
* @stability stable
* @category constructors
* @since 2.0.0
*/
const zero = /*#__PURE__*/ make$7(0);
/**
* A Duration representing infinite time.
*
* **Example** (Referencing infinite duration)
*
* ```ts import.meta.vitest
* import { Duration } from "effect"
*
* Duration.toMillis(Duration.infinity) // => Infinity
* ```
*
* @stability stable
* @category constructors
* @since 2.0.0
*/
const infinity = /*#__PURE__*/ make$7(Infinity);
/**
* A Duration representing negative infinite time.
*
* **Example** (Referencing negative infinite duration)
*
* ```ts import.meta.vitest
* import { Duration } from "effect"
*
* Duration.toMillis(Duration.negativeInfinity) // => -Infinity
* ```
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const negativeInfinity = /*#__PURE__*/ make$7(-Infinity);
/**
* Creates a Duration from nanoseconds.
*
* **Example** (Creating durations from nanoseconds)
*
* ```ts import.meta.vitest
* import { Duration } from "effect"
*
* Duration.nanos(500_000_000n) // => Duration.nanos(500_000_000n)
* ```
*
* @stability stable
* @category constructors
* @since 2.0.0
*/
const nanos = (nanos) => make$7(nanos);
/**
* Creates a Duration from milliseconds.
*
* **Example** (Creating durations from milliseconds)
*
* ```ts import.meta.vitest
* import { Duration } from "effect"
*
* Duration.toMillis(Duration.millis(1000)) // => 1000
* ```
*
* @stability stable
* @category constructors
* @since 2.0.0
*/
const millis = (millis) => make$7(millis);
/**
* Creates a Duration from seconds.
*
* **Example** (Creating durations from seconds)
*
* ```ts import.meta.vitest
* import { Duration } from "effect"
*
* Duration.toMillis(Duration.seconds(30)) // => 30_000
* ```
*
* @stability stable
* @category constructors
* @since 2.0.0
*/
const seconds = (seconds) => make$7(seconds * 1e3);
/**
* Creates a Duration from minutes.
*
* **Example** (Creating durations from minutes)
*
* ```ts import.meta.vitest
* import { Duration } from "effect"
*
* Duration.toMillis(Duration.minutes(5)) // => 300_000
* ```
*
* @stability stable
* @category constructors
* @since 2.0.0
*/
const minutes = (minutes) => make$7(minutes * 6e4);
/**
* Creates a Duration from hours.
*
* **Example** (Creating durations from hours)
*
* ```ts import.meta.vitest
* import { Duration } from "effect"
*
* Duration.toMillis(Duration.hours(2)) // => 7_200_000
* ```
*
* @stability stable
* @category constructors
* @since 2.0.0
*/
const hours = (hours) => make$7(hours * 36e5);
/**
* Creates a Duration from days.
*
* **Example** (Creating durations from days)
*
* ```ts import.meta.vitest
* import { Duration } from "effect"
*
* Duration.toMillis(Duration.days(1)) // => 86_400_000
* ```
*
* @stability stable
* @category constructors
* @since 2.0.0
*/
const days = (days) => make$7(days * 864e5);
/**
* Creates a Duration from weeks.
*
* **Example** (Creating durations from weeks)
*
* ```ts import.meta.vitest
* import { Duration } from "effect"
*
* Duration.toMillis(Duration.weeks(1)) // => 604_800_000
* ```
*
* @stability stable
* @category constructors
* @since 2.0.0
*/
const weeks = (weeks) => make$7(weeks * 6048e5);
/**
* Gets the duration in nanoseconds as a bigint.
*
* **When to use**
*
* Use when the duration is known to be finite and you need the nanosecond value
* as a `bigint`.
*
* **Details**
*
* Millisecond-backed fractional durations are rounded to the nearest
* nanosecond, with ties away from zero.
*
* **Gotchas**
*
* If the duration is infinite, it throws an error.
*
* **Example** (Reading nanoseconds unsafely)
*
* ```ts import.meta.vitest
* import { Duration } from "effect"
*
* Duration.toNanosUnsafe(Duration.seconds(2)) // => 2_000_000_000n
*
* // Duration.toNanosUnsafe(Duration.infinity)
* // throws Error: "Cannot convert infinite duration to nanos"
* ```
*
* @stability stable
* @category getters
* @since 4.0.0
*/
const toNanosUnsafe = (input) => {
const self = fromInputUnsafe(input);
switch (self.value._tag) {
case "Infinity":
case "NegativeInfinity": throw new Error("Cannot convert infinite duration to nanos");
case "Nanos": return self.value.nanos;
case "Millis": return roundMillisToNanos(self.value.millis);
}
};
/**
* Pattern matches on two `Duration`s, providing handlers that receive both values.
*
* **Example** (Pattern matching on duration pairs)
*
* ```ts import.meta.vitest
* import { Duration } from "effect"
*
* Duration.matchPair(Duration.seconds(3), Duration.seconds(2), {
* onMillis: (a, b) => a + b,
* onNanos: (a, b) => Number(a + b),
* onInfinity: () => Infinity
* }) // => 5000
* ```
*
* @stability stable
* @category pattern matching
* @since 4.0.0
*/
const matchPair = /*#__PURE__*/ dual(3, (self, that, options) => {
if (self.value._tag === "Infinity" || self.value._tag === "NegativeInfinity" || that.value._tag === "Infinity" || that.value._tag === "NegativeInfinity") return options.onInfinity(self, that);
if (self.value._tag === "Millis") return that.value._tag === "Millis" ? options.onMillis(self.value.millis, that.value.millis) : options.onNanos(toNanosUnsafe(self), that.value.nanos);
else return options.onNanos(self.value.nanos, toNanosUnsafe(that));
});
/**
* Provides an `Equivalence` instance for comparing `Duration` values.
*
* **Example** (Comparing durations for equivalence)
*
* ```ts import.meta.vitest
* import { Duration } from "effect"
*
* Duration.Equivalence(Duration.seconds(5), Duration.millis(5000)) // => true
* ```
*
* @stability stable
* @category instances
* @since 2.0.0
*/
const Equivalence$2 = (self, that) => matchPair(self, that, {
onMillis: (self, that) => self === that,
onNanos: (self, that) => self === that,
onInfinity: (self, that) => self.value._tag === that.value._tag
});
/**
* Checks whether two Durations are equal.
*
* **Example** (Checking duration equality)
*
* ```ts import.meta.vitest
* import { Duration } from "effect"
*
* Duration.equals(Duration.seconds(5), Duration.millis(5000)) // => true
* ```
*
* @stability stable
* @category predicates
* @since 2.0.0
*/
const equals = /*#__PURE__*/ dual(2, (self, that) => Equivalence$2(self, that));
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Scheduler.js
/**
* Controls how runnable Effect fiber tasks are dispatched.
*
* A scheduler decides how tasks are queued, when queued tasks run, and when a
* fiber should pause so other work can continue. This module includes the
* scheduler service reference, the default `MixedScheduler`, dispatcher types
* for queued tasks, and references for tuning or disabling automatic scheduler
* yields.
*
* @stability stable
* @since 2.0.0
*/
/**
* Context reference for the scheduler used by the Effect runtime.
*
* **When to use**
*
* Use when you need to replace scheduling behavior globally in tests or runtime
* setup, such as forcing deterministic task dispatch.
*
* **Details**
*
* The default value creates a `MixedScheduler`. Provide this service to
* customize execution mode, task dispatching, or yield behavior.
*
* @stability stable
* @category services
* @since 2.0.0
*/
const Scheduler = /*#__PURE__*/ Reference("effect/Scheduler", {
fiberCached: true,
defaultValue: () => new MixedScheduler()
});
const setMicrotask = (f) => {
let cancelled = false;
Promise.resolve().then(() => {
if (!cancelled) f();
});
return () => {
cancelled = true;
};
};
const setTimer = "setImmediate" in globalThis ? (f) => {
const timer = globalThis.setImmediate(f);
return () => globalThis.clearImmediate(timer);
} : (f) => {
const timer = setTimeout(f, 0);
return () => clearTimeout(timer);
};
const setImmediate = (f) => {
try {
return setTimer(f);
} catch {
return setMicrotask(f);
}
};
var PriorityBuckets = class {
buckets = [];
scheduleTask(task, priority) {
const buckets = this.buckets;
const len = buckets.length;
let bucket;
let index = 0;
for (; index < len; index++) {
if (buckets[index][0] > priority) break;
bucket = buckets[index];
}
if (bucket && bucket[0] === priority) bucket[1].push(task);
else if (index === len) buckets.push([priority, [task]]);
else buckets.splice(index, 0, [priority, [task]]);
}
drain() {
const buckets = this.buckets;
this.buckets = [];
return buckets;
}
};
/**
* Provides a scheduler implementation that batches queued tasks and dispatches them by
* priority.
*
* **When to use**
*
* Use when you need the default runtime scheduler directly, including a
* scheduler that batches queued work by priority and preserves FIFO order within
* each priority.
*
* **Details**
*
* `MixedScheduler` supports synchronous and asynchronous execution modes, uses
* operation counts to decide when fibers should yield, and is the default
* scheduler implementation.
*
* **Gotchas**
*
* On Cloudflare Workers, request-owned scheduler timers can be discarded,
* leaving shared fibers suspended. Use `new MixedScheduler("sync")` for the
* whole application; see `HttpRouter.toWebHandler` for a recipe.
* Sync mode does not yield to the event loop: CPU-heavy work delays other
* requests, and I/O-polling loops can exhaust the CPU limit. It does not fix
* request-owned timers (such as `Effect.sleep`) or request-bound async contexts.
*
* @stability stable
* @category models
* @since 2.0.0
*/
var MixedScheduler = class {
executionMode;
setImmediate;
constructor(executionMode = "async", setImmediateFn) {
this.executionMode = executionMode;
this.setImmediate = setImmediateFn ?? (executionMode === "sync" ? setMicrotask : setImmediate);
}
/**
* Returns whether the fiber has reached its operation budget and should yield.
*
* **When to use**
*
* Use to decide whether a fiber should yield after consuming its current
* operation budget.
*
* @since 2.0.0
*/
shouldYield(fiber) {
return fiber.currentOpCount >= fiber.cache.maxOpsBeforeYield;
}
/**
* Creates a dispatcher that schedules work through this scheduler.
*
* **When to use**
*
* Use when you need a standalone dispatcher from a scheduler instance, for
* example in tests that enqueue tasks and then flush them deterministically.
*
* @since 4.0.0
*/
makeDispatcher() {
return new MixedSchedulerDispatcher(this.setImmediate);
}
};
var MixedSchedulerDispatcher = class {
tasks = /*#__PURE__*/ new PriorityBuckets();
running = void 0;
setImmediate;
constructor(setImmediateFn = setImmediate) {
this.setImmediate = setImmediateFn;
}
/**
* @since 2.0.0
*/
scheduleTask(task, priority) {
this.tasks.scheduleTask(task, priority);
if (this.running === void 0) this.running = this.setImmediate(this.afterScheduled);
}
/**
* @since 2.0.0
*/
afterScheduled = () => {
this.running = void 0;
this.runTasks();
};
/**
* @since 2.0.0
*/
runTasks() {
const buckets = this.tasks.drain();
for (let i = 0; i < buckets.length; i++) {
const toRun = buckets[i][1];
for (let j = 0; j < toRun.length; j++) toRun[j]();
}
}
/**
* @since 2.0.0
*/
flush() {
while (this.tasks.buckets.length > 0) {
if (this.running !== void 0) {
this.running();
this.running = void 0;
}
this.runTasks();
}
}
};
/**
* Context reference that controls the maximum number of operations a fiber
* can perform before yielding control back to the scheduler.
*
* **When to use**
*
* Use to tune scheduler fairness for CPU-bound fibers by changing the scheduler
* operation budget that triggers a yield.
*
* **Details**
*
* The default value is `2048` operations, which balances performance and
* fairness by helping prevent long-running fibers from monopolizing the
* execution thread.
*
* @see {@link PreventSchedulerYield} for bypassing scheduler yield checks entirely rather than tuning the operation budget
*
* @stability stable
* @category services
* @since 4.0.0
*/
const MaxOpsBeforeYield = /*#__PURE__*/ Reference("effect/Scheduler/MaxOpsBeforeYield", {
fiberCached: true,
defaultValue: () => 2048
});
/**
* Context reference that controls whether the runtime should bypass scheduler
* yield checks. When set to `true`, the fiber run loop won't call
* `Scheduler.shouldYield`.
*
* **When to use**
*
* Use to bypass scheduler yield checks for controlled runtime workloads where
* cooperative yielding should be disabled.
*
* **Gotchas**
*
* Setting this reference to `true` can let long-running fibers monopolize the
* JavaScript thread.
*
* @see {@link MaxOpsBeforeYield} for tuning yield frequency without disabling yield checks
* @see {@link Scheduler} for providing custom scheduler yield behavior
*
* @stability stable
* @category services
* @since 4.0.0
*/
const PreventSchedulerYield = /*#__PURE__*/ Reference("effect/Scheduler/PreventSchedulerYield", {
fiberCached: true,
defaultValue: () => false
});
/**
* Creates a tagged error class with a `_tag` discriminator.
*
* **When to use**
*
* Use when you need domain errors with discriminated-union handling.
*
* **Details**
*
* Like {@link Error}, but instances also carry a `readonly _tag` property,
* enabling `Effect.catchTag` and `Effect.catchTags` for tag-based recovery.
* The `_tag` is excluded from the constructor argument. Yielding an instance
* inside `Effect.gen` fails the effect with this error.
*
* **Example** (Recovering by tag)
*
* ```ts import.meta.vitest
* import { Data, Effect } from "effect"
*
* class NotFound extends Data.TaggedError("NotFound")<{
* readonly resource: string
* }> {}
*
* class Forbidden extends Data.TaggedError("Forbidden")<{
* readonly reason: string
* }> {}
*
* const program = Effect.gen(function*() {
* return yield* new NotFound({ resource: "/users/42" })
* })
*
* const recovered = program.pipe(
* Effect.catchTag("NotFound", (e) =>
* Effect.succeed(`missing: ${e.resource}`))
* )
*
* await Effect.runPromise(recovered) // => "missing: /users/42"
* ```
*
* @see {@link Error} — without a `_tag`
* @see {@link TaggedClass} — tagged class that is not an error
*
* @stability stable
* @category constructors
* @since 2.0.0
*/
const TaggedError = TaggedError$1;
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Tracer.js
/**
* Defines the string key for the parent-span context service.
*
* **When to use**
*
* Use when you need the raw context key for parent span lookup in lower-level
* tracing code.
*
* **Example** (Reading the parent span key)
*
* ```ts import.meta.vitest
* import { Tracer } from "effect"
*
* // The key used to identify parent spans in the context
* Tracer.ParentSpanKey // => "effect/Tracer/ParentSpan"
* ```
*
* @stability stable
* @category constants
* @since 4.0.0
*/
const ParentSpanKey = "effect/Tracer/ParentSpan";
/**
* Defines the string key for the active tracer context reference.
*
* **When to use**
*
* Use when you need the raw context key for active tracer lookup in lower-level
* tracing code.
*
* @stability stable
* @category constants
* @since 4.0.0
*/
const TracerKey = "effect/Tracer";
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/metric.js
/** @internal */
const FiberRuntimeMetricsKey = "effect/Metric/FiberRuntimeMetrics";
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/references.js
/** @internal */
const CurrentStackFrame = /*#__PURE__*/ Reference("effect/References/CurrentStackFrame", {
fiberCached: true,
defaultValue: constUndefined
});
/** @internal */
const TracerEnabled = /*#__PURE__*/ Reference("effect/References/TracerEnabled", {
fiberCached: true,
defaultValue: constTrue
});
/** @internal */
const CurrentLogLevel = /*#__PURE__*/ Reference("effect/References/CurrentLogLevel", {
fiberCached: true,
defaultValue: () => "Info"
});
/** @internal */
const MinimumLogLevel = /*#__PURE__*/ Reference("effect/References/MinimumLogLevel", {
fiberCached: true,
defaultValue: () => "Info"
});
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/effect.js
/** @internal */
var Interrupt = class extends ReasonBase {
constructor(fiberId, annotations = constEmptyAnnotations) {
super("Interrupt", annotations, "Interrupted");
this.fiberId = fiberId;
}
toString() {
return `Interrupt(${this.fiberId})`;
}
toJSON() {
return {
_tag: "Interrupt",
fiberId: this.fiberId
};
}
[symbol](that) {
return isInterruptReason(that) && this.fiberId === that.fiberId && this.annotations === that.annotations;
}
[symbol$1]() {
return string$1(`${this._tag}:${this.fiberId}`);
}
};
/** @internal */
const causeInterrupt = (fiberId) => new CauseImpl([new Interrupt(fiberId)]);
/** @internal */
const hasInterrupts = (self) => self.reasons.some(isInterruptReason);
/** @internal */
const causeMap = /*#__PURE__*/ dual(2, (self, f) => {
let hasFail = false;
const failures = self.reasons.map((failure) => {
if (isFailReason$1(failure)) {
hasFail = true;
return new Fail(f(failure.error), failure.annotations);
}
return failure;
});
return hasFail ? causeFromReasons(failures) : self;
});
/** @internal */
const FiberTypeId = "~effect/Fiber";
const fiberVariance = {
_A: identity,
_E: identity
};
const fiberIdStore = { id: 0 };
const AsyncResource = /*#__PURE__*/ (() => {
try {
return globalThis.process?.getBuiltinModule?.("node:async_hooks")?.AsyncResource;
} catch {
return;
}
})();
const captureAsyncContext = () => AsyncResource === void 0 ? void 0 : new AsyncResource("effect/Fiber");
/** @internal */
const getCurrentFiber = () => globalThis[currentFiberTypeId];
/** @internal */
var FiberImpl = class {
constructor(context, interruptible = true) {
this.setContext(context);
this.id = ++fiberIdStore.id;
this.currentOpCount = 0;
this.interruptible = interruptible;
this._stack = [];
this._observers = void 0;
this._exit = void 0;
this._children = void 0;
this._interruptedCause = void 0;
this._yielded = void 0;
this._running = false;
this._deferredInterrupt = false;
this._parent = void 0;
this._asyncContext = void 0;
this.cache.runtimeMetrics?.recordFiberStart(this.context);
}
get [FiberTypeId]() {
return fiberVariance;
}
get currentDispatcher() {
return this._dispatcher ??= this.cache.scheduler.makeDispatcher();
}
getRef(ref) {
return get(this.context, ref);
}
addObserver(cb) {
if (this._exit) {
cb(this._exit);
return constVoid;
}
if (this._observers === void 0) this._observers = [cb];
else this._observers.push(cb);
return () => this.removeObserver(cb);
}
removeObserver(cb) {
if (this._exit || this._observers === void 0) return;
const index = this._observers.indexOf(cb);
if (index >= 0) this._observers.splice(index, 1);
}
interruptUnsafe(fiberId, annotations) {
if (this._exit) return;
let cause = causeInterrupt(fiberId);
if (this.cache.stackFrame) cause = causeAnnotate(cause, make$8(StackTraceKey, this.cache.stackFrame));
if (annotations) cause = causeAnnotate(cause, annotations);
this._interruptedCause = this._interruptedCause ? causeAddInterrupts(this._interruptedCause, cause) : cause;
if (this.interruptible) {
if (this._running) this._deferredInterrupt = true;
else this.evaluate(failCause$1(this._interruptedCause));
}
}
pollUnsafe() {
return this._exit;
}
evaluate(effect) {
if (this._exit) return;
else if (this._asyncContext !== void 0) {
const asyncContext = this._asyncContext;
this._asyncContext = void 0;
return asyncContext.runInAsyncScope(this.evaluate, this, effect);
} else if (this._yielded !== void 0) {
const yielded = this._yielded;
this._yielded = void 0;
yielded();
}
const exit = this.runLoop(effect);
if (exit === Yield) {
this._asyncContext = captureAsyncContext();
return;
}
const interruptChildren = fiberMiddleware.interruptChildren && fiberMiddleware.interruptChildren(this);
if (interruptChildren !== void 0) return this.evaluate(flatMap$1(interruptChildren, () => exit));
this._exit = exit;
this.cache.runtimeMetrics?.recordFiberEnd(this.context, this._exit);
if (this._parent) {
this._parent._children?.delete(this);
this._parent = void 0;
}
if (this._observers !== void 0) {
const observers = this._observers;
this._observers = void 0;
for (let i = 0; i < observers.length; i++) observers[i](exit);
}
this._stack.length = 0;
this._children = void 0;
this.context = empty();
}
runLoop(effect) {
const prevFiber = globalThis[currentFiberTypeId];
globalThis[currentFiberTypeId] = this;
const prevRunning = this._running;
this._running = true;
let yielding = false;
let current = effect;
this.currentOpCount = 0;
try {
while (true) try {
if (this._deferredInterrupt) {
this._deferredInterrupt = false;
current = failCause$1(this._interruptedCause);
}
this.currentOpCount++;
const cache = this.cache;
if (!yielding && !cache.preventYield && cache.scheduler.shouldYield(this)) {
yielding = true;
const prev = current;
current = flatMap$1(yieldNow, () => prev);
}
current = cache.tracerContext ? cache.tracerContext(current, this) : current[evaluate](this);
if (current === Yield) {
const yielded = this._yielded;
if ("~effect/Exit" in yielded) {
this._deferredInterrupt = false;
this._yielded = void 0;
return yielded;
} else if (this._deferredInterrupt) {
this._yielded = void 0;
yielded();
continue;
}
return Yield;
}
} catch (error) {
if (!hasProperty(current, "~effect/Effect/evaluate")) return exitDie(`Fiber.runLoop: Not a valid effect: ${String(current)}`);
current = exitDie(error);
}
} finally {
this._running = prevRunning;
globalThis[currentFiberTypeId] = prevFiber;
}
}
getCont(symbol) {
if (this._deferredInterrupt) {
this._deferredInterrupt = false;
return deferredInterruptCont;
}
while (true) {
const op = this._stack.pop();
if (!op) return void 0;
const all = op[contAll];
if (all !== void 0) {
const cont = all.call(op, this);
if (cont) {
cont[symbol] = cont;
return cont;
}
}
if (op[symbol]) return op;
}
}
succeedWith(value) {
if ((++this.currentOpCount & maxInlineSteps - 1) === 0) return exitSucceed(value);
const cont = this.getCont(contA);
return cont ? cont[contA](value, this) : this.yieldWith(exitSucceed(value));
}
yieldWith(value) {
this._yielded = value;
return Yield;
}
children() {
return this._children ??= /* @__PURE__ */ new Set();
}
pipe() {
return pipeArguments(this, arguments);
}
setContext(context) {
const previous = this.context;
this.context = context;
if (previous !== void 0 && hasSameCache(previous, context)) return;
const root = context.cacheRoot;
const cache = root._fiberCache ??= makeFiberContextCache(context);
if (this.cache?.scheduler !== cache.scheduler) this._dispatcher = void 0;
this.cache = cache;
}
get currentSpanLocal() {
const span = this.cache.span;
return span?._tag === "Span" ? span : void 0;
}
};
const makeFiberContextCache = (context) => {
const currentTracer = getOrUndefinedUnsafe(context, TracerKey);
return {
scheduler: get(context, Scheduler),
tracer: currentTracer,
tracerContext: currentTracer ? currentTracer["context"] : void 0,
tracerEnabled: get(context, TracerEnabled),
span: getOrUndefinedUnsafe(context, ParentSpanKey),
logLevel: get(context, CurrentLogLevel),
minimumLogLevel: get(context, MinimumLogLevel),
stackFrame: get(context, CurrentStackFrame),
runtimeMetrics: getOrUndefinedUnsafe(context, FiberRuntimeMetricsKey),
maxOpsBeforeYield: get(context, MaxOpsBeforeYield),
preventYield: get(context, PreventSchedulerYield)
};
};
const deferredInterruptCont = {
[contA](_value, fiber) {
return failCause$1(fiber._interruptedCause);
},
[contE](_cause, fiber) {
return failCause$1(fiber._interruptedCause);
}
};
const maxInlineSteps = 32;
const fiberMiddleware = { interruptChildren: void 0 };
const fiberStackAnnotations = (fiber) => {
if (!fiber.cache.stackFrame) return void 0;
const annotations = /* @__PURE__ */ new Map();
annotations.set(InterruptorStackTrace.key, fiber.cache.stackFrame);
return makeUnsafe$2(annotations);
};
/** @internal */
const fiberAwaitAll = (self) => callback((resume) => {
const iter = self[Symbol.iterator]();
const exits = [];
let cancel = void 0;
function loop() {
let result = iter.next();
while (!result.done) {
if (result.value._exit) {
exits.push(result.value._exit);
result = iter.next();
continue;
}
cancel = result.value.addObserver((exit) => {
exits.push(exit);
loop();
});
return;
}
resume(succeed$3(exits));
}
loop();
return sync(() => cancel?.());
});
/** @internal */
const fiberInterruptAll = (fibers) => withFiber((parent) => {
const annotations = fiberStackAnnotations(parent);
let fiberArr = empty$1();
for (const fiber of fibers) {
fiber.interruptUnsafe(parent.id, annotations);
fiberArr.push(fiber);
}
return asVoid(fiberAwaitAll(fiberArr));
});
/** @internal */
const succeed$3 = exitSucceed;
/** @internal */
const failCause$1 = exitFailCause;
/** @internal */
const fail$3 = exitFail;
/** @internal */
const sync = /*#__PURE__*/ makePrimitive({
op: "Sync",
[evaluate](fiber) {
const value = this[args]();
const cont = fiber.getCont(contA);
return cont ? cont[contA](value, fiber) : fiber.yieldWith(exitSucceed(value));
}
});
/** @internal */
const suspend$1 = /*#__PURE__*/ makePrimitive({
op: "Suspend",
[evaluate](_fiber) {
return this[args]();
}
});
/** @internal */
const yieldNow = /*#__PURE__*/ (/* @__PURE__ */ makePrimitive({
op: "Yield",
[evaluate](fiber) {
let resumed = false;
fiber.currentDispatcher.scheduleTask(() => {
if (resumed) return;
fiber.evaluate(exitVoid);
}, this["~effect/Effect/args"] ?? 0);
return fiber.yieldWith(() => {
resumed = true;
});
}
}))(0);
/** @internal */
const failCauseSync$1 = (evaluate) => suspend$1(() => failCause$1(evaluate()));
/** @internal */
const die$2 = (defect) => exitDie(defect);
/** @internal */
const void_$1 = /*#__PURE__*/ succeed$3(void 0);
const callbackOptions = /*#__PURE__*/ function() {
const Proto = /*#__PURE__*/ makePrimitiveProto({
op: "Async",
[evaluate](fiber) {
let resumed = false;
let yielded = false;
const controller = this.withSignal ? new AbortController() : void 0;
const onCancel = this.register.call(fiber.cache.scheduler, (effect) => {
if (resumed) return;
resumed = true;
if (yielded) fiber.evaluate(effect);
else yielded = effect;
}, controller?.signal);
if (yielded !== false) return yielded;
yielded = true;
fiber._yielded = () => {
resumed = true;
};
if (controller === void 0 && onCancel === void 0) return Yield;
fiber._stack.push(asyncFinalizer(() => {
resumed = true;
controller?.abort();
return onCancel ?? exitVoid;
}));
return Yield;
}
});
const AsyncImpl = function(register, withSignal) {
this.register = register;
this.withSignal = withSignal;
};
AsyncImpl.prototype = Proto;
return function(register, withSignal) {
return new AsyncImpl(register, withSignal);
};
}();
const asyncFinalizer = /*#__PURE__*/ makePrimitive({
op: "AsyncFinalizer",
[contAll](fiber) {
if (fiber.interruptible) {
fiber.interruptible = false;
fiber._stack.push(setInterruptibleTrue);
}
},
[contE](cause, _fiber) {
return hasInterrupts(cause) ? flatMap$1(combineFinalizerCause(exitFailCause(cause), this[args]()), () => failCause$1(cause)) : failCause$1(cause);
}
});
/** @internal */
const callback = (register) => callbackOptions(register, register.length >= 2);
const defineFunctionLength = (length, fn) => Object.defineProperty(fn, "length", {
value: length,
configurable: true
});
/** @internal */
const fnUntracedEager$1 = (body, ...pipeables) => defineFunctionLength(body.length, pipeables.length === 0 ? function() {
return fromIteratorEagerUnsafe(() => body.apply(this, arguments));
} : function() {
let effect = fromIteratorEagerUnsafe(() => body.apply(this, arguments));
for (const pipeable of pipeables) effect = pipeable(effect, ...arguments);
return effect;
});
const fromIteratorEagerUnsafe = (evaluate) => {
try {
const iterator = evaluate();
let value = void 0;
while (true) {
const state = iterator.next(value);
if (state.done) return succeed$3(state.value);
const primitive = state.value;
if (primitive && primitive._tag === "Success") {
value = primitive.value;
continue;
} else if (primitive && primitive._tag === "Failure") return state.value;
else {
let isFirstExecution = true;
return suspend$1(() => {
if (isFirstExecution) {
isFirstExecution = false;
return flatMap$1(state.value, (value) => fromIteratorUnsafe(iterator, value));
} else return suspend$1(() => fromIteratorUnsafe(evaluate()));
});
}
}
} catch (error) {
return die$2(error);
}
};
const fromIteratorUnsafe = /*#__PURE__*/ function() {
const Proto = /*#__PURE__*/ makePrimitiveProto({
op: "Iterator",
[contA](value, fiber) {
const iter = this.iterator;
while (true) {
const state = iter.next(value);
if (state.done) return succeed$3(state.value);
if (!effectIsExit(state.value)) {
fiber._stack.push(this);
return state.value;
} else if (state.value._tag === "Failure") return state.value;
value = state.value.value;
}
},
[evaluate](fiber) {
return this[contA](this.initial, fiber);
}
});
const IteratorImpl = function(iterator, initial) {
this.iterator = iterator;
this.initial = initial;
};
IteratorImpl.prototype = Proto;
return function(iterator, initial) {
return new IteratorImpl(iterator, initial);
};
}();
const evaluateCont = function(fiber) {
fiber._stack.push(this);
return this[args];
};
const OnSuccessProto = /*#__PURE__*/ makePrimitiveProto({
op: "OnSuccess",
[evaluate]: evaluateCont
});
const ContImpl = function(self, cont, payload) {
this[args] = self;
this[contA] = cont;
this.payload = payload;
};
ContImpl.prototype = OnSuccessProto;
const returnPayload = function() {
return this.payload;
};
const continuationMarksStack = /*#__PURE__*/ (() => {
const limit = /*#__PURE__*/ getStackTraceLimit();
if (limit === 0) return false;
const marker = "~effect/Effect/stackProbe";
const probe = { [marker]: function stackProbe() {
return /* @__PURE__ */ new Error();
} };
setStackTraceLimit(1);
const error = /*#__PURE__*/ probe[marker]();
setStackTraceLimit(limit);
return error.stack?.includes("[as " + marker + "]") === true;
})();
const mapCont = function(value, fiber) {
const f = this.payload;
return fiber.succeedWith(continuationMarksStack ? f(value) : internalCall(() => f(value)));
};
const andThenCont = function(value) {
const f = this.payload;
return f(value);
};
/** @internal */
const asVoid = (self) => new ContImpl(self, returnPayload, exitVoid);
/** @internal */
const flatMap$1 = /*#__PURE__*/ dual(2, (self, f) => new ContImpl(self, andThenCont, f));
/** @internal */
const effectIsExit = (effect) => effect[ExitTypeId] !== void 0;
/** @internal */
const flatMapEager$1 = /*#__PURE__*/ dual(2, (self, f) => {
if (effectIsExit(self)) return self._tag === "Success" ? f(self.value) : self;
return flatMap$1(self, f);
});
/** @internal */
const map$1 = /*#__PURE__*/ dual(2, (self, f) => new ContImpl(self, mapCont, f));
/** @internal */
const mapEager$1 = /*#__PURE__*/ dual(2, (self, f) => effectIsExit(self) ? exitMap(self, f) : map$1(self, f));
/** @internal */
const exitIsSuccess = (self) => self._tag === "Success";
/** @internal */
const exitVoid = /*#__PURE__*/ exitSucceed(void 0);
/** @internal */
const exitMap = /*#__PURE__*/ dual(2, (self, f) => self._tag === "Success" ? exitSucceed(f(self.value)) : self);
/** @internal */
const catchCause$1 = /*#__PURE__*/ dual(2, (self, f) => new OnFailureImpl(self, f.length !== 1 ? (cause) => f(cause) : f));
const OnFailureProto = /*#__PURE__*/ makePrimitiveProto({
op: "OnFailure",
[evaluate]: evaluateCont
});
const OnFailureImpl = function(self, f) {
this[args] = self;
this[contE] = f;
};
OnFailureImpl.prototype = OnFailureProto;
const OnSuccessAndFailureProto = /*#__PURE__*/ makePrimitiveProto({
op: "OnSuccessAndFailure",
[evaluate]: evaluateCont
});
const OnSuccessAndFailureImpl = function(self, onSuccess, onFailure) {
this[args] = self;
this[contA] = onSuccess;
this[contE] = onFailure;
};
OnSuccessAndFailureImpl.prototype = OnSuccessAndFailureProto;
/** @internal */
const exit$1 = (self) => effectIsExit(self) ? exitSucceed(self) : exitPrimitive(self);
const exitPrimitive = /*#__PURE__*/ makePrimitive({
op: "Exit",
[evaluate](fiber) {
fiber._stack.push(this);
return this[args];
},
[contA](value, fiber, exit) {
return fiber.succeedWith(exit ?? exitSucceed(value));
},
[contE](cause, fiber, exit) {
return fiber.succeedWith(exit ?? exitFailCause(cause));
}
});
const combineFinalizerCause = (exit_, finalizer) => exitIsSuccess(exit_) ? finalizer : catchCause$1(finalizer, (cause) => failCause$1(causeCombine(exit_.cause, cause)));
/** @internal */
const uninterruptible = (self) => withFiber((fiber) => {
if (!fiber.interruptible) return self;
fiber.interruptible = false;
fiber._stack.push(setInterruptibleTrue);
return self;
});
const setInterruptibleTrue = /*#__PURE__*/ (/* @__PURE__ */ makePrimitive({
op: "SetInterruptible",
[contAll](fiber) {
fiber.interruptible = this[args];
if (fiber._interruptedCause && fiber.interruptible) return () => failCause$1(fiber._interruptedCause);
}
}))(true);
/** @internal */
const resolveConcurrency = (concurrency) => concurrency === "unbounded" ? Number.POSITIVE_INFINITY : Math.max(1, concurrency ?? 1);
/** @internal */
const iterateEager = () => (options) => {
const onItem = options.onItem;
const step = options.step;
const resumeSequential = (state, items, index, end, effect) => flatMap$1(exit$1(effect), (itemExit) => step(state, items[index], itemExit, index) ?? runSequential(state, items, index + 1, end) ?? void_$1);
const runSequential = (state, items, index = 0, end = items.length) => {
for (; index < end; index++) {
const item = items[index];
const effect = onItem(state, item, index);
if (!effectIsExit(effect)) return resumeSequential(state, items, index, end, effect);
const terminal = step(state, item, effect, index);
if (terminal) return terminal._tag === "Failure" ? terminal : void 0;
}
};
return runSequential;
};
const iterateConcurrentImpl = (options) => {
const onItem = options.onItem;
const step = options.step;
return (state, items, opts) => {
let index = 0;
const end = opts.end ?? items.length;
const concurrency = opts.concurrency;
let done = false;
let parentFiber;
let fibers;
let resume;
let terminal;
let effect;
const failDefect = (error) => {
const defect = exitDie(error);
terminal = defect;
done = true;
return fibers && fibers.size > 0 ? flatMap$1(uninterruptible(fiberInterruptAll(Array.from(fibers))), () => terminal ?? defect) : defect;
};
const go = () => {
let paused = false;
for (; !terminal && index < end; index++) {
const item = items[index];
const eff = effect ?? onItem(state, item, index);
if (effectIsExit(eff)) {
terminal = step(state, item, eff, index);
if (terminal) break;
} else if (!parentFiber) return callback((cb) => {
parentFiber = getCurrentFiber();
fibers = /* @__PURE__ */ new Set();
effect = eff;
resume = cb;
let result;
try {
result = go();
} catch (error) {
return cb(failDefect(error));
}
if (result) return cb(result);
return suspend$1(() => {
terminal ??= exitVoid;
return flatMap$1(fibers ? fiberInterruptAll(fibers) : void_$1, () => terminal?._tag === "Failure" ? terminal : void_$1);
});
});
else {
effect = void 0;
const fiber = forkUnsafe(parentFiber, eff, true, true, "inherit");
if (fiber._exit) {
terminal = step(state, item, fiber._exit, index);
if (terminal) break;
continue;
}
fibers.add(fiber);
const currentIndex = index;
fiber.addObserver((exit) => {
fibers.delete(fiber);
try {
if (terminal) {
if (exit._tag === "Failure") {
const reasons = exit.cause.reasons.filter((reason) => reason._tag !== "Interrupt");
if (reasons.length > 0) {
const cause = causeFromReasons(reasons);
terminal = exitFailCause(terminal._tag === "Failure" ? causeCombine(terminal.cause, cause) : cause);
}
}
} else {
const result = step(state, item, exit, currentIndex);
if (result) {
terminal = result;
go();
}
}
if (paused) {
const eff = go();
if (eff) resume(eff);
} else if (done && fibers.size === 0) resume(terminal ?? void_$1);
} catch (error) {
resume(failDefect(error));
}
});
if (fibers.size < concurrency) continue;
paused = true;
index++;
return;
}
}
done = true;
if (terminal) {
if (fibers && fibers.size > 0) {
const annotations = fiberStackAnnotations(parentFiber);
fibers.forEach((f) => f.interruptUnsafe(parentFiber.id, annotations));
return;
}
if (resume || terminal._tag === "Failure") return terminal;
} else if (resume) {
if (!fibers) return exitVoid;
else if (fibers.size === 0) resume(void_$1);
}
};
return go();
};
};
/** @internal */
const iterateConcurrent = () => (options) => iterateConcurrentImpl(options);
/** @internal */
const forkUnsafe = (parent, effect, immediate = false, daemon = false, uninterruptible = false) => {
const parentRuntime = parent;
const interruptible = uninterruptible === "inherit" ? parentRuntime.interruptible : !uninterruptible;
const child = new FiberImpl(parentRuntime.context, interruptible);
if (!daemon) {
parentRuntime.children().add(child);
child._parent = parentRuntime;
}
if (immediate) child.evaluate(effect);
else {
child._asyncContext = captureAsyncContext();
parentRuntime.currentDispatcher.scheduleTask(() => child.evaluate(effect), 0);
}
return child;
};
/** @internal */
const runForkWith = (context) => (effect, options) => {
const fiber = new FiberImpl(options?.scheduler ? add(context, Scheduler, options.scheduler) : context, options?.uninterruptible !== true);
fiber.evaluate(effect);
if (fiber._exit) return fiber;
if (options?.signal) {
if (options.signal.aborted) fiber.interruptUnsafe();
else {
const abort = () => fiber.interruptUnsafe();
options.signal.addEventListener("abort", abort, { once: true });
fiber.addObserver(() => options.signal.removeEventListener("abort", abort));
}
}
if (options?.onFiberStart) options.onFiberStart(fiber);
return fiber;
};
/** @internal */
const runSyncExitWith = (context) => {
const runFork = runForkWith(context);
return (effect) => {
if (effectIsExit(effect)) return effect;
const scheduler = new MixedScheduler("sync");
const fiber = runFork(effect, { scheduler });
fiber._dispatcher?.flush();
return fiber._exit ?? exitDie(new AsyncFiberError(fiber));
};
};
/** @internal */
const runSyncExit$1 = /*#__PURE__*/ runSyncExitWith(/*#__PURE__*/ empty());
/** @internal */
const AsyncFiberErrorTypeId = "~effect/Cause/AsyncFiberError";
/** @internal */
var AsyncFiberError = class extends (/*#__PURE__*/ TaggedError$1("AsyncFiberError")) {
[AsyncFiberErrorTypeId] = AsyncFiberErrorTypeId;
constructor(fiber) {
super({
message: "An asynchronous Effect was executed with Effect.runSync",
fiber
});
}
};
const colors = {
bold: "1",
red: "31",
green: "32",
yellow: "33",
blue: "34",
cyan: "36",
white: "37",
gray: "90",
black: "30",
bgBrightRed: "101"
};
colors.gray, colors.blue, colors.green, colors.yellow, colors.red, colors.bgBrightRed, colors.black;
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Cause.js
/**
* Narrows a `Reason` to `Fail`.
*
* **When to use**
*
* Use as a predicate for `Array.filter` to pick out typed `Fail` reasons when
* iterating over `cause.reasons`.
*
* **Example** (Filtering fail reasons)
*
* ```ts import.meta.vitest
* import { Cause } from "effect"
*
* const cause = Cause.fail("error")
* const fails = cause.reasons.filter(Cause.isFailReason)
* fails[0].error // => "error"
* ```
*
* @see {@link isDieReason} — narrow to `Die`
* @see {@link isInterruptReason} — narrow to `Interrupt`
*
* @stability stable
* @category guards
* @since 4.0.0
*/
const isFailReason = isFailReason$1;
/**
* Creates a `Cause` containing a single `Die` reason with the
* given defect.
*
* **When to use**
*
* Use to construct a cause from an untyped defect or unexpected thrown value.
*
* **Example** (Creating a die cause)
*
* ```ts import.meta.vitest
* import { Cause } from "effect"
*
* Cause.die("Unexpected") // => Cause.fromReasons([Cause.makeDieReason("Unexpected")])
* ```
*
* @see {@link fail} — for typed errors
* @see {@link interrupt} — for fiber interruptions
*
* @stability stable
* @category constructors
* @since 2.0.0
*/
const die$1 = causeDie;
/**
* Transforms the typed error values inside a `Cause` using the
* provided function. Only `Fail` reasons are affected; `Die` and `Interrupt`
* reasons pass through unchanged.
*
* **When to use**
*
* Use to transform expected typed failures while preserving defects and
* interruptions unchanged.
*
* **Details**
*
* If at least one `Fail` reason exists, this returns a new `Cause`
* containing the mapped failures. If the cause has no `Fail` reasons, the
* original cause is returned unchanged.
*
* **Example** (Mapping errors to uppercase)
*
* ```ts import.meta.vitest
* import { Cause } from "effect"
*
* const cause = Cause.fail("error")
* const mapped = Cause.map(cause, (e) => e.toUpperCase())
* const reason = mapped.reasons[0]
* if (Cause.isFailReason(reason)) {
* reason.error // => "ERROR"
* }
* ```
*
* @stability stable
* @category mapping
* @since 2.0.0
*/
const map = causeMap;
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Exit.js
/**
* Creates a successful Exit containing the given value.
*
* **When to use**
*
* Use when you need an Exit that contains a known success value.
*
* **Details**
*
* Returns a `Success<A>` with the provided value. Does not perform any
* computation.
*
* **Example** (Creating a successful Exit)
*
* ```ts import.meta.vitest
* import { Exit } from "effect"
*
* Exit.succeed(42) // => Exit.succeed(42)
* ```
*
* @see {@link fail} to create a failed Exit
* @see {@link void_ void} for a pre-allocated success with no value
*
* @stability stable
* @category constructors
* @since 2.0.0
*/
const succeed$2 = exitSucceed;
/**
* Creates a failed Exit from a Cause.
*
* **When to use**
*
* Use when you already have a `Cause<E>` and want to wrap it in an Exit
* for advanced error handling where you need full control over the Cause
* structure.
*
* **Details**
*
* Returns a `Failure<never, E>`. If you only have an error value, use
* {@link fail} instead.
*
* **Example** (Creating a failed Exit from a Cause)
*
* ```ts import.meta.vitest
* import { Cause, Exit } from "effect"
*
* Exit.failCause(Cause.fail("Something went wrong")) // => Exit.fail("Something went wrong")
* ```
*
* @see {@link fail} to create a Failure from a plain error value
* @see {@link die} to create a Failure from a defect
*
* @stability stable
* @category constructors
* @since 2.0.0
*/
const failCause = exitFailCause;
/**
* Creates a failed Exit from a typed error value.
*
* **When to use**
*
* Use when you need to represent an expected typed failure as an `Exit`.
*
* **Details**
*
* The error is wrapped in a `Cause.Fail` internally.
*
* Returns a `Failure<never, E>`.
*
* **Example** (Creating a failed Exit)
*
* ```ts import.meta.vitest
* import { Exit } from "effect"
*
* Exit.fail("Something went wrong") // => Exit.fail("Something went wrong")
* ```
*
* @see {@link succeed} to create a successful Exit
* @see {@link die} to create a Failure from an unexpected defect
* @see {@link failCause} to create a Failure from a full Cause
*
* @stability stable
* @category constructors
* @since 2.0.0
*/
const fail$2 = exitFail;
const void_ = exitVoid;
/**
* Checks whether an Exit is a Success.
*
* **When to use**
*
* Use as a type guard to narrow `Exit<A, E>` to `Success<A, E>` and access the
* `value` property.
*
* **Example** (Narrowing to success)
*
* ```ts import.meta.vitest
* import { Exit } from "effect"
*
* const exit = Exit.succeed(42)
*
* if (Exit.isSuccess(exit)) {
* exit.value // => 42
* }
* ```
*
* @see {@link isFailure} for the opposite check
* @see {@link match} for exhaustive pattern matching
*
* @stability stable
* @category guards
* @since 2.0.0
*/
const isSuccess = exitIsSuccess;
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/dateTime.js
/** @internal */
const TypeId$10 = "~effect/DateTime";
/** @internal */
const TimeZoneTypeId = "~effect/DateTime/TimeZone";
const Proto$4 = {
[TypeId$10]: TypeId$10,
pipe() {
return pipeArguments(this, arguments);
},
[NodeInspectSymbol]() {
return this.toString();
},
toJSON() {
return toDateUtc$1(this).toJSON();
}
};
({ ...Proto$4 });
({ ...Proto$4 });
const ProtoTimeZone = {
[TimeZoneTypeId]: TimeZoneTypeId,
[NodeInspectSymbol]() {
return this.toString();
}
};
({ ...ProtoTimeZone });
({ ...ProtoTimeZone });
/** @internal */
const toDateUtc$1 = (self) => new Date(self.epochMilliseconds);
/**
* Creates an `Effect` that always succeeds with a given value.
*
* **When to use**
*
* Use when an effect should complete successfully with a specific value without any errors
* or external dependencies.
*
* **Example** (Creating a successful effect)
*
* ```ts import.meta.vitest
* import { Effect } from "effect"
*
* // Creating an effect that represents a successful scenario
* //
* // ┌─── Effect<number, never, never>
* // â–¼
* const success = Effect.succeed(42)
* Effect.runSync(success) // => 42
* ```
*
* @see {@link fail} to create an effect that represents a failure.
* @stability stable
* @category constructors
* @since 2.0.0
*/
const succeed$1 = succeed$3;
/**
* Creates an `Effect` lazily, delaying construction until it is needed.
*
* **When to use**
*
* Use when you need to defer the evaluation of an effect until it is required.
*
* **Details**
*
* `suspend` takes a thunk that represents an effect and delays creating it
* until the suspended effect is evaluated. This is useful for optimizing
* expensive computations, managing circular dependencies such as recursive
* functions, and helping TypeScript unify return types when branches construct
* different effects. Any side effects or scoped captures inside the thunk are
* re-executed on each invocation.
*
* **Example** (Lazily evaluating side effects)
*
* ```ts import.meta.vitest
* import { Effect } from "effect"
*
* let i = 0
*
* const bad = Effect.succeed(i++)
*
* const good = Effect.suspend(() => Effect.succeed(i++))
*
* Effect.runSync(bad) // => 0
* Effect.runSync(bad) // => 0
*
* Effect.runSync(good) // => 1
* Effect.runSync(good) // => 2
* ```
*
* **Example** (Suspending recursive Fibonacci evaluation)
*
* ```ts import.meta.vitest
* import { Effect } from "effect"
*
* const blowsUp = (n: number): Effect.Effect<number> =>
* n < 2
* ? Effect.succeed(1)
* : Effect.zipWith(blowsUp(n - 1), blowsUp(n - 2), (a, b) => a + b)
*
* // console.log(Effect.runSync(blowsUp(32)))
* // crash: JavaScript heap out of memory
*
* const allGood = (n: number): Effect.Effect<number> =>
* n < 2
* ? Effect.succeed(1)
* : Effect.zipWith(
* Effect.suspend(() => allGood(n - 1)),
* Effect.suspend(() => allGood(n - 2)),
* (a, b) => a + b
* )
*
* Effect.runSync(allGood(16)) // => 1597
* ```
*
* **Example** (Helping TypeScript infer recursive effect types)
*
* ```ts import.meta.vitest
* import { Effect } from "effect"
*
* // Without suspend, TypeScript may struggle with type inference.
* // Inferred type:
* // (a: number, b: number) =>
* // Effect<never, Error, never> | Effect<number, never, never>
* const withoutSuspend = (a: number, b: number) =>
* b === 0
* ? Effect.fail(new Error("Cannot divide by zero"))
* : Effect.succeed(a / b)
*
* // Using suspend to unify return types.
* // Inferred type:
* // (a: number, b: number) => Effect<number, Error, never>
* const withSuspend = (a: number, b: number) =>
* Effect.suspend(() =>
* b === 0
* ? Effect.fail(new Error("Cannot divide by zero"))
* : Effect.succeed(a / b)
* )
*
* Effect.runSync(withSuspend(6, 2)) // => 3
* ```
*
* @stability stable
* @category constructors
* @since 2.0.0
*/
const suspend = suspend$1;
/**
* Creates an `Effect` that represents a recoverable error.
*
* **When to use**
*
* Use to explicitly signal a recoverable error in an `Effect`.
*
* **Details**
*
* The error keeps propagating unless it is handled. You can handle tagged
* errors with functions like {@link catchTag} or {@link catchTags}.
*
* **Example** (Creating a failed effect)
*
* ```ts import.meta.vitest
* import { Data, Effect } from "effect"
*
* class OperationFailedError extends Data.TaggedError("OperationFailedError")<{}> {}
*
* // ┌─── Effect<never, OperationFailedError, never>
* // â–¼
* const failure = Effect.fail(
* new OperationFailedError()
* )
* Effect.runSync(Effect.flip(failure))._tag // => "OperationFailedError"
* ```
*
* @see {@link succeed} to create an effect that represents a successful value.
* @stability stable
* @category constructors
* @since 2.0.0
*/
const fail$1 = fail$3;
/**
* Creates an `Effect` that represents a failure with a `Cause` computed lazily.
*
* **When to use**
*
* Use to defer computing a full `Cause` until the effect is run.
*
* **Details**
*
* The cause-producing function is evaluated each time the effect is executed.
*
* **Example** (Lazily creating a Cause)
*
* ```ts import.meta.vitest
* import { Cause, Effect } from "effect"
*
* const program = Effect.failCauseSync(() =>
* Cause.fail("Error computed at runtime")
* )
*
* Effect.runSync(Effect.flip(program)) // => "Error computed at runtime"
* ```
*
* @stability stable
* @category constructors
* @since 2.0.0
*/
const failCauseSync = failCauseSync$1;
/**
* Creates an effect that terminates a fiber with a specified error.
*
* **When to use**
*
* Use when you need an `Effect` to report an unrecoverable defect instead of a
* typed error.
*
* **Details**
*
* The `die` function is used to signal a defect, which represents a critical
* and unexpected error in the code. When invoked, it produces an effect that
* does not handle the error and instead terminates the fiber.
*
* The error channel of the resulting effect is of type `never`, indicating that
* it cannot recover from this failure.
*
* **Example** (Failing on division by zero)
*
* ```ts import.meta.vitest
* import { Effect, Exit } from "effect"
*
* const defect = new Error("Cannot divide by zero")
* const divide = (a: number, b: number) =>
* b === 0
* ? Effect.die(defect)
* : Effect.succeed(a / b)
*
* // ┌─── Effect<number, never, never>
* // â–¼
* const program = divide(1, 0)
*
* Effect.runSyncExit(program) // => Exit.die(defect)
* ```
*
* @stability stable
* @category constructors
* @since 2.0.0
*/
const die = die$2;
/**
* Chains effects to produce new `Effect` instances, useful for combining
* operations that depend on previous results.
*
* **When to use**
*
* Use when you need to chain multiple effects, ensuring that each
* step produces a new `Effect` while flattening any nested effects that may
* occur.
*
* **Details**
*
* `flatMap` lets you sequence effects so that the result of one effect can be
* used in the next step. It is similar to `flatMap` used with arrays but works
* specifically with `Effect` instances, allowing you to avoid deeply nested
* effect structures.
*
* Since effects are immutable, `flatMap` always returns a new effect instead of
* changing the original one.
*
* **Example** (Choosing flatMap syntax variants)
*
* ```ts import.meta.vitest
* import { Effect, pipe } from "effect"
* const output: Array<unknown> = []
*
* const myEffect = Effect.succeed(1)
* const transformation = (n: number) => Effect.succeed(n + 1)
*
* const flatMappedWithPipe = pipe(myEffect, Effect.flatMap(transformation))
* const flatMappedWithDataFirst = Effect.flatMap(myEffect, transformation)
* const flatMappedWithMethod = myEffect.pipe(Effect.flatMap(transformation))
*
* void output.push(Effect.runSync(Effect.all([
* flatMappedWithPipe,
* flatMappedWithDataFirst,
* flatMappedWithMethod
* ])))
* output // => [[2, 2, 2]]
* ```
*
* **Example** (Sequencing dependent effects)
*
* ```ts import.meta.vitest
* import { Data, Effect, pipe } from "effect"
*
* class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
*
* // Function to apply a discount safely to a transaction amount
* const applyDiscount = (
* total: number,
* discountRate: number
* ): Effect.Effect<number, DiscountRateError> =>
* discountRate === 0
* ? Effect.fail(new DiscountRateError())
* : Effect.succeed(total - (total * discountRate) / 100)
*
* // Simulated asynchronous task to fetch a transaction amount from database
* const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))
*
* // Chaining the fetch and discount application using `flatMap`
* const finalAmount = pipe(
* fetchTransactionAmount,
* Effect.flatMap((amount) => applyDiscount(amount, 5))
* )
*
* await Effect.runPromise(finalAmount) // => 95
* ```
*
* @see {@link tap} for a version that ignores the result of the effect.
* @stability stable
* @category sequencing
* @since 2.0.0
*/
const flatMap = flatMap$1;
/**
* Transforms an effect to encapsulate both failure and success using the `Exit`
* data type.
*
* **When to use**
*
* Use when you need to inspect the full outcome, including typed failures, defects,
* and interruptions.
*
* **Details**
*
* `exit` wraps an effect's success or failure inside an `Exit` type, allowing
* you to handle both cases explicitly.
*
* The resulting effect cannot fail because the failure is encapsulated within
* the `Exit.Failure` type. The error type is set to `never`, indicating that
* the effect is structured to never fail directly.
*
* **Example** (Capturing completion as Exit)
*
* ```ts import.meta.vitest
* import { Effect, Exit } from "effect"
*
* const success = Effect.succeed(42)
* const failure = Effect.fail("Something went wrong")
*
* const program1 = Effect.exit(success)
* const program2 = Effect.exit(failure)
*
* Effect.runSync(program1) // => Exit.succeed(42)
*
* Effect.runSync(program2) // => Exit.fail("Something went wrong")
* ```
*
* @see {@link option} for a version that uses `Option` instead.
* @see {@link result} for a version that uses `Result` instead.
*
* @stability stable
* @category error handling
* @since 2.0.0
*/
const exit = exit$1;
/**
* Handles both recoverable and unrecoverable errors by providing a recovery
* effect.
*
* **When to use**
*
* Use when you need to recover from an `Effect` by inspecting the full `Cause`,
* including recoverable failures, defects, and interruptions, instead of only
* the typed error value.
*
* **Details**
*
* When to Recover from Defects:
*
* Defects are unexpected errors that typically shouldn't be recovered from, as
* they often indicate serious issues. However, in some cases, such as
* dynamically loaded plugins, controlled recovery might be needed.
*
* **Example** (Recovering from full failure causes)
*
* ```ts import.meta.vitest
* import { Cause, Effect } from "effect"
* const output: Array<unknown> = []
*
* // An effect that might fail in different ways
* const program = Effect.die("Something went wrong")
*
* // Recover from any cause (including defects)
* const recovered = Effect.catchCause(program, (cause) => {
* if (Cause.hasDies(cause)) {
* return Effect.sync(() => { output.push("Caught defect") }).pipe(
* Effect.as("Recovered from defect")
* )
* }
* return Effect.succeed("Unknown error")
* })
*
* void output.push(Effect.runSync(recovered))
* output // => ["Caught defect", "Recovered from defect"]
* ```
*
* @stability stable
* @category error handling
* @since 4.0.0
*/
const catchCause = catchCause$1;
/**
* Runs an effect synchronously and captures the outcome safely as an `Exit` type, which
* represents the outcome (success or failure) of the effect.
*
* **When to use**
*
* Use to find out whether an effect succeeded or failed,
* including any defects, without dealing with asynchronous operations.
*
* **Details**
*
* The `Exit` type represents the result of the effect. Successful effects are
* wrapped in `Success`, and failed effects are wrapped in `Failure` with a
* `Cause`.
*
* If the effect contains asynchronous operations, `runSyncExit` will
* return an `Failure` with a `Die` cause, indicating that the effect cannot be
* resolved synchronously.
*
* **Example** (Observing synchronous results as Exit)
*
* ```ts import.meta.vitest
* import { Effect, Exit } from "effect"
*
* Effect.runSyncExit(Effect.succeed(1)) // => Exit.succeed(1)
*
* Effect.runSyncExit(Effect.fail("my error")) // => Exit.fail("my error")
* ```
*
* **Example** (Capturing async work as a Die cause)
*
* ```ts import.meta.vitest
* import { Cause, Effect, Exit } from "effect"
*
* const exit = Effect.runSyncExit(Effect.promise(() => Promise.resolve(1)))
* const isAsyncDie = Exit.hasDies(exit) && exit.cause.reasons.some(
* (reason) => Cause.isDieReason(reason) && Cause.isAsyncFiberError(reason.defect)
* )
*
* isAsyncDie // => true
* ```
*
* @see {@link runSync} for a version that throws on failure.
*
* @stability stable
* @category running
* @since 2.0.0
*/
const runSyncExit = runSyncExit$1;
/**
* Applies `map` eagerly when an effect is already resolved.
*
* **When to use**
*
* Use when an already-resolved effect should apply a success transformation
* immediately while pending effects still use regular mapping.
*
* **Details**
*
* Success effects apply the mapping function immediately. Failure effects pass
* through unchanged, and pending effects fall back to regular `map` behavior.
*
* **Example** (Mapping already completed effects)
*
* ```ts import.meta.vitest
* import { Effect } from "effect"
*
* // For resolved effects, the mapping is applied immediately
* const resolved = Effect.succeed(5)
* const mapped = Effect.mapEager(resolved, (n) => n * 2) // Applied eagerly
*
* // For pending effects, behaves like regular map
* const pending = Effect.delay(Effect.succeed(5), 0)
* const mappedPending = Effect.mapEager(pending, (n) => n * 2) // Uses regular map
*
* await Effect.runPromise(Effect.all([mapped, mappedPending])) // => [10, 10]
* ```
*
* @stability stable
* @category mapping
* @since 4.0.0
*/
const mapEager = mapEager$1;
/**
* Applies `flatMap` eagerly when an effect is already resolved.
*
* **When to use**
*
* Use when an already-resolved successful effect should bind immediately to the
* next effect while pending effects still use regular flat mapping.
*
* **Details**
*
* Success effects apply the flatMap function immediately. Failure effects pass
* through unchanged, and pending effects fall back to regular `flatMap`
* behavior.
*
* **Example** (Flat mapping eagerly when possible)
*
* ```ts import.meta.vitest
* import { Effect } from "effect"
*
* // For resolved effects, the flatMap is applied immediately
* const resolved = Effect.succeed(5)
* const flatMapped = Effect.flatMapEager(resolved, (n) => Effect.succeed(n * 2)) // Applied eagerly
*
* // For pending effects, behaves like regular flatMap
* const pending = Effect.delay(Effect.succeed(5), 0)
* const flatMappedPending = Effect.flatMapEager(
* pending,
* (n) => Effect.succeed(n * 2)
* ) // Uses regular flatMap
*
* await Effect.runPromise(Effect.all([flatMapped, flatMappedPending])) // => [10, 10]
* ```
*
* @stability stable
* @category sequencing
* @since 4.0.0
*/
const flatMapEager = flatMapEager$1;
/**
* Creates untraced function effects with eager evaluation optimization.
*
* **Details**
*
* Executes generator functions eagerly when all yielded effects are synchronous,
* stopping at the first async effect and deferring to normal execution.
*
* **Example** (Defining eager untraced effect functions)
*
* ```ts import.meta.vitest
* import { Effect } from "effect"
*
* const computation = Effect.fnUntracedEager(function*() {
* yield* Effect.succeed(1)
* yield* Effect.succeed(2)
* return "computed eagerly"
* })
*
* const effect = computation() // Executed immediately if all effects are sync
* Effect.runSync(effect) // => "computed eagerly"
* ```
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const fnUntracedEager = fnUntracedEager$1;
const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const codes = /*#__PURE__*/ (/* @__PURE__ */ new Uint8Array(123)).fill(255);
for (let i = 0; i < 64; i++) codes[/*#__PURE__*/ alphabet.charCodeAt(i)] = i;
codes[/*#__PURE__*/ "=".charCodeAt(0)] = 0;
({ ...BaseProto });
({ ...BaseProto });
({ ...PipeInspectableProto });
BaseProto.toString, BaseProto[NodeInspectSymbol];
({ ...PipeInspectableProto });
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/schema/annotations.js
/** @internal */
function resolve$1(ast) {
return ast.checks ? ast.checks[ast.checks.length - 1].annotations : ast.annotations;
}
/** @internal */
const STRUCTURAL_ANNOTATION_KEY = "~structural";
/** @internal */
const SENTINELS_ANNOTATION_KEY = "~sentinels";
/** @internal */
const CONSTRUCTOR_ANNOTATION_KEY = "~constructor";
/** @internal */
const getExpected = /*#__PURE__*/ memoize((ast) => {
const identifier = resolve$1(ast)?.identifier;
if (typeof identifier === "string") return identifier;
return ast.getExpected(getExpected);
});
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/schema/parser.js
/** @internal */
const missing = /*#__PURE__*/ Symbol();
/** @internal */
const succeed = succeed$2;
/** @internal */
const missingExit = /*#__PURE__*/ succeed(missing);
/** @internal */
const sameExit = /*#__PURE__*/ succeed(missing);
/** @internal */
const toOption = (value) => value === missing ? none() : some(value);
/** @internal */
const fromOptionExit = (option) => option._tag === "None" ? missingExit : succeed(option.value);
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/SchemaIssue.js
/**
* Describes problems found while decoding, encoding, or checking data with
* schemas.
*
* An `Issue` records what failed and, for nested data, where the failure
* happened. The Schema system uses these values for missing keys, unexpected
* keys, invalid types, invalid values, failed filters, failed transformations,
* and alternatives that did not match. This module also formats issues.
*
* @stability stable
* @since 4.0.0
*/
const TypeId$5 = "~effect/SchemaIssue/Issue";
/**
* Returns `true` if the given value is an {@link Issue}.
*
* **When to use**
*
* Use when you need to narrow an `unknown` value to `Issue` in error-handling
* code, such as distinguishing an `Issue` from other error types in a catch-all
* handler.
*
* **Details**
*
* - Checks for the internal `TypeId` brand on the value.
*
* **Example** (Type-guarding an unknown error)
*
* ```ts import.meta.vitest
* import { SchemaIssue } from "effect"
*
* const issue = new SchemaIssue.MissingKey(undefined)
* SchemaIssue.isIssue(issue) // => true
* SchemaIssue.isIssue("not an issue") // => false
* ```
*
* @see {@link Issue}
*
* @stability stable
* @category guards
* @since 4.0.0
*/
function isIssue(u) {
return hasProperty(u, TypeId$5) && u[TypeId$5] === TypeId$5;
}
/**
* Returns `true` when an issue contains an input reported by the schema parser.
*
* **When to use**
*
* Use when reading `Issue.input`, especially when `undefined` is a valid input
* value.
*
* **Details**
*
* Reported input is stored as an own property. This guard checks for that
* property and narrows `input` from optional to required.
*
* **Example** (Reading a reported input)
*
* ```ts import.meta.vitest
* import { Result, Schema, SchemaIssue } from "effect"
*
* const result = Schema.decodeUnknownResult(Schema.String)(1, { reportInput: true })
* if (Result.isFailure(result) && SchemaIssue.hasInput(result.failure.issue)) {
* result.failure.issue.input // => 1
* }
* ```
*
* @see {@link Issue} for the complete issue model
*
* @stability stable
* @category guards
* @since 4.0.0
*/
function hasInput(issue) {
return Object.hasOwn(issue, "input");
}
var IssueNodeImpl = class {
[TypeId$5] = TypeId$5;
constructor(input, options) {
if (options?.reportInput === true && input !== missing) this.input = input;
}
};
/**
* Constructs a schema issue for a failed refinement check.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const Filter$1 = class extends IssueNodeImpl {
_tag = "Filter";
/**
* The filter that failed.
*/
filter;
/**
* The issue that occurred.
*/
issue;
constructor(filter, issue, input, options) {
super(input, options);
this.filter = filter;
this.issue = issue;
}
};
/**
* Constructs a schema issue for a failed transformation.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const Encoding = class extends IssueNodeImpl {
_tag = "Encoding";
/**
* The schema that caused the issue.
*/
ast;
/**
* The issue that occurred.
*/
issue;
constructor(ast, issue, input, options) {
super(input, options);
this.ast = ast;
this.issue = issue;
}
};
/**
* Constructs a schema issue that points to a nested location.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const Pointer = class extends IssueNodeImpl {
_tag = "Pointer";
/**
* The path to the location in the input that caused the issue.
*/
path;
/**
* The issue that occurred.
*/
issue;
constructor(path, issue) {
super();
this.path = path;
this.issue = issue;
}
};
/**
* Constructs a schema issue for a missing key or tuple index.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const MissingKey = class extends IssueNodeImpl {
_tag = "MissingKey";
/**
* The metadata for the issue.
*/
annotations;
constructor(annotations) {
super();
this.annotations = annotations;
}
};
/**
* Constructs a schema issue for an unexpected key or tuple index.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const UnexpectedKey = class extends IssueNodeImpl {
_tag = "UnexpectedKey";
/**
* The schema that caused the issue.
*/
ast;
constructor(ast, input, options) {
super(input, options);
this.ast = ast;
}
};
/**
* Constructs a schema issue that groups multiple child issues.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const Composite = class extends IssueNodeImpl {
_tag = "Composite";
/**
* The schema that caused the issue.
*/
ast;
/**
* The issues that occurred.
*/
issues;
constructor(ast, issues, input, options) {
super(input, options);
this.ast = ast;
this.issues = issues;
}
};
/**
* Constructs a schema issue for an input with an invalid runtime type.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const InvalidType = class extends IssueNodeImpl {
_tag = "InvalidType";
/**
* The schema that caused the issue.
*/
ast;
constructor(ast, input, options) {
super(input, options);
this.ast = ast;
}
};
/**
* Constructs a schema issue for a value that violates a constraint.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const InvalidValue = class extends IssueNodeImpl {
_tag = "InvalidValue";
/**
* The metadata for the issue.
*/
annotations;
constructor(annotations, input, options) {
super(input, options);
this.annotations = annotations;
}
};
/**
* Constructs a schema issue for a value that matches no union member.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const AnyOf = class extends IssueNodeImpl {
_tag = "AnyOf";
/**
* The schema that caused the issue.
*/
ast;
/**
* The issues that occurred.
*/
issues;
constructor(ast, issues, input, options) {
super(input, options);
this.ast = ast;
this.issues = issues;
}
};
/**
* Constructs a schema issue for a value that matches multiple union members.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const OneOf = class extends IssueNodeImpl {
_tag = "OneOf";
/**
* The schema that caused the issue.
*/
ast;
/**
* The schemas that were successful.
*/
successes;
constructor(ast, successes, input, options) {
super(input, options);
this.ast = ast;
this.successes = successes;
}
};
function makeFilterIssue(entry, input, options) {
if (isIssue(entry)) return entry;
if (typeof entry === "string") return new InvalidValue({ message: entry }, input, options);
const inner = typeof entry.issue === "string" ? new InvalidValue({ message: entry.issue }, input, options) : entry.issue;
return new Pointer(entry.path, inner);
}
/** @internal */
function makeSingle(out, input, options) {
if (out === void 0) return;
if (typeof out === "boolean") return out ? void 0 : new InvalidValue(void 0, input, options);
return makeFilterIssue(out, input, options);
}
/** @internal */
function normalizeFilterOutput(ast, out, input, options) {
if (Array.isArray(out)) {
if (!isReadonlyArrayNonEmpty(out)) return;
return out.length === 1 ? makeFilterIssue(out[0], input, options) : new Composite(ast, map$2(out, (entry) => makeFilterIssue(entry, input, options)), input, options);
}
return makeSingle(out, input, options);
}
/**
* Returns the built-in {@link LeafHook} used by default formatters.
*
* **When to use**
*
* Use as the default leaf renderer when customizing only the {@link CheckHook}.
*
* **Details**
*
* - Checks for a `message` annotation first; returns it if present.
* - For `InvalidValue`, an `expected` annotation uses the standard expected
* value message and includes reported input when available.
* - Otherwise generates a default message per `_tag`. When the issue reports
* input, the message includes its formatted value where applicable:
* - `InvalidType` → `"Expected <type>"` or `"Expected <type>, got <input>"`
* - `InvalidValue` → `"Expected a valid value"` or `"Invalid data <input>"`
* - `MissingKey` → `"Missing key"`
* - `UnexpectedKey` → `"Expected no excess property"` or
* `"Unexpected key with value <input>"`
* - `Forbidden` → `"Forbidden operation"`
* - `OneOf` → `"Expected exactly one member to match"` or
* `"Expected exactly one member to match the input <input>"`
*
* **Example** (Formatting Standard Schema issues with defaultLeafHook)
*
* ```ts import.meta.vitest
* import { SchemaIssue } from "effect"
*
* const formatter = SchemaIssue.makeFormatterStandardSchemaV1({
* leafHook: SchemaIssue.defaultLeafHook
* })
* formatter(new SchemaIssue.MissingKey(undefined)) // => { issues: [{ path: [], message: "Missing key" }] }
* ```
*
* @see {@link LeafHook}
* @see {@link makeFormatterStandardSchemaV1}
*
* @stability stable
* @category formatting
* @since 4.0.0
*/
const defaultLeafHook = (issue) => {
const message = findMessage(issue);
if (message !== void 0) return message;
switch (issue._tag) {
case "InvalidType": return getExpectedMessage(getExpected(issue.ast), issue);
case "InvalidValue": {
const expected = findExpected(issue);
if (expected !== void 0) return getExpectedMessage(expected, issue);
const input = formatInput(issue);
return input === void 0 ? "Expected a valid value" : `Invalid data ${input}`;
}
case "MissingKey": return "Missing key";
case "UnexpectedKey": {
const input = formatInput(issue);
return input === void 0 ? "Expected no excess property" : `Unexpected key with value ${input}`;
}
case "Forbidden": return "Forbidden operation";
case "OneOf": {
const input = formatInput(issue);
return input === void 0 ? "Expected exactly one member to match" : `Expected exactly one member to match the input ${input}`;
}
}
};
/**
* Returns the built-in {@link CheckHook} used by default formatters.
*
* **When to use**
*
* Use as the default filter renderer when customizing only the {@link LeafHook}.
*
* **Details**
*
* - Looks for a `message` annotation on the inner issue first, then on the
* filter itself.
* - Returns `undefined` when no annotation is found, causing the formatter to
* fall back to `"Expected <filter>"` or, when the filter reports input,
* `"Expected <filter>, got <input>"`.
*
* @see {@link CheckHook}
* @see {@link makeFormatterStandardSchemaV1}
*
* @stability stable
* @category formatting
* @since 4.0.0
*/
const defaultCheckHook = (issue) => findMessage(issue.issue) ?? findMessage(issue);
function formatInput(issue) {
return hasInput(issue) ? format$1(issue.input) : void 0;
}
function findExpected(issue) {
const expected = issue.annotations?.expected;
return typeof expected === "string" ? expected : void 0;
}
function getExpectedMessage(expected, issue) {
const input = formatInput(issue);
return input === void 0 ? `Expected ${expected}` : `Expected ${expected}, got ${input}`;
}
function formatCheck(check) {
const expected = check.annotations?.expected;
if (typeof expected === "string") return expected;
switch (check._tag) {
case "Filter": return "<filter>";
case "FilterGroup": return check.checks.map((check) => formatCheck(check)).join(" & ");
}
}
/**
* Creates a {@link Formatter} that converts an {@link Issue} into a
* human-readable multi-line string.
*
* **When to use**
*
* Use when you need to format a `SchemaIssue.Issue` as error messages for
* logging, CLI output, or developer-facing diagnostics.
*
* **Details**
*
* - Flattens the issue tree into `{ message, path }` entries using
* {@link defaultLeafHook} and {@link defaultCheckHook}.
* - Includes reported input in default messages when the node producing the
* message has an `input` field.
* - Each entry is rendered as `"<message>"` or `"<message>\n at <path>"`.
* - Multiple entries are joined with newlines.
*
* **Gotchas**
*
* Formatting an issue can disclose input retained with `reportInput: true`.
* Wrapper inputs are not inherited by child messages, and custom messages are
* returned unchanged.
*
* **Example** (Formatting an issue as a string)
*
* ```ts import.meta.vitest
* import { SchemaIssue } from "effect"
*
* const formatter = SchemaIssue.makeFormatterDefault()
* formatter(new SchemaIssue.MissingKey(undefined)) // => "Missing key"
* ```
*
* @see {@link makeFormatterStandardSchemaV1} — produces Standard Schema V1 format instead
* @see {@link Formatter}
*
* @stability stable
* @category formatting
* @since 4.0.0
*/
function makeFormatterDefault() {
return (issue) => formatIssue(issue, "");
}
/** @internal */
const defaultFormatter = /*#__PURE__*/ makeFormatterDefault();
function formatIssue(issue, path) {
let message;
switch (issue._tag) {
case "Filter": {
const annotated = defaultCheckHook(issue);
if (annotated !== void 0) message = annotated;
else {
if (issue.issue._tag !== "InvalidValue") return formatIssue(issue.issue, path);
const expected = findExpected(issue.issue);
message = expected === void 0 ? getExpectedMessage(formatCheck(issue.filter), issue) : getExpectedMessage(expected, issue.issue);
}
break;
}
case "Encoding": return formatIssue(issue.issue, path);
case "Pointer": return formatIssue(issue.issue, path + formatPath(issue.path));
case "Composite":
case "AnyOf":
if (issue._tag === "Composite" || issue.issues.length > 0) return issue.issues.map((issue) => formatIssue(issue, path)).join("\n");
message = findMessage(issue) ?? getExpectedMessage(getExpected(issue.ast), issue);
break;
default: message = defaultLeafHook(issue);
}
return path ? `${message}\n at ${path}` : message;
}
function findMessage(issue) {
if (issue._tag === "Pointer") return;
if (issue._tag === "Encoding") return findMessage(issue.issue);
const message = (issue._tag === "Filter" ? issue.filter.annotations : "annotations" in issue ? issue.annotations : issue.ast.annotations)?.[issue._tag === "MissingKey" ? "messageMissingKey" : issue._tag === "UnexpectedKey" ? "messageUnexpectedKey" : "message"];
if (typeof message === "string") return message;
}
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/schema/cause.js
/** @internal */
function getSchemaIssue(cause) {
let issue;
for (const reason of cause.reasons) {
if (!isFailReason(reason) || !isIssue(reason.error)) return;
issue ??= reason.error;
}
return issue;
}
/** @internal */
function getSchemaIssueOrThrow(cause, message) {
const issue = getSchemaIssue(cause);
if (issue === void 0) throw new Error(message, { cause });
return issue;
}
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/SchemaGetter.js
const makeGetter = (fields) => Object.assign(Object.create(Prototype$1), fields);
const passthrough_$1 = /*#__PURE__*/ makeGetter({ _tag: "Passthrough" });
function passthrough$1() {
return passthrough_$1;
}
/**
* Creates a getter that applies a pure function to present values.
*
* **When to use**
*
* Use when you need a schema getter for a pure, infallible transformation
* between types.
* - Building encode/decode pairs for `Schema.decodeTo`.
*
* **Details**
*
* - This is the most commonly used constructor.
* - Transforms `Some(e)` to `Some(f(e))` and leaves `None` unchanged.
* - Skips `None` inputs — only called when a value is present.
* - Never fails.
*
* **Example** (Transforming strings to numbers)
*
* ```ts import.meta.vitest
* import { Schema, SchemaGetter } from "effect"
*
* const NumberFromString = Schema.String.pipe(
* Schema.decodeTo(Schema.Number, {
* decode: SchemaGetter.transform((s) => Number(s)),
* encode: SchemaGetter.transform((n) => String(n))
* })
* )
* Schema.decodeSync(NumberFromString)("42") // => 42
* ```
*
* @see {@link transformEffect} when the transformation returns an `Effect`
* @see {@link transformOptional} when you need to handle `None` inputs
* @see {@link passthrough} when no transformation is needed
*
* @stability stable
* @category transforming
* @since 4.0.0
*/
function transform$1(f) {
return makeGetter({
_tag: "Transform",
transform: f
});
}
/**
* Coerces any value to a `string` using the global `String()` constructor.
*
* **When to use**
*
* Use when you need a schema getter to coerce a present encoded value to a
* string with `String()`.
*
* **Details**
*
* The getter is pure, never fails, and delegates to `globalThis.String`.
*
* **Example** (Coercing to a string)
*
* ```ts import.meta.vitest
* import { Effect, Option, SchemaGetter } from "effect"
*
* const toString = SchemaGetter.String<number>()
* Effect.runSync(SchemaGetter.run(toString, Option.some(42), {})) // => Option.some("42")
* ```
*
* @see {@link transform} for custom string conversions
*
* @stability stable
* @category converting
* @since 4.0.0
*/
function String$3() {
return transform$1(globalThis.String);
}
/**
* Coerces any value to a `number` using the global `Number()` constructor.
*
* **When to use**
*
* Use when you need a schema getter to coerce a present encoded value to a
* number with `Number()`.
*
* **Details**
*
* The getter is pure, never fails, and delegates to `globalThis.Number`. It may
* produce `NaN` for non-numeric inputs.
*
* **Example** (Coercing to a number)
*
* ```ts import.meta.vitest
* import { Effect, Option, SchemaGetter } from "effect"
*
* const toNumber = SchemaGetter.Number<string>()
* Effect.runSync(SchemaGetter.run(toNumber, Option.some("42"), {})) // => Option.some(42)
* ```
*
* @see {@link transformEffect} for effectful or validated number parsing
*
* @stability stable
* @category converting
* @since 4.0.0
*/
function Number$3() {
return transform$1(globalThis.Number);
}
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/SchemaTransformation.js
/**
* Constructs schema middleware from its decode and encode functions.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const Middleware = class extends Class$1 {
_tag = "Middleware";
decode;
encode;
constructor(decode, encode) {
super();
this.decode = decode;
this.encode = encode;
}
flip() {
return new Middleware(this.encode, this.decode);
}
};
const TypeId$4 = "~effect/SchemaTransformation/Transformation";
/**
* Constructs a bidirectional schema transformation from its decode and encode getters.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const Transformation = class extends Class$1 {
[TypeId$4] = TypeId$4;
_tag = "Transformation";
decode;
encode;
constructor(decode, encode) {
super();
this.decode = decode;
this.encode = encode;
}
flip() {
return new Transformation(this.encode, this.decode);
}
};
/**
* Returns `true` if `u` is a `Transformation` instance.
*
* **When to use**
*
* Use to check whether a value is already a schema transformation before
* wrapping it.
*
* **Details**
*
* - Pure predicate, no side effects.
* - Acts as a TypeScript type guard.
*
* **Example** (Checking a value)
*
* ```ts import.meta.vitest
* import { SchemaTransformation } from "effect"
*
* SchemaTransformation.isTransformation(SchemaTransformation.trim()) // => true
* SchemaTransformation.isTransformation({ decode: null, encode: null }) // => false
* ```
*
* @see {@link Transformation}
* @see {@link makeTransformation}
*
* @stability stable
* @category guards
* @since 4.0.0
*/
function isTransformation(u) {
return hasProperty(u, TypeId$4) && u[TypeId$4] === TypeId$4;
}
/**
* Constructs a `Transformation` from an object with `decode` and `encode`
* `Getter`s. If the input is already a `Transformation`, returns it as-is.
*
* **When to use**
*
* Use when you already have schema getter instances and want to pair them into
* a schema transformation.
* - You want idempotent wrapping (won't double-wrap).
*
* **Details**
*
* - Returns the input unchanged if it is already a `Transformation`.
*
* **Example** (Wrapping existing getters)
*
* ```ts import.meta.vitest
* import { SchemaGetter, SchemaTransformation } from "effect"
*
* const t = SchemaTransformation.makeTransformation({
* decode: SchemaGetter.transform<number, string>((s) => Number(s)),
* encode: SchemaGetter.transform<string, number>((n) => String(n))
* })
* t._tag // => "Transformation"
* ```
*
* @see {@link transform} — simpler constructor from pure functions
* @see {@link transformEffect} — constructor from effectful functions
* @see {@link Transformation}
*
* @stability stable
* @category constructors
* @since 3.10.0
*/
const makeTransformation = (options) => {
if (isTransformation(options)) return options;
return new Transformation(options.decode, options.encode);
};
const passthrough_ = /*#__PURE__*/ new Transformation(/*#__PURE__*/ passthrough$1(), /*#__PURE__*/ passthrough$1());
function passthrough() {
return passthrough_;
}
/**
* Decodes a `string` into a `number` and encodes a `number` back to a
* `string`.
*
* **When to use**
*
* Use when you need a schema transformation to parse numeric strings from APIs,
* form data, or URL parameters.
*
* **Details**
*
* Decoding coerces the string to a number like `Number(s)`. Encoding coerces
* the number to a string like `String(n)`. This does not validate that the
* result is finite; combine with `Schema.Finite` or `Schema.Int` for stricter
* checks.
*
* **Example** (Converting a string to a number)
*
* ```ts import.meta.vitest
* import { Schema, SchemaTransformation } from "effect"
*
* const schema = Schema.String.pipe(
* Schema.decodeTo(Schema.Number, SchemaTransformation.numberFromString)
* )
* Schema.decodeSync(schema)("42") // => 42
* ```
*
* @see {@link bigintFromString}
* @see {@link transform}
*
* @stability stable
* @category converting
* @since 4.0.0
*/
const numberFromString = /*#__PURE__*/ new Transformation(/*#__PURE__*/ Number$3(), /*#__PURE__*/ String$3());
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/SchemaAST.js
/**
* Represents Effect schemas as runtime trees.
*
* Every `Schema` has an AST made from nodes for declarations, primitives,
* literals, arrays, objects, unions, suspended schemas, checks, annotations,
* encoding links, and parsing context. Most users work with the higher-level
* `Schema` module. Use `SchemaAST` when you need to inspect schema nodes, build
* ASTs programmatically, change encoded or decoded views, collect issues, or
* run low-level schema checks.
*
* @stability stable
* @since 4.0.0
*/
function makeGuard(tag) {
return (ast) => ast._tag === tag;
}
/**
* Narrows an {@link AST} to {@link Declaration}.
*
* **When to use**
*
* Use to recognize declaration AST nodes before running declaration-specific
* handling.
*
* @see {@link Declaration} for the AST node type narrowed by this guard
*
* @stability stable
* @category guards
* @since 3.10.0
*/
const isDeclaration = /*#__PURE__*/ makeGuard("Declaration");
/**
* Narrows an {@link AST} to {@link Never}.
*
* **When to use**
*
* Use to detect the AST node for a schema that can never match before handling
* other schema variants.
*
* @see {@link Never} for the AST node type narrowed by this guard
* @see {@link never} for the singleton `Never` AST instance
*
* @stability stable
* @category guards
* @since 4.0.0
*/
const isNever = /*#__PURE__*/ makeGuard("Never");
/**
* Narrows an {@link AST} to {@link Literal}.
*
* **When to use**
*
* Use to recognize exact string, number, boolean, or bigint literal AST nodes.
*
* @see {@link Literal} for the AST node type narrowed by this guard
* @see {@link LiteralValue} for the values stored by literal nodes
*
* @stability stable
* @category guards
* @since 3.10.0
*/
const isLiteral = /*#__PURE__*/ makeGuard("Literal");
/**
* Narrows an {@link AST} to {@link UniqueSymbol}.
*
* @stability stable
* @category guards
* @since 3.10.0
*/
const isUniqueSymbol = /*#__PURE__*/ makeGuard("UniqueSymbol");
/**
* Narrows an {@link AST} to {@link Arrays}.
*
* **When to use**
*
* Use to recognize array-like AST nodes before reading their element, rest, or
* mutability metadata.
*
* @see {@link Arrays} for the AST node type narrowed by this guard
*
* @stability stable
* @category guards
* @since 4.0.0
*/
const isArrays = /*#__PURE__*/ makeGuard("Arrays");
/**
* Narrows an {@link AST} to {@link Objects}.
*
* @stability stable
* @category guards
* @since 4.0.0
*/
const isObjects = /*#__PURE__*/ makeGuard("Objects");
/**
* Narrows an {@link AST} to {@link Suspend}.
*
* @stability stable
* @category guards
* @since 3.10.0
*/
const isSuspend = /*#__PURE__*/ makeGuard("Suspend");
/**
* Constructs a {@link Link}.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const Link = class {
to;
transformation;
constructor(to, transformation) {
this.to = to;
this.transformation = transformation;
}
};
/** @internal */
const defaultParseOptions = {};
/**
* Constructs a {@link Context}.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const Context = class {
isOptional;
isMutable;
/** Used for constructor default values (e.g. `withConstructorDefault` API) */
constructorDefault;
annotations;
constructor(isOptional, isMutable, constructorDefault = void 0, annotations = void 0) {
this.isOptional = isOptional;
this.isMutable = isMutable;
this.constructorDefault = constructorDefault;
this.annotations = annotations;
}
};
const TypeId$3 = "~effect/Schema";
var ASTNodeImpl = class {
[TypeId$3] = TypeId$3;
annotations;
checks;
encoding;
context;
constructor(annotations = void 0, checks = void 0, encoding = void 0, context = void 0) {
this.annotations = annotations;
this.checks = checks;
this.encoding = encoding;
this.context = context;
}
toString() {
return `<${this._tag}>`;
}
};
/**
* Constructs a {@link Declaration}.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const Declaration = class extends ASTNodeImpl {
_tag = "Declaration";
typeParameters;
run;
encodingChecks;
/**
* Parser factory {@link flip} swaps in, so a declaration can behave
* differently when encoding. `undefined` reuses `run`.
*/
encodingRun;
constructor(typeParameters, run, annotations, checks, encoding, context, encodingChecks, encodingRun) {
super(annotations, checks, encoding, context);
this.typeParameters = typeParameters;
this.run = run;
this.encodingChecks = encodingChecks;
this.encodingRun = encodingRun;
}
/** @internal */
getParser() {
let run;
return (input, options) => {
if (input === missing) return missingExit;
return (run ??= this.run(this.typeParameters))(input, this, options);
};
}
_rebuild(recur, checks, encodingChecks, run, encodingRun) {
const tps = mapOrSame(this.typeParameters, recur);
return tps === this.typeParameters && checks === this.checks && encodingChecks === this.encodingChecks && run === this.run && encodingRun === this.encodingRun ? this : new Declaration(tps, run, this.annotations, checks, void 0, this.context, encodingChecks, encodingRun);
}
/** @internal */
recur(recur) {
return this._rebuild(recur, this.checks, this.encodingChecks, this.run, this.encodingRun);
}
/** @internal */
flip(recur) {
return this._rebuild(recur, this.encodingChecks, this.checks, this.encodingRun ?? this.run, this.run);
}
/** @internal */
getExpected() {
const expected = this.annotations?.expected;
if (typeof expected === "string") return expected;
return "<Declaration>";
}
};
/**
* Constructs a {@link Null}.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const Null$1 = class extends ASTNodeImpl {
_tag = "Null";
/** @internal */
getParser() {
return fromConst(this, null);
}
/** @internal */
getExpected() {
return "null";
}
};
const null_ = /*#__PURE__*/ new Null$1();
/**
* Constructs a {@link Unknown}.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const Unknown = class extends ASTNodeImpl {
_tag = "Unknown";
/** @internal */
getParser() {
return fromRefinement(this, isUnknown);
}
/** @internal */
getExpected() {
return "unknown";
}
};
/**
* Provides the singleton {@link Unknown} AST instance.
*
* **When to use**
*
* Use when you need the reusable AST singleton for a schema node that accepts
* every value while keeping parsed values opaque.
*
* @see {@link any} for the singleton that accepts every value as `any`
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const unknown = /*#__PURE__*/ new Unknown();
/**
* Constructs a {@link Literal}.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const Literal$1 = class extends ASTNodeImpl {
_tag = "Literal";
literal;
constructor(literal, annotations, checks, encoding, context) {
super(annotations, checks, encoding, context);
if (typeof literal === "number" && !globalThis.Number.isFinite(literal)) throw new Error(`A numeric literal must be finite, got ${format$1(literal)}`);
this.literal = literal;
}
/** @internal */
getParser() {
return fromConst(this, this.literal);
}
/** @internal */
matchPart(s, _options) {
return s === globalThis.String(this.literal) ? this.literal : void 0;
}
/** @internal */
toCodecJson() {
return typeof this.literal === "bigint" ? literalToString(this) : this;
}
/** @internal */
toCodecStringTree() {
return typeof this.literal === "string" ? this : literalToString(this);
}
/** @internal */
getExpected() {
return typeof this.literal === "string" ? JSON.stringify(this.literal) : globalThis.String(this.literal);
}
};
function literalToString(ast) {
const literalAsString = globalThis.String(ast.literal);
return replaceEncoding(ast, [new Link(new Literal$1(literalAsString), new Transformation(transform$1(() => ast.literal), transform$1(() => literalAsString)))]);
}
/**
* Constructs a {@link String}.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const String$2 = class extends ASTNodeImpl {
_tag = "String";
/** @internal */
getParser() {
return fromRefinement(this, isString$1);
}
/** @internal */
matchPart(s, options) {
const checks = this.checks;
return checks && !options.disableChecks && collectIssues(checks, s, void 0, this, options) ? void 0 : s;
}
/** @internal */
getExpected() {
return "string";
}
};
/**
* Provides the singleton {@link String} AST instance.
*
* **When to use**
*
* Use as the shared `SchemaAST` node for unconstrained JavaScript strings.
*
* @see {@link String} for the AST node class
* @see {@link isString} for narrowing an AST to a string node
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const string = /*#__PURE__*/ new String$2();
/**
* Constructs a {@link Number}.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const Number$2 = class extends ASTNodeImpl {
_tag = "Number";
/** @internal */
getParser() {
return fromRefinement(this, isNumber);
}
/** @internal */
matchKey(s, options) {
return this._match(isStringNumberRegExp, s, options);
}
/** @internal */
matchPart(s, options) {
return this._match(isStringFiniteRegExp, s, options);
}
_match(regexp, s, options) {
if (!regexp.test(s)) return void 0;
const value = globalThis.Number(s);
if (options.disableChecks || !this.checks) return value;
return collectIssues(this.checks, value, void 0, this, options) ? void 0 : value;
}
/** @internal */
toCodecJson() {
if (this.checks && (hasCheck(this.checks, "effect/schema/isFinite") || hasCheck(this.checks, "effect/schema/isInt"))) return this;
return replaceEncoding(this, [numberToJson]);
}
/** @internal */
toCodecStringTree() {
if (this.toCodecJson() === this) return replaceEncoding(this, [finiteToString]);
return replaceEncoding(this, [numberToString]);
}
/** @internal */
getExpected() {
return "number";
}
};
function hasCheck(checks, id) {
return checks.some((check) => check.annotations?.representation?.id === id || check._tag === "FilterGroup" && hasCheck(check.checks, id));
}
/**
* Provides the singleton {@link Number} AST instance.
*
* **When to use**
*
* Use when you need the canonical `SchemaAST` node for schemas that accept any
* JavaScript number value.
*
* @see {@link Number} for the AST node class and serialization behavior
* @see {@link Literal} for exact finite numeric literal AST nodes
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const number = /*#__PURE__*/ new Number$2();
/**
* Constructs a {@link Arrays}.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const Arrays = class extends ASTNodeImpl {
_tag = "Arrays";
isMutable;
elements;
rest;
encodingChecks;
constructor(isMutable, elements, rest, annotations, checks, encoding, context, encodingChecks) {
super(annotations, checks, encoding, context);
this.isMutable = isMutable;
this.elements = elements;
this.rest = rest;
this.encodingChecks = encodingChecks;
let hasOptional = false;
for (let i = 0; i < elements.length; i++) if (isOptional(elements[i])) hasOptional = true;
else if (hasOptional) throw new Error("A required element cannot follow an optional element. ts(1257)");
if (hasOptional && rest.length > 1) throw new Error("A required element cannot follow an optional element. ts(1257)");
for (let i = 1; i < rest.length; i++) if (isOptional(rest[i])) throw new Error("An optional element cannot follow a rest element. ts(1266)");
}
/** @internal */
getParser(compile, compileField = compile) {
const ast = this;
let elements;
let rest;
const elementLen = ast.elements.length;
const tailLen = Math.max(0, ast.rest.length - 1);
function getParser(tailThreshold, index) {
if (index < elementLen) return elements[index];
else if (index >= tailThreshold) return rest[index - tailThreshold + 1];
return rest[0];
}
const finish = (state) => {
const { input, len, options } = state;
if (ast.rest.length === 0 && len > elementLen) for (let i = elementLen; i < len; i++) {
const unexpected = new UnexpectedKey(ast, input[i], options);
const issue = new Pointer([i], unexpected);
if (options.errors === "all") {
if (state.issues) state.issues.push(issue);
else state.issues = [issue];
} else return fail$1(new Composite(ast, [issue], input, options));
}
if (state.issues) return fail$1(new Composite(ast, state.issues, input, options));
return succeed(state.output);
};
const parse = (input, options) => {
const len = input.length;
const state = {
ast,
getParser,
input,
len,
tailThreshold: Math.max(elementLen, len - tailLen),
output: new globalThis.Array(len),
issues: void 0,
options
};
const end = ast.rest.length === 0 ? elementLen : Math.max(len, elementLen + tailLen);
const concurrency = options.concurrency === void 0 ? 1 : resolveConcurrency(options.concurrency);
const eff = concurrency === 1 ? parseArray(state, input, 0, end) : parseArrayConcurrent(state, input, {
concurrency,
end
});
if (!eff) return finish(state);
if (effectIsExit(eff)) return flatMapEager(eff, () => finish(state));
let first = true;
return suspend(() => {
if (!first) return parse(input, options);
first = false;
return flatMap(eff, () => finish(state));
});
};
return (input, options) => {
if (input === missing) return missingExit;
try {
if (!Array.isArray(input)) return fail$1(new InvalidType(ast, input, options));
if (!elements) {
elements = ast.elements.map((ast) => ({
ast,
parser: compileField(ast)
}));
rest = ast.rest.map((ast) => ({
ast,
parser: compileField(ast)
}));
}
return parse(input, options);
} catch (error) {
return die(error);
}
};
}
_rebuild(recur, checks, encodingChecks) {
const elements = mapOrSame(this.elements, recur);
const rest = mapOrSame(this.rest, recur);
return elements === this.elements && rest === this.rest && checks === this.checks && encodingChecks === this.encodingChecks ? this : new Arrays(this.isMutable, elements, rest, this.annotations, checks, void 0, this.context, encodingChecks);
}
/** @internal */
recur(recur) {
return this._rebuild(recur, this.checks, this.encodingChecks);
}
/** @internal */
flip(recur) {
return this._rebuild(recur, this.encodingChecks, this.checks);
}
/** @internal */
getExpected() {
return "array";
}
};
/** @internal */
function stepArray(s, item, exit, i) {
if (exit._tag === "Failure") return wrapPropertyKeyIssue(s, s.ast, i, exit);
const value = exit === sameExit ? item : exit[args];
if (value !== missing) s.output[i] = value;
else {
const p = s.getParser(s.tailThreshold, i);
if (isOptional(p.ast)) return;
const issue = new Pointer([i], new MissingKey(p.ast.context?.annotations));
if (s.options.errors === "all") {
if (s.issues) s.issues.push(issue);
else s.issues = [issue];
} else return fail$2(new Composite(s.ast, [issue], s.input, s.options));
}
}
const parseArrayOptions = {
onItem(s, item, i) {
const value = i < s.len ? item : missing;
return s.getParser(s.tailThreshold, i).parser(value, s.options);
},
step: stepArray
};
/** @internal */
const parseArray = /*#__PURE__*/ iterateEager()(parseArrayOptions);
const parseArrayConcurrent = /*#__PURE__*/ iterateConcurrent()(parseArrayOptions);
const wrapPropertyKeyIssue = (s, ast, key, exit) => {
if (exit.cause.reasons.length === 0) return exit;
const issue = getSchemaIssue(exit.cause);
if (issue === void 0) return failCause(map(exit.cause, (issue) => new Composite(ast, [new Pointer([key], issue)], s.input, s.options)));
const pointer = new Pointer([key], issue);
if (s.options.errors === "all") {
if (s.issues) s.issues.push(pointer);
else s.issues = [pointer];
} else return fail$2(new Composite(ast, [pointer], s.input, s.options));
};
/**
* floating point or integer, with optional exponent
* @internal
*/
const FINITE_PATTERN = "[+-]?\\d*\\.?\\d+(?:[Ee][+-]?\\d+)?";
/**
* Returns the object keys that match the index signature parameter schema.
* @internal
*/
function getIndexSignatureKeys(input, parameter, options = defaultParseOptions) {
let stringKeys;
let symbolKeys;
function go(parameter) {
switch (parameter._tag) {
case "String":
case "TemplateLiteral": return (stringKeys ??= Object.keys(input)).filter((k) => parameter.matchPart(k, options) !== void 0);
case "Number": return (stringKeys ??= Object.keys(input)).filter((k) => parameter.matchKey(k, options) !== void 0);
case "Symbol": return (symbolKeys ??= Object.getOwnPropertySymbols(input)).filter((k) => Object.prototype.propertyIsEnumerable.call(input, k) && parameter.matchKey(k, options) !== void 0);
case "Union": return [...new Set(parameter.types.flatMap(go))];
default: return [];
}
}
return go(parameterFromPropertyKey(toEncoded(parameter)));
}
/**
* Constructs a {@link PropertySignature}.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const PropertySignature = class {
name;
type;
constructor(name, type) {
this.name = name;
this.type = type;
}
};
function isIndexSignatureParameterSide(ast) {
switch (ast._tag) {
case "String":
case "Number":
case "Symbol":
case "TemplateLiteral": return true;
case "Union": return ast.types.every(isIndexSignatureParameterSide);
default: return false;
}
}
function isIndexSignatureParameterEncodedSide(ast) {
const encoded = getLastEncoding(ast);
switch (encoded._tag) {
case "String":
case "Number":
case "Symbol":
case "TemplateLiteral": return true;
case "Union": return encoded.types.every(isIndexSignatureParameterEncodedSide);
default: return false;
}
}
function isIndexSignatureParameter(ast) {
return isIndexSignatureParameterSide(ast) && isIndexSignatureParameterEncodedSide(ast);
}
/**
* Constructs a {@link IndexSignature}.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const IndexSignature = class {
parameter;
type;
constructor(parameter, type) {
if (!isIndexSignatureParameter(parameter)) throw new Error(`Invalid index signature parameter ${parameter._tag}`);
this.parameter = parameter;
this.type = type;
if (isOptional(type) && !containsUndefined(type)) throw new Error("Cannot use `Schema.optionalKey` with index signatures, use `Schema.optional` instead.");
}
};
/**
* Constructs a {@link Objects}.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const Objects = class extends ASTNodeImpl {
_tag = "Objects";
propertySignatures;
indexSignatures;
encodingChecks;
constructor(propertySignatures, indexSignatures, annotations, checks, encoding, context, encodingChecks) {
super(annotations, checks, encoding, context);
this.propertySignatures = propertySignatures;
this.indexSignatures = indexSignatures;
this.encodingChecks = encodingChecks;
}
/** @internal */
getParser(compile, compileField = compile) {
const ast = this;
const hasProperties = ast.propertySignatures.length;
const indexCount = ast.indexSignatures.length;
if (!hasProperties && !indexCount) return fromRefinement(ast, isNotNullish);
let properties;
let indexes;
const compileMembers = () => {
if (!properties) {
properties = ast.propertySignatures.map((ps) => ({
parser: compileField(ps.type),
name: ps.name,
type: ps.type
}));
indexes = indexCount ? ast.indexSignatures.map((is) => ({
is,
parserKey: compile(parameterFromPropertyKey(is.parameter)),
parserValue: compileField(is.type)
})) : void 0;
}
return properties;
};
const makeFallback = () => {
const expectedKeys = new Set(ast.propertySignatures.map((ps) => typeof ps.name === "number" ? globalThis.String(ps.name) : ps.name));
const finishIndex = (s, key, k2, inputValue, exitValue) => {
if (exitValue._tag === "Failure") return wrapPropertyKeyIssue(s, ast, key, exitValue) ?? void_;
const value = exitValue === sameExit ? inputValue : exitValue[args];
if (k2 !== missing && value !== missing) {
if (hasProperties && (expectedKeys.has(key) || expectedKeys.has(typeof k2 === "number" ? globalThis.String(k2) : k2))) return void_;
assignProperty(s.out, k2, value);
}
return void_;
};
const parseIndex = (s, key, index, exitKey) => {
if (!exitKey) {
const eff = index.parserKey(key, s.options);
if (!effectIsExit(eff)) return flatMap(exit(eff), (exit) => parseIndex(s, key, index, exit));
exitKey = eff;
}
if (exitKey._tag === "Failure") return wrapPropertyKeyIssue(s, ast, key, exitKey) ?? void_;
const k2 = exitKey === sameExit ? key : exitKey[args];
const inputValue = s.input[key];
const result = index.parserValue(inputValue, s.options);
return effectIsExit(result) ? finishIndex(s, key, k2, inputValue, result) : flatMap(exit(result), (exit) => finishIndex(s, key, k2, inputValue, exit));
};
const parseStringIndex = (s, key, index) => {
const inputValue = s.input[key];
const result = index.parserValue(inputValue, s.options);
return effectIsExit(result) ? finishIndex(s, key, key, inputValue, result) : flatMap(exit(result), (exit) => finishIndex(s, key, key, inputValue, exit));
};
const parseIndexes = indexCount ? iterateConcurrent()({
onItem: (s, [key, index]) => index.is.parameter === string ? parseStringIndex(s, key, index) : parseIndex(s, key, index),
step: (_s, _item, exit) => exit._tag === "Failure" ? exit : void 0
}) : void 0;
return fnUntracedEager(function* (input, options) {
if (input === missing) return missing;
if (!(typeof input === "object" && input !== null && !Array.isArray(input))) return yield* fail$1(new InvalidType(ast, input, options));
compileMembers();
const record = input;
const out = {};
const state = {
ast,
input: record,
out,
issues: void 0,
options
};
const errorsAllOption = options.errors === "all";
const onExcessPropertyError = options.onExcessProperty === "error";
const concurrency = options.concurrency === void 0 ? 1 : resolveConcurrency(options.concurrency);
const indexKeys = indexCount && onExcessPropertyError ? ast.indexSignatures.map((index) => getIndexSignatureKeys(record, index.parameter, options)) : void 0;
if (onExcessPropertyError) {
const coveredKeys = indexKeys ? new Set(expectedKeys) : expectedKeys;
if (indexKeys) for (const keys of indexKeys) for (const key of keys) coveredKeys.add(key);
const inputKeys = Reflect.ownKeys(record);
for (let i = 0; i < inputKeys.length; i++) {
const key = inputKeys[i];
if (!coveredKeys.has(key) && Object.prototype.propertyIsEnumerable.call(record, key)) {
const unexpected = new UnexpectedKey(ast, record[key], options);
const issue = new Pointer([key], unexpected);
if (errorsAllOption) {
if (state.issues) state.issues.push(issue);
else state.issues = [issue];
continue;
} else return yield* fail$1(new Composite(ast, [issue], input, options));
}
}
}
if (hasProperties) {
const eff = concurrency === 1 ? parseProperties(state, properties) : parsePropertiesConcurrent(state, properties, { concurrency });
if (eff) yield* eff;
}
if (indexCount && concurrency === 1) for (let i = 0; i < indexCount; i++) {
const index = indexes[i];
const parse = index.is.parameter === string ? parseStringIndex : parseIndex;
const keys = indexKeys?.[i] ?? (index.is.parameter === string ? Object.keys(record) : getIndexSignatureKeys(record, index.is.parameter, options));
for (let j = 0; j < keys.length; j++) {
const eff = parse(state, keys[j], index);
if (!effectIsExit(eff)) yield* eff;
else if (eff._tag === "Failure") return yield* eff;
}
}
else if (parseIndexes) {
const keyPairs = empty$1();
for (let i = 0; i < indexCount; i++) {
const index = indexes[i];
const keys = indexKeys?.[i] ?? (index.is.parameter === string ? Object.keys(record) : getIndexSignatureKeys(record, index.is.parameter, options));
for (let j = 0; j < keys.length; j++) keyPairs.push([keys[j], index]);
}
const eff = parseIndexes(state, keyPairs, { concurrency });
if (eff) yield* eff;
}
if (state.issues) return yield* fail$1(new Composite(ast, state.issues, input, options));
return out;
});
};
if (indexCount) return makeFallback();
let fallback;
const resume = (state, index, pending) => {
const property = properties[index];
return flatMap(exit(pending), (exit) => {
const terminal = stepProperty(state, property, exit);
if (terminal) return terminal;
const done = () => succeed(state.out);
const eff = parseProperties(state, properties.slice(index + 1));
return eff ? flatMapEager(eff, done) : done();
});
};
return (input, options) => {
if (input === missing) return missingExit;
if (options.errors === "all" || options.onExcessProperty !== void 0 || options.concurrency !== void 0 && resolveConcurrency(options.concurrency) !== 1) return (fallback ??= makeFallback())(input, options);
if (!(typeof input === "object" && input !== null && !Array.isArray(input))) return fail$1(new InvalidType(ast, input, options));
const props = compileMembers();
const record = input;
const out = {};
const state = {
ast,
input: record,
out,
issues: void 0,
options
};
try {
for (let index = 0; index < props.length; index++) {
const property = props[index];
const name = property.name;
const hasKey = hasPropertySignature(record, name);
const value = hasKey ? record[name] : missing;
const exit = property.parser(value, options);
if (!effectIsExit(exit)) return resume(state, index, exit);
if (exit === sameExit) {
if (hasKey) assignProperty(out, name, value);
continue;
}
const terminal = stepProperty(state, property, exit);
if (terminal) return terminal;
}
} catch (error) {
return die(error);
}
return succeed(out);
};
}
_rebuild(recur, recurParameter, checks, encodingChecks) {
const props = mapOrSame(this.propertySignatures, (ps) => {
const t = recur(ps.type);
return t === ps.type ? ps : new PropertySignature(ps.name, t);
});
const indexes = mapOrSame(this.indexSignatures, (is) => {
const p = recurParameter(is.parameter);
const t = recur(is.type);
return p === is.parameter && t === is.type ? is : new IndexSignature(p, t);
});
return props === this.propertySignatures && indexes === this.indexSignatures && checks === this.checks && encodingChecks === this.encodingChecks ? this : new Objects(props, indexes, this.annotations, checks, void 0, this.context, encodingChecks);
}
/** @internal */
flip(recur) {
return this._rebuild(recur, recur, this.encodingChecks, this.checks);
}
/** @internal */
recur(recur, recurParameter = recur) {
return this._rebuild(recur, recurParameter, this.checks, this.encodingChecks);
}
/** @internal */
getExpected() {
if (this.propertySignatures.length === 0 && this.indexSignatures.length === 0) return "object | array";
return "object";
}
};
/** @internal */
function stepProperty(s, p, exit) {
if (exit._tag === "Failure") return wrapPropertyKeyIssue(s, s.ast, p.name, exit);
if (exit === sameExit) return;
const value = exit[args];
if (value !== missing) {
assignProperty(s.out, p.name, value);
return;
}
delete s.out[p.name];
if (!isOptional(p.type)) {
const issue = new Pointer([p.name], new MissingKey(p.type.context?.annotations));
if (s.options.errors === "all") {
if (s.issues) s.issues.push(issue);
else s.issues = [issue];
return;
} else return fail$2(new Composite(s.ast, [issue], s.input, s.options));
}
}
const parsePropertiesOptions = {
onItem(s, p) {
if (!hasPropertySignature(s.input, p.name)) return p.parser(missing, s.options);
const value = s.input[p.name];
assignProperty(s.out, p.name, value);
return p.parser(value, s.options);
},
step: stepProperty
};
/** @internal */
const parseProperties = /*#__PURE__*/ iterateEager()(parsePropertiesOptions);
const parsePropertiesConcurrent = /*#__PURE__*/ iterateConcurrent()(parsePropertiesOptions);
function combineChecks(a, b) {
if (!a) return b;
if (!b) return a;
return [...a, ...b];
}
/** @internal */
function struct(fields, checks, annotations) {
return new Objects(Reflect.ownKeys(fields).map((key) => {
return new PropertySignature(key, fields[key].ast);
}), [], annotations, checks);
}
/** @internal */
function getAST(self) {
return self.ast;
}
/** @internal */
function union(members, options, checks) {
return new Union$1(members.map(getAST), options, void 0, checks);
}
/** @internal */
function mutable$1(ast) {
if (ast.encoding) throw new Error("mutable does not support encodings");
return new Arrays(true, ast.elements, ast.rest, ast.annotations, ast.checks, void 0, ast.context, ast.encodingChecks);
}
const toCandidate = /*#__PURE__*/ memoizeIdempotent((ast) => {
while (true) {
if (isSuspend(ast)) return unknown;
const encoding = ast.encoding;
if (!encoding) return ast.recur?.(toCandidate, identity) ?? ast;
if (encoding.some((link) => link.transformation._tag === "Middleware" && link.transformation.decode !== identity)) return unknown;
ast = encoding[encoding.length - 1].to;
}
});
function getCandidateTypes(ast) {
switch (ast._tag) {
case "Null": return ["null"];
case "Undefined": return ["undefined"];
case "String":
case "TemplateLiteral": return ["string"];
case "Number": return ["number"];
case "Boolean": return ["boolean"];
case "Symbol":
case "UniqueSymbol": return ["symbol"];
case "BigInt": return ["bigint"];
case "Arrays": return ["array"];
case "ObjectKeyword": return [
"object",
"array",
"function"
];
case "Objects": return ast.propertySignatures.length || ast.indexSignatures.length ? ["object"] : [
"string",
"number",
"boolean",
"symbol",
"bigint",
"object",
"array",
"function"
];
case "Enum": return Array.from(new Set(ast.enums.map(([, v]) => typeof v)));
case "Literal": return [typeof ast.literal];
case "Union": return Array.from(new Set(ast.types.flatMap(getCandidateTypes)));
default: return [
"null",
"undefined",
"string",
"number",
"boolean",
"symbol",
"bigint",
"object",
"array",
"function"
];
}
}
/** @internal */
function collectSentinels(ast) {
switch (ast._tag) {
default: return [];
case "Declaration": {
const s = ast.annotations?.[SENTINELS_ANNOTATION_KEY];
return Array.isArray(s) ? s : [];
}
case "Objects": return ast.propertySignatures.flatMap((ps) => {
const type = ps.type;
if (!isOptional(type)) {
if (isLiteral(type)) return [{
key: ps.name,
literal: type.literal
}];
if (isUniqueSymbol(type)) return [{
key: ps.name,
literal: type.symbol
}];
}
return [];
});
case "Arrays": return ast.elements.flatMap((e, i) => {
if (!isOptional(e)) {
if (isLiteral(e)) return [{
key: i,
literal: e.literal
}];
if (isUniqueSymbol(e)) return [{
key: i,
literal: e.symbol
}];
}
return [];
});
case "Union": {
if (ast.types.length === 0) return [];
const members = ast.types.map((type) => collectSentinels(toCandidate(type)));
return members[0].filter((s) => members.every((sentinels) => sentinels.some((o) => o.key === s.key && o.literal === s.literal)));
}
case "Suspend": return collectSentinels(ast.thunk());
}
}
const candidateIndexCache = /*#__PURE__*/ new WeakMap();
const emptyCandidates = /*#__PURE__*/ Object.freeze([]);
const getRuntimeType = (input) => input === null ? "null" : Array.isArray(input) ? "array" : typeof input;
const hasPropertySignature = (input, key) => key === "__proto__" ? Object.hasOwn(input, key) : key in input;
/** @internal */
function getCandidateIndex(types) {
let index = candidateIndexCache.get(types);
if (index) return index;
let bySentinel;
let sentinelCandidateCount = 0;
let otherwise;
let literalCandidates;
let onlyLiterals = true;
const literalOf = [];
for (let i = 0; i < types.length; i++) {
const a = types[i];
const encoded = toCandidate(a);
if (isNever(encoded)) continue;
if (isLiteral(encoded) || isUniqueSymbol(encoded)) {
literalCandidates ??= /* @__PURE__ */ new Map();
const literal = isLiteral(encoded) ? encoded.literal : encoded.symbol;
literalOf[i] = literal;
let arr = literalCandidates.get(literal);
if (!arr) literalCandidates.set(literal, arr = []);
arr.push(i);
} else onlyLiterals = false;
const sentinels = collectSentinels(encoded);
if (sentinels.length) {
bySentinel ??= /* @__PURE__ */ new Map();
sentinelCandidateCount++;
for (const { key, literal } of sentinels) {
let entry = bySentinel.get(key);
if (!entry) bySentinel.set(key, entry = [/* @__PURE__ */ new Map(), /* @__PURE__ */ new Set()]);
entry[1].add(i);
let indexes = entry[0].get(literal);
if (!indexes) entry[0].set(literal, indexes = /* @__PURE__ */ new Set());
indexes.add(i);
}
} else {
otherwise ??= {};
const candidateTypes = getCandidateTypes(encoded);
for (const t of candidateTypes) (otherwise[t] ??= []).push(i);
}
}
const fallbacks = {};
const getFallback = (type) => fallbacks[type] ??= Object.freeze(otherwise?.[type] ?? emptyCandidates);
if (onlyLiterals && literalCandidates) {
literalCandidates.forEach(Object.freeze);
index = (input) => literalCandidates.get(input) ?? emptyCandidates;
} else if (bySentinel?.size === 1 && !otherwise) {
const [key, [byValue]] = bySentinel.entries().next().value;
const candidates = /* @__PURE__ */ new Map();
for (const [literal, indexes] of byValue) candidates.set(literal, Object.freeze(Array.from(indexes)));
const all = Object.freeze(types.map((_, i) => i));
index = (input, isConstructor) => {
if (isObjectKeyword(input)) {
const value = hasPropertySignature(input, key) ? input[key] : void 0;
if (value !== void 0) return candidates.get(value) ?? emptyCandidates;
if (isConstructor) return all;
}
return emptyCandidates;
};
} else if (bySentinel) {
let commonSentinel;
for (const entry of bySentinel) if ((!commonSentinel || entry[1][0].size > commonSentinel[1][0].size) && entry[1][1].size === sentinelCandidateCount) commonSentinel = entry;
index = (input, isConstructor) => {
const runtimeType = getRuntimeType(input);
if (!isObjectKeyword(input)) return getFallback(runtimeType);
const selected = new Set(otherwise?.[runtimeType]);
let directKey;
if (commonSentinel) {
const [key, [byValue]] = commonSentinel;
const hasKey = hasPropertySignature(input, key);
const value = hasKey ? input[key] : void 0;
if (hasKey && (!isConstructor || value !== void 0)) {
const match = byValue.get(value);
if (!match) return getFallback(runtimeType);
for (const i of match) selected.add(i);
directKey = key;
}
}
if (directKey === void 0) for (const [key, [byValue, all]] of bySentinel) {
const hasKey = hasPropertySignature(input, key);
const value = hasKey ? input[key] : void 0;
if (hasKey && (!isConstructor || value !== void 0)) {
const match = byValue.get(value);
if (match) for (const i of match) selected.add(i);
} else if (isConstructor) for (const i of all) selected.add(i);
}
for (const [key, [byValue, all]] of bySentinel) {
if (key === directKey) continue;
const hasKey = hasPropertySignature(input, key);
const value = hasKey ? input[key] : void 0;
if (hasKey && (!isConstructor || value !== void 0)) {
const match = byValue.get(value);
for (const i of selected) if (all.has(i) && !match?.has(i)) selected.delete(i);
}
}
return Array.from(selected).sort((a, b) => a - b);
};
} else index = (input) => {
const fallback = getFallback(getRuntimeType(input));
return literalCandidates ? fallback.filter((i) => literalOf[i] === void 0 || literalOf[i] === input) : fallback;
};
candidateIndexCache.set(types, index);
return index;
}
/**
* Constructs a {@link Union}.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const Union$1 = class extends ASTNodeImpl {
_tag = "Union";
types;
options;
encodingChecks;
constructor(types, options, annotations, checks, encoding, context, encodingChecks) {
super(annotations, checks, encoding, context);
this.types = types;
this.options = options;
this.encodingChecks = encodingChecks;
}
/** @internal */
getParser(compile, compileField) {
const ast = this;
const isConstructor = compileField !== void 0;
const parsers = [];
const parser = (i) => parsers[i] ??= compile(ast.types[i]);
let index;
return (input, options) => {
if (input === missing) return missingExit;
const candidates = (index ??= getCandidateIndex(ast.types))(input, isConstructor);
if (candidates.length === 0) return fail$1(new AnyOf(ast, [], input, options));
if (candidates.length === 1) {
const result = parser(candidates[0])(input, options);
if (result._tag === "Success") return result;
return effectIsExit(result) ? failSingleUnionCandidate(ast, result.cause, input, options) : catchSingleUnionCandidate(ast, result, input, options);
}
return parseUnionCandidates(ast, parser, candidates, input, options);
};
}
_rebuild(recur, checks, encodingChecks) {
const types = mapOrSame(this.types, recur);
return types === this.types && checks === this.checks && encodingChecks === this.encodingChecks ? this : new Union$1(types, this.options, this.annotations, checks, void 0, this.context, encodingChecks);
}
/** @internal */
recur(recur) {
return this._rebuild(recur, this.checks, this.encodingChecks);
}
/** @internal */
flip(recur) {
return this._rebuild(recur, this.encodingChecks, this.checks);
}
/** @internal */
matchPart(s, options) {
for (const type of this.types) {
const out = type.matchPart(s, options);
if (out !== void 0) return out;
}
}
/** @internal */
getExpected(getExpected) {
const expected = this.annotations?.expected;
if (typeof expected === "string") return expected;
if (this.types.length === 0) return "never";
const types = this.types.map((type) => {
const encoded = toEncoded(type);
switch (encoded._tag) {
case "Arrays": {
const literals = encoded.elements.filter(isLiteral);
if (literals.length > 0) return `${formatIsMutable(encoded.isMutable)}[ ${literals.map((e) => getExpected(e) + formatIsOptional(e.context?.isOptional)).join(", ")}, ... ]`;
break;
}
case "Objects": {
const literals = encoded.propertySignatures.filter((ps) => isLiteral(ps.type));
if (literals.length > 0) return `{ ${literals.map((ps) => `${formatIsMutable(ps.type.context?.isMutable)}${formatPropertyKey(ps.name)}${formatIsOptional(ps.type.context?.isOptional)}: ${getExpected(ps.type)}`).join(", ")}, ... }`;
break;
}
}
return getExpected(encoded);
});
return Array.from(new Set(types)).join(" | ");
}
};
function failSingleUnionCandidate(ast, cause, input, options) {
const issue = getSchemaIssue(cause);
if (!issue) return failCause(cause);
return fail$2(new AnyOf(ast, [issue], input, options));
}
function catchSingleUnionCandidate(ast, result, input, options) {
return catchCause(result, (cause) => failSingleUnionCandidate(ast, cause, input, options));
}
function parseUnionCandidates(ast, parser, candidates, input, options) {
const state = {
ast,
parser,
input,
out: void 0,
successes: ast.options?.mode === "oneOf" ? [] : void 0,
issues: void 0,
options
};
const eff = parseUnion(state, candidates);
if (!eff) {
if (state.out) return state.out;
return fail$1(new AnyOf(ast, state.issues ?? [], input, options));
}
if (effectIsExit(eff)) return resumeUnion(eff, state);
let first = true;
return suspend(() => {
if (!first) return parseUnionCandidates(ast, parser, candidates, input, options);
first = false;
return resumeUnion(eff, state);
});
}
function resumeUnion(eff, state) {
return flatMapEager(eff, (_) => {
if (state.out === sameExit) return succeed$1(state.input);
if (state.out) return state.out;
return fail$1(new AnyOf(state.ast, state.issues ?? [], state.input, state.options));
});
}
const parseUnion = /*#__PURE__*/ iterateEager()({
onItem(s, i) {
return s.parser(i)(s.input, s.options);
},
step(s, i, exit) {
if (exit._tag === "Failure") {
const issue = getSchemaIssue(exit.cause);
if (issue === void 0) return exit;
if (s.issues) s.issues.push(issue);
else s.issues = [issue];
} else {
if (s.out && s.successes) {
s.successes.push(s.ast.types[i]);
return fail$2(new OneOf(s.ast, s.successes, s.input, s.options));
}
s.out = exit;
if (s.successes) s.successes.push(s.ast.types[i]);
else return void_;
}
}
});
const nonFiniteLiterals = /*#__PURE__*/ new Union$1([
/*#__PURE__*/ new Literal$1("Infinity"),
/*#__PURE__*/ new Literal$1("-Infinity"),
/*#__PURE__*/ new Literal$1("NaN")
]);
function formatIsMutable(isMutable) {
return isMutable ? "" : "readonly ";
}
function formatIsOptional(isOptional) {
return isOptional ? "?" : "";
}
/**
* Constructs a {@link Filter}.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const Filter = class extends Class$1 {
_tag = "Filter";
run;
annotations;
/**
* Whether the parsing process should be aborted after this check has failed.
*/
aborted;
constructor(run, annotations = void 0, aborted = false) {
super();
this.run = run;
this.annotations = annotations;
this.aborted = aborted;
}
annotate(annotations) {
return new Filter(this.run, {
...this.annotations,
...annotations
}, this.aborted);
}
abort() {
return new Filter(this.run, this.annotations, true);
}
and(other, annotations) {
return new FilterGroup([this, other], annotations);
}
};
/**
* Constructs a {@link FilterGroup}.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const FilterGroup = class extends Class$1 {
_tag = "FilterGroup";
checks;
annotations;
constructor(checks, annotations = void 0) {
super();
this.checks = checks;
this.annotations = annotations;
}
annotate(annotations) {
return new FilterGroup(this.checks, {
...this.annotations,
...annotations
});
}
and(other, annotations) {
return new FilterGroup([this, other], annotations);
}
};
/** @internal */
function makeFilter$1(filter, annotations, aborted = false) {
return new Filter((input, ast, options) => normalizeFilterOutput(ast, filter(input, ast, options), input, options), annotations, aborted);
}
/** @internal */
function isFinite(annotations) {
return makeFilter$1((n) => globalThis.Number.isFinite(n), {
expected: "a finite number",
representation: {
id: "effect/schema/isFinite",
payload: null
},
toJsonSchema: () => ({ type: "number" }),
toCode: () => ({ runtime: "Schema.isFinite()" }),
arbitraryConstraint: { number: "finite" },
...annotations
});
}
const numberToJson = /*#__PURE__*/ new Link(/*#__PURE__*/ new Union$1([/* @__PURE__ */ appendChecks(number, [/*#__PURE__*/ isFinite()]), nonFiniteLiterals]), /*#__PURE__*/ new Transformation(/*#__PURE__*/ Number$3(), /*#__PURE__*/ transform$1((n) => globalThis.Number.isFinite(n) ? n : globalThis.String(n))));
/**
* Creates a {@link Filter} that validates strings by running `RegExp.test`.
*
* **When to use**
*
* Use when string validation should be represented as a schema `Filter` backed
* by a regular expression.
*
* **Details**
*
* The filter can be used with `Schema.filter` or attached directly to a
* `String` AST node through checks. The regular expression is cloned and its
* `lastIndex` is reset before each test, so global and sticky expressions are
* deterministic and the provided regular expression is not mutated. The
* regular expression source is stored in annotations for serialization and
* arbitrary generation.
*
* **Gotchas**
*
* Arbitrary metadata preserves both `regExp.source` and `regExp.flags`.
* Implementations that cannot consume all flags may still use the source as a
* generation hint because the Schema filter validates every generated value.
* JSON Schema has no way to carry JavaScript regular-expression flags. Unless
* annotations provide `toJsonSchema`, the RegExp constraint is omitted from
* JSON Schema export.
*
* **Example** (Validating an email pattern)
*
* ```ts import.meta.vitest
* import { SchemaAST } from "effect"
*
* const emailFilter = SchemaAST.isPattern(/^[^@]+@[^@]+$/)
* emailFilter.run("alice@example.com", SchemaAST.string, {}) // => undefined
* emailFilter.run("invalid", SchemaAST.string, {})?._tag // => "InvalidValue"
* ```
*
* @see {@link Filter}
* @stability stable
* @category constructors
* @since 4.0.0
*/
function isPattern$1(regExp, annotations) {
const copy = new globalThis.RegExp(regExp);
const payload = {
source: copy.source,
flags: copy.flags
};
return makeFilter$1((s) => {
copy.lastIndex = 0;
return copy.test(s);
}, {
expected: `a string matching the RegExp ${payload.source}`,
representation: {
id: "effect/schema/isPattern",
payload
},
toJsonSchema: () => [{}, true],
arbitraryConstraint: { patterns: [payload] },
...annotations
});
}
const bodyOwners = /*#__PURE__*/ new WeakMap();
function copy(ast, changes) {
const out = Object.assign(Object.create(Object.getPrototypeOf(ast)), ast, changes);
if (Reflect.ownKeys(changes).every((key) => key === "context" || key === "encoding")) bodyOwners.set(out, getContextOwner(ast));
return out;
}
/** @internal */
function getContextOwner(ast) {
const existing = bodyOwners.get(ast);
if (existing !== void 0) return existing;
if (ast.encoding === void 0) return ast;
const owner = Object.assign(Object.create(Object.getPrototypeOf(ast)), ast, { encoding: void 0 });
bodyOwners.set(ast, owner);
return owner;
}
/** @internal */
function replaceEncoding(ast, encoding) {
return ast.encoding === encoding ? ast : copy(ast, { encoding });
}
/** @internal */
function replaceContext(ast, context) {
if (ast.context === context) return ast;
const owner = getContextOwner(ast);
if (owner.context === context && owner.encoding === ast.encoding) return owner;
return copy(ast, { context });
}
/** @internal */
function getLastEncoding(ast) {
return ast.encoding ? getLastEncoding(ast.encoding[ast.encoding.length - 1].to) : ast;
}
/** @internal */
function annotate(ast, annotations) {
if (ast.checks) {
const last = ast.checks[ast.checks.length - 1];
return replaceChecks(ast, append(ast.checks.slice(0, -1), last.annotate(annotations)));
}
return copy(ast, { annotations: {
...ast.annotations,
...annotations
} });
}
/** @internal */
function replaceChecks(ast, checks) {
if (ast._tag === "Suspend" && checks) throw new Error("Cannot add checks to Suspend");
if (ast.checks === checks) return ast;
return copy(ast, { checks });
}
/** @internal */
function appendChecks(ast, checks) {
return replaceChecks(ast, combineChecks(ast.checks, checks));
}
/** @internal */
function mapLink(link, f) {
const to = f(link.to);
return to === link.to ? link : new Link(to, link.transformation);
}
function updateLastLink(encoding, f) {
const links = encoding;
const last = links[links.length - 1];
const out = mapLink(last, f);
return out === last ? encoding : append(encoding.slice(0, encoding.length - 1), out);
}
/** @internal */
function applyToSelfOrLastLinkEncodingIdempotent(f, options) {
function out(ast) {
if (ast.encoding) {
const last = ast.encoding[ast.encoding.length - 1];
return options?.stopAt?.(last) ? ast : replaceEncoding(ast, updateLastLink(ast.encoding, out));
}
return f(ast);
}
return memoizeIdempotent(out);
}
function appendTransformation(from, transformation, to) {
const link = new Link(from, transformation);
return replaceEncoding(to, to.encoding ? [...to.encoding, link] : [link]);
}
function mapOrSame(as, f) {
let out;
for (let i = 0; i < as.length; i++) {
const a = as[i];
const fa = f(a);
if (out) out[i] = fa;
else if (fa !== a) {
out = new Array(as.length);
for (let j = 0; j < i; j++) out[j] = as[j];
out[i] = fa;
}
}
return out ?? as;
}
/** @internal */
function annotateKey(ast, annotations) {
return replaceContext(ast, ast.context ? new Context(ast.context.isOptional, ast.context.isMutable, ast.context.constructorDefault, {
...ast.context.annotations,
...annotations
}) : new Context(false, false, void 0, annotations));
}
/**
* Attaches a `Transformation` to the `to` AST, making it decode from the
* `from` AST and encode back to it.
*
* **Details**
*
* This is the low-level primitive behind `Schema.decodeTo`. It appends a
* {@link Link} to the `to` node's encoding chain.
*
* - Returns a new AST with the same type as `to`.
*
* @see {@link Link}
* @see {@link Encoding}
* @see {@link flip}
* @stability stable
* @category transforming
* @since 4.0.0
*/
function decodeTo$1(from, to, transformation) {
return appendTransformation(from, transformation, to);
}
/**
* Returns `true` if the AST node represents an optional property.
*
* **Details**
*
* Checks `ast.context?.isOptional`. Defaults to `false` when no
* {@link Context} is set.
*
* @see `Schema.optionalKey`
* @see {@link Context}
* @stability stable
* @category predicates
* @since 4.0.0
*/
function isOptional(ast) {
return ast.context?.isOptional ?? false;
}
function isStructuralCheck(check) {
return check.annotations?.["~structural"] === true || check._tag === "FilterGroup" && check.checks.every(isStructuralCheck);
}
function extractStructuralChecks(checks) {
function extract(check) {
if (isStructuralCheck(check)) return [check];
return check._tag === "FilterGroup" ? check.checks.flatMap(extract) : [];
}
const out = checks.flatMap(extract);
return isArrayNonEmpty(out) ? out : void 0;
}
function canPreserveEncodingChecks(ast) {
let preserve = true;
function visit(child) {
preserve = preserve && !child.encoding && !isSuspend(child);
if (preserve && "recur" in child) child.recur(visit);
return child;
}
if ("recur" in ast) ast.recur(visit);
return preserve;
}
/**
* Strips all encoding transformations from an AST, returning the decoded
* (type-level) representation.
*
* **Details**
*
* - Memoized: same input reference → same output reference.
* - Recursively walks into composite nodes ({@link Arrays}, {@link Objects},
* {@link Union}, {@link Suspend}).
*
* **Example** (Getting the type AST)
*
* ```ts import.meta.vitest
* import { Schema, SchemaAST } from "effect"
*
* const schema = Schema.NumberFromString
* const typeAst = SchemaAST.toType(schema.ast)
* typeAst._tag // => "Number"
* ```
*
* @see {@link toEncoded}
* @see {@link flip}
* @stability stable
* @category transforming
* @since 4.0.0
*/
const toType = /*#__PURE__*/ memoizeIdempotent((ast) => {
const owner = getContextOwner(ast);
if (owner !== ast) {
const type = toType(owner);
return type === owner && ast.encoding === void 0 ? ast : replaceContext(type, ast.context);
}
const type = "recur" in ast ? ast.recur(toType) : ast;
if ("encodingChecks" in type && type.encodingChecks) {
const checks = canPreserveEncodingChecks(ast) ? type.encodingChecks : isArrays(type) || isObjects(type) || isDeclaration(type) && type.typeParameters.length > 0 ? extractStructuralChecks(type.encodingChecks) : void 0;
return copy(type, {
encodingChecks: void 0,
checks: combineChecks(type.checks, checks)
});
}
return type;
});
/**
* Returns the encoded (wire-format) AST by flipping and then stripping
* encodings.
*
* **Details**
*
* Equivalent to `toType(flip(ast))`. This gives you the AST that describes
* the shape of the serialized/encoded data.
*
* - Memoized: same input reference → same output reference.
*
* **Example** (Getting the encoded AST)
*
* ```ts import.meta.vitest
* import { Schema, SchemaAST } from "effect"
*
* const schema = Schema.NumberFromString
* const encodedAst = SchemaAST.toEncoded(schema.ast)
* encodedAst._tag // => "String"
* ```
*
* @see {@link toType}
* @see {@link flip}
* @stability stable
* @category transforming
* @since 4.0.0
*/
const toEncoded = /*#__PURE__*/ memoizeIdempotent((ast) => {
return toType(flip(ast));
});
function flipEncoding(ast, encoding) {
const links = encoding;
const len = links.length;
const last = links[len - 1];
const ls = [new Link(flip(replaceEncoding(ast, void 0)), links[0].transformation.flip())];
for (let i = 1; i < len; i++) ls.unshift(new Link(flip(links[i - 1].to), links[i].transformation.flip()));
const to = flip(last.to);
if (to.encoding) return replaceEncoding(to, [...to.encoding, ...ls]);
else return replaceEncoding(to, ls);
}
/**
* Swaps the decode and encode directions of an AST's {@link Encoding} chain.
*
* **Details**
*
* After flipping, what was decoding becomes encoding and vice versa. This is
* the core operation behind `Schema.encode` — encoding a value is decoding
* with a flipped SchemaAST.
*
* - Memoized: same input reference → same output reference.
* - Recursively walks composite nodes.
*
* @see {@link toType}
* @see {@link toEncoded}
* @stability stable
* @category transforming
* @since 4.0.0
*/
const flip = /*#__PURE__*/ memoize((ast) => {
if (ast.encoding) return flipEncoding(ast, ast.encoding);
const owner = getContextOwner(ast);
if (owner !== ast) {
const flipped = flip(owner);
return flipped === owner ? ast : replaceContext(flipped, ast.context);
}
return "flip" in ast ? ast.flip(flip) : "recur" in ast ? ast.recur(flip) : ast;
});
/** @internal */
function containsUndefined(ast) {
switch (ast._tag) {
case "Undefined": return true;
case "Union": return ast.types.some(containsUndefined);
default: return false;
}
}
function fromConst(ast, value) {
const succeed$6 = value === 0 ? sameExit : succeed(value);
return (input, options) => {
if (input === missing) return missingExit;
if (input === value) return succeed$6;
return fail$1(new InvalidType(ast, input, options));
};
}
function fromRefinement(ast, refinement) {
return (input, options) => {
if (input === missing) return missingExit;
if (refinement(input)) return sameExit;
return fail$1(new InvalidType(ast, input, options));
};
}
/** @internal */
const parameterFromPropertyKey = /*#__PURE__*/ applyToSelfOrLastLinkEncodingIdempotent((ast) => {
switch (ast._tag) {
default: return ast;
case "Number": return ast.toCodecStringTree();
case "Union": return ast.recur(parameterFromPropertyKey);
}
});
const isStringFiniteRegExp = /*#__PURE__*/ new globalThis.RegExp(`^${FINITE_PATTERN}$`);
const isStringNumberRegExp = /*#__PURE__*/ new globalThis.RegExp(`^(?:${FINITE_PATTERN}|Infinity|-Infinity|NaN)$`);
/** @internal */
function isStringFinite(annotations) {
return isPattern$1(isStringFiniteRegExp, {
expected: "a string representing a finite number",
representation: {
id: "effect/schema/isStringFinite",
payload: null
},
toJsonSchema: () => ({ pattern: isStringFiniteRegExp.source }),
...annotations
});
}
const finiteString = /*#__PURE__*/ appendChecks(string, [/*#__PURE__*/ isStringFinite()]);
const finiteToString = /*#__PURE__*/ new Link(finiteString, numberFromString);
const numberToString = /*#__PURE__*/ new Link(/*#__PURE__*/ new Union$1([finiteString, nonFiniteLiterals]), numberFromString);
/** @internal */
function collectIssues(checks, value, issues, ast, options) {
for (let i = 0; i < checks.length; i++) {
const check = checks[i];
if (check._tag === "FilterGroup") {
issues = collectIssues(check.checks, value, issues, ast, options);
if (issues && (options.errors !== "all" || issues[issues.length - 1].filter.aborted)) return issues;
} else {
const issue = check.run(value, ast, options);
if (issue) {
const filter = new Filter$1(check, issue, value, options);
if (issues) issues.push(filter);
else issues = [filter];
if (options.errors !== "all" || check.aborted) return issues;
}
}
}
return issues;
}
/** @internal */
function getConstructorDescriptor(ast) {
if (!isDeclaration(ast)) return void 0;
const getDescriptor = ast.annotations?.[CONSTRUCTOR_ANNOTATION_KEY];
return isFunction(getDescriptor) ? getDescriptor(ast.typeParameters) : void 0;
}
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/schema/interpreter.js
const flatMapTransformation = (result, current, f) => result === sameExit ? f(current) : flatMapEager(result, f);
function compileTransformation(transformation) {
if (transformation._tag === "Middleware") return (result, current, options) => {
const transformed = result === sameExit ? transformation.decode(succeed(toOption(current)), options) : transformation.decode(mapEager(result, toOption), options);
return fromOptionalEffect(transformed);
};
const getter = transformation.decode;
switch (getter._tag) {
case "Passthrough": return (result, current) => result === sameExit ? succeed(current) : result;
case "Transform": {
const transform = (value) => value === missing ? missingExit : succeed(getter.transform(value));
return (result, current) => flatMapTransformation(result, current, transform);
}
case "TransformOptional": {
const transform = (value) => fromOptionExit(getter.transform(toOption(value)));
return (result, current) => flatMapTransformation(result, current, transform);
}
case "TransformEffect": return (result, current, options) => flatMapTransformation(result, current, (value) => value === missing ? missingExit : getter.transform(value, options));
case "TransformOptionalEffect": return (result, current, options) => flatMapTransformation(result, current, (value) => fromOptionalEffect(getter.transform(toOption(value), options)));
}
}
const fromOptionalEffect = (effect) => flatMapEager(effect, fromOptionExit);
/** @internal */
const wrapEncoding = (ast, input, options, effect) => catchCause(effect, (cause) => failCauseSync(() => map(cause, (issue) => new Encoding(ast, issue, input, options))));
function makeConstructorParser(descriptor, compile) {
const transform = compileTransformation(descriptor.link.transformation);
let sourceParser;
return (input, options) => {
if (input === missing) return missingExit;
if (descriptor.isConstructed(input)) return sameExit;
const result = (sourceParser ??= compile(descriptor.link.to))(input, options);
return transform(result, input, options);
};
}
function withDefault(ast, parser) {
const defaultValue = ast.context.constructorDefault;
return (input, options) => {
if (input !== missing && input !== void 0) return parser(input, options);
const result = defaultValue;
if (effectIsExit(result) && result._tag === "Success") {
const local = parser(result[args], options);
return local === sameExit ? result : local;
}
return flatMapEager(wrapEncoding(ast, input, options, result), (value) => {
const local = parser(value, options);
return local === sameExit ? succeed(value) : local;
});
};
}
/** @internal */
function compileField(ast, compile) {
const parser = compile(ast);
return ast.context?.constructorDefault === void 0 ? parser : withDefault(ast, parser);
}
/** @internal */
function compile(ast, compile, compileField, base, specialize) {
if (ast._tag === "Declaration") for (const parameter of ast.typeParameters) compile(parameter);
const descriptor = compileField ? getConstructorDescriptor(ast) : void 0;
const parser = descriptor ? makeConstructorParser(descriptor, compile) : base ?? ast.getParser(compile, compileField);
const checks = ast.checks;
const links = ast.encoding;
const transformations = links?.map((link) => compileTransformation(link.transformation));
const encodingChecks = ast.encodingChecks;
if (!links && !checks && !encodingChecks) return parser;
let encodingParsers;
const parseChecks = (input, options) => {
let result = parser(input, options);
if (encodingChecks && !options.disableChecks) {
if (effectIsExit(result)) {
if (result._tag === "Success") {
const output = result === sameExit ? input : result[args];
if (input !== missing && output !== missing) {
const issues = collectIssues(encodingChecks, input, void 0, ast, options);
if (issues) result = fail$1(new Composite(ast, issues, input, options));
}
}
} else result = flatMap(result, (value) => {
if (input !== missing && value !== missing) {
const issues = collectIssues(encodingChecks, input, void 0, ast, options);
if (issues) return fail$1(new Composite(ast, issues, input, options));
}
return succeed$1(value);
});
}
if (checks && !options.disableChecks) {
if (effectIsExit(result)) {
if (result._tag === "Success") {
const value = result === sameExit ? input : result[args];
if (value === missing) return result;
const issues = collectIssues(checks, value, void 0, ast, options);
if (issues) result = fail$1(new Composite(ast, issues, value, options));
}
} else result = flatMap(result, (value) => {
if (value !== missing) {
const issues = collectIssues(checks, value, void 0, ast, options);
if (issues) return fail$1(new Composite(ast, issues, value, options));
}
return succeed$1(value);
});
}
return result;
};
const parseLocal = specialize === void 0 ? parseChecks : specialize(parseChecks);
if (!links) return parseLocal;
return (input, options) => {
const parsers = encodingParsers ??= links.map((link) => compile(link.to));
let current = input;
let result = parsers[parsers.length - 1](input, options);
for (let i = links.length - 1; i >= 0; i--) {
result = transformations[i](result, current, options);
if (i !== 0) {
const next = parsers[i - 1];
if (result._tag === "Success") {
current = result[args];
result = next(current, options);
} else result = flatMapEager(result, (value) => {
const nextResult = next(value, options);
return nextResult === sameExit ? succeed(value) : nextResult;
});
}
}
if (result._tag === "Success") {
const value = result[args];
const local = parseLocal(value, options);
return local === sameExit ? result : local;
}
result = wrapEncoding(ast, input, options, result);
return flatMapEager(result, (value) => {
const local = parseLocal(value, options);
return local === sameExit ? succeed(value) : local;
});
};
}
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/schema/compilerRegistry.js
/** @internal */
const invalid = /*#__PURE__*/ Symbol();
const cache = /*#__PURE__*/ new WeakMap();
const decodeChild = (ast) => resolve(ast).parser;
const makeChild = (ast) => resolve(ast).makeEffect;
const makeField = (ast) => compileField(ast, makeChild);
var InterpretedEntry = class {
ast;
constructor(ast) {
this.ast = ast;
}
get decodeEffect() {
return this.cachedDecodeEffect ??= compile(this.ast, decodeChild);
}
get parser() {
return this.decodeEffect;
}
get makeEffect() {
return this.cachedMakeEffect ??= compile(this.ast, makeChild, makeField);
}
};
/** @internal */
function resolve(ast) {
const cached = cache.get(ast);
if (cached !== void 0) return cached;
const entry = new InterpretedEntry(ast);
cache.set(ast, entry);
return entry;
}
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/SchemaParser.js
/**
* Runs schemas against real values.
*
* Schema parsers construct values from schema input, check whether a value
* matches a schema, decode encoded input, and encode decoded values back to
* their external form. This module exposes those operations through several
* result styles, including `Effect`, `Promise`, `Exit`, `Option`, `Result`, and
* synchronous functions that throw. It also contains the lower-level runner that
* walks a schema AST and reports schema failures as `SchemaIssue.Issue` values.
*
* @stability stable
* @since 4.0.0
*/
/**
* Creates an effectful maker for the schema's decoded type side.
*
* **When to use**
*
* Use to construct decoded schema values in `Effect` while preserving
* construction failures as `SchemaIssue.Issue` values in the error channel.
*
* **Details**
*
* The returned function accepts constructor input, applies constructor defaults,
* runs type-side validation unless checks are disabled, and fails with a
* `SchemaIssue.Issue` when construction fails.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
function makeEffect(schema) {
const ast = schema.ast;
let parser;
return (input, options) => {
return (parser ??= runWithCompiler(constructorCompiler, toType(ast)))(input, options?.disableChecks ? options?.parseOptions ? {
...options.parseOptions,
disableChecks: true
} : { disableChecks: true } : options?.parseOptions);
};
}
/**
* Creates a synchronous maker that returns `Option.some` with the constructed
* value on success, or `Option.none` when construction fails with schema issues.
*
* **When to use**
*
* Use when you need to validate schema constructor input and only care whether
* construction succeeds, without exposing `SchemaIssue.Issue` details.
*
* **Gotchas**
*
* Only causes made entirely of schema issues are converted to `Option.none`.
* Causes that contain defects, interruptions, or asynchronous work at this
* synchronous boundary throw an `Error` whose cause is the underlying `Cause`.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
function makeOption(schema) {
const parser = makeEffect(schema);
return (input, options) => {
const exit = runSyncExit(parser(input, options));
if (isSuccess(exit)) return some(exit.value);
getSchemaIssueOrThrow(exit.cause, "Option adapter can only return none for schema issues");
return none();
};
}
/**
* Creates a synchronous maker for the schema's decoded type side.
*
* **When to use**
*
* Use to construct decoded schema values synchronously when invalid input
* should throw an `Error` whose cause is `SchemaIssue.Issue`.
*
* **Details**
*
* The returned function constructs a value from constructor input and throws an
* `Error` with the `SchemaIssue.Issue` in its `cause` when construction fails.
* Schema validation failures use the generic message `"Schema validation failed"`.
* Format the `cause` explicitly with `SchemaIssue.makeFormatterDefault()` when
* human-readable details are needed.
*
* **Gotchas**
*
* Causes that contain defects, interruptions, or asynchronous work at this
* synchronous boundary throw an `Error` whose cause is the underlying `Cause`,
* instead of being converted to a schema validation error.
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
function make$2(schema) {
return makeConstructorSync(toType(schema.ast));
}
/**
* Creates an effectful decoder for `unknown` input.
*
* **When to use**
*
* Use when you need to decode untyped boundary input in an `Effect` whose
* failure channel is `SchemaIssue.Issue`, while preserving transformations
* and service requirements.
*
* **Details**
*
* The returned function succeeds with the schema's decoded `Type` or fails with a
* `SchemaIssue.Issue`. Decoding service requirements are preserved in the returned
* `Effect`. Parse options may be provided when creating the decoder and overridden
* when applying it.
*
* @see {@link decodeEffect} for input already typed as the schema's `Encoded` type
*
* @stability stable
* @category decoding
* @since 4.0.0
*/
function decodeUnknownEffect$1(schema, options) {
const parser = run(schema.ast);
return options === void 0 ? parser : (input, overrideOptions) => parser(input, mergeParseOptions(options, overrideOptions));
}
const mergeParseOptions = (options, overrideOptions) => overrideOptions ? {
...options,
...overrideOptions
} : options;
const getValue = (value) => {
if (value === missing) return fail$1(new InvalidValue());
return succeed$1(value);
};
/** @internal */
function run(ast) {
return runWithCompiler(normalCompiler, ast);
}
function parserResult(result, input) {
if (result === sameExit) return succeed$1(input);
if (!effectIsExit(result)) return flatMapEager(result, getValue);
return result["~effect/Effect/args"] === missing ? getValue(missing) : result;
}
function runWithCompiler(compiler, ast) {
let parser;
return (input, options) => {
const result = (parser ??= compiler(ast))(input, options ?? defaultParseOptions);
if (result === sameExit) return succeed$1(input);
if (!effectIsExit(result)) return flatMapEager(result, getValue);
return result["~effect/Effect/args"] === missing ? getValue(missing) : result;
};
}
function runSync(effect, message) {
const exit = runSyncExit(effect);
if (isSuccess(exit)) return exit.value;
const issue = getSchemaIssueOrThrow(exit.cause, message);
throw new Error("Schema validation failed", { cause: issue });
}
function makeConstructorSync(ast) {
let entry;
let parser;
return (input, options) => {
entry ??= resolve(ast);
const parseOptions = options?.disableChecks ? options.parseOptions ? {
...options.parseOptions,
disableChecks: true
} : { disableChecks: true } : options?.parseOptions ?? defaultParseOptions;
const make = entry.make;
if (make !== void 0 && input !== missing) {
let output;
try {
output = make(input, parseOptions);
} catch (error) {
getSchemaIssueOrThrow(die$1(error), "Constructor adapter can only throw schema issues");
throw error;
}
if (output !== invalid && output !== missing) return output;
}
return runSync(parserResult((parser ??= entry.makeEffect)(input, parseOptions), input), "Constructor adapter can only throw schema issues");
};
}
const normalCompiler = (ast) => resolve(ast).parser;
const constructorCompiler = (ast) => resolve(ast).makeEffect;
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/schema/make.js
/** @internal */
const TypeId$2 = "~effect/Schema/Schema";
const RebuildOptions = /*#__PURE__*/ Symbol();
const SchemaProto = {
[TypeId$2]: TypeId$2,
get make() {
const value = make$2(this);
Object.defineProperty(this, "make", {
value,
enumerable: true
});
return value;
},
get makeEffect() {
const value = makeEffect(this);
Object.defineProperty(this, "makeEffect", {
value,
enumerable: true
});
return value;
},
get makeOption() {
const value = makeOption(this);
Object.defineProperty(this, "makeOption", {
value,
enumerable: true
});
return value;
},
pipe() {
return pipeArguments(this, arguments);
},
annotate(annotations) {
return this.rebuild(annotate(this.ast, annotations));
},
annotateKey(annotations) {
return this.rebuild(annotateKey(this.ast, annotations));
},
check(...checks) {
return this.rebuild(appendChecks(this.ast, checks));
},
rebuild(ast) {
return make$1(ast, this[RebuildOptions]);
}
};
/** @internal */
function make$1(ast, options) {
function Schema() {}
const self = Object.setPrototypeOf(Schema, SchemaProto);
if (options && (Object.hasOwn(options, "name") || Object.hasOwn(options, "length") || Object.hasOwn(options, "__proto__"))) Object.defineProperties(self, Object.getOwnPropertyDescriptors({ ...options }));
else Object.assign(self, options);
self[RebuildOptions] = options;
self.ast = ast;
return self;
}
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Struct.js
/**
* Wraps a plain function as a {@link Lambda} value so it can be used with
* {@link map}, {@link mapPick}, and {@link mapOmit}.
*
* **When to use**
*
* Use to create a typed lambda for struct mapping APIs that need type-level
* input and output tracking.
*
* **Details**
*
* The type parameter `L` encodes both the input and output types at the type
* level, allowing the compiler to track how struct value types change. At
* runtime, the returned value is the same function; `lambda` only adjusts the
* type.
*
* **Example** (Wrapping values in arrays)
*
* ```ts import.meta.vitest
* import { pipe, Struct } from "effect"
*
* interface AsArray extends Struct.Lambda {
* <A>(self: A): Array<A>
* readonly "~lambda.out": Array<this["~lambda.in"]>
* }
*
* const asArray = Struct.lambda<AsArray>((a) => [a])
* const result = pipe({ x: 1, y: "hello" }, Struct.map(asArray))
* result // => { x: [1], y: ["hello"] }
* ```
*
* @see {@link Lambda} – the type-level interface
* @see {@link map} – apply a lambda to all struct values
* @stability stable
* @category constructors
* @since 4.0.0
*/
const lambda = (f) => f;
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/schemaError.js
const SchemaErrorTypeId = "~effect/Schema/SchemaError";
function isSchemaError$1(u) {
return hasProperty(u, "~effect/Schema/SchemaError") && u["~effect/Schema/SchemaError"] === "~effect/Schema/SchemaError";
}
({ ...BaseProto });
({ ...BaseProto });
({ ...BaseProto });
({ ...BaseProto });
({ ...BaseProto });
({ ...BaseProto });
({ ...BaseProto });
({ ...BaseProto });
//#endregion
//#region ../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Schema.js
/**
* Creates a schema for a **parametric** type (a generic container such as
* `Array<A>`, `Option<A>`, etc.) by accepting a list of type-parameter schemas
* and a decoder factory.
*
* **When to use**
*
* Use when you are defining a schema for a generic container whose validation
* depends on one or more type-parameter schemas.
*
* **Details**
*
* The outer call `declareConstructor<T, E, Iso>()` fixes the decoded type `T`,
* the encoded type `E`, and the optional iso type. The inner call receives:
* - `typeParameters` — the concrete schemas for each type variable
* - `run` — a factory that, given resolved codecs for each type parameter,
* returns a parsing function `(u, ast, options) => Effect<T, Issue>`
* - `annotations` — optional metadata
*
* @see {@link declare} for creating schemas for non-parametric types.
*
* **Example** (Schema for a parametric `Box<A>` type)
*
* ```ts import.meta.vitest
* import { Effect, Schema, SchemaIssue, SchemaParser } from "effect"
*
* interface Box<A> {
* readonly value: A
* }
*
* const isBox = (u: unknown): u is Box<unknown> =>
* typeof u === "object" && u !== null && "value" in u
*
* const Box = <A extends Schema.Constraint>(item: A) =>
* Schema.declareConstructor<Box<A["Type"]>, Box<A["Encoded"]>>()(
* [item],
* ([itemCodec]) =>
* (u, ast, options) => {
* if (!isBox(u)) {
* return Effect.fail(new SchemaIssue.InvalidType(ast, u, options))
* }
* return Effect.map(
* SchemaParser.decodeUnknownEffect(itemCodec)(u.value, options),
* (value) => ({ value })
* )
* }
* )
*
* const schema = Box(Schema.Number)
* Effect.runSync(Schema.decodeUnknownEffect(schema)({ value: 1 })) // => { value: 1 }
* ```
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
function declareConstructor() {
return (typeParameters, run, annotations) => {
return make(new Declaration(typeParameters.map(getAST), (typeParameters) => run(typeParameters.map((ast) => make(ast))), annotations));
};
}
/**
* Creates a schema for a **non-parametric** opaque type using a type-guard
* function. The schema accepts any unknown value and succeeds when `is` returns
* `true`, failing with an `InvalidType` issue otherwise.
*
* **When to use**
*
* Use when you are defining a schema for an opaque type with no type parameters
* and validation can be expressed as a type guard.
*
* **Example** (Defining a schema for a custom `UserId` branded type)
*
* ```ts import.meta.vitest
* import { Schema } from "effect"
*
* type UserId = string & { readonly _tag: "UserId" }
*
* const isUserId = (u: unknown): u is UserId =>
* typeof u === "string" && u.startsWith("user_")
*
* const UserId = Schema.declare<UserId>(isUserId, {
* title: "UserId",
* description: "A user identifier starting with 'user_'"
* })
* Schema.decodeUnknownSync(UserId)("user_123") // => "user_123"
* ```
*
* @see {@link declareConstructor} for creating schemas for parametric types.
*
* @stability stable
* @category constructors
* @since 3.10.0
*/
function declare(is, annotations) {
return declareConstructor()([], () => (input, ast, options) => is(input) ? succeed$1(input) : fail$1(new InvalidType(ast, input, options)), annotations);
}
/**
* Error thrown or returned when schema decoding or encoding fails.
*
* **Details**
*
* The `issue` field contains a structured {@link SchemaIssue.Issue} tree describing
* every validation failure, including the path to the problematic value and
* the expected type or constraint. The `message` field renders the issue tree
* with the default formatter.
*
* **Gotchas**
*
* Parsing with `reportInput: true` adds an enumerable `input` field to
* value-bearing issues. Built-in messages may include reported input, and
* custom annotations or messages are not sanitized.
*
* **Example** (Inspecting a SchemaError)
*
* ```ts import.meta.vitest
* import { Result, Schema } from "effect"
*
* const result = Schema.decodeUnknownResult(Schema.Number)("not a number")
* const message = Result.isFailure(result) ? result.failure.message : ""
* message // => "Expected number"
* ```
*
* @see {@link isSchemaError} for narrowing unknown values
* @stability stable
* @category errors
* @since 4.0.0
*/
var SchemaError = class extends (/*#__PURE__*/ TaggedError("SchemaError")) {
[SchemaErrorTypeId] = SchemaErrorTypeId;
constructor(issue) {
const stackTraceLimit = getStackTraceLimit();
setStackTraceLimit(0);
try {
super({ issue });
} finally {
setStackTraceLimit(stackTraceLimit);
}
}
get message() {
return defaultFormatter(this.issue);
}
toJSON() {
return {
_tag: this._tag,
message: this.message
};
}
[NodeInspectSymbol]() {
return this.toJSON();
}
toString() {
return `SchemaError(${this.message})`;
}
};
/**
* Returns `true` if `u` is a {@link SchemaError}.
*
* **When to use**
*
* Use when you need to narrow an unknown value to `SchemaError`.
*
* **Example** (Narrowing Schema errors)
*
* ```ts import.meta.vitest
* import { Result, Schema } from "effect"
*
* const result = Result.try(() => Schema.decodeUnknownSync(Schema.Number)("oops"))
* const error: unknown = Result.isFailure(result) ? result.failure : undefined
* Schema.isSchemaError(error) // => true
* ```
*
* @stability stable
* @category guards
* @since 4.0.0
*/
function isSchemaError(u) {
return isSchemaError$1(u);
}
function fromIssueEffect(self) {
if (effectIsExit(self)) return fromIssueExit(self);
return catchCause(self, (cause) => failCauseSync(() => map(cause, (issue) => new SchemaError(issue))));
}
function fromIssueExit(exit) {
return isSuccess(exit) ? exit : failCause(map(exit.cause, (issue) => new SchemaError(issue)));
}
function getSchemaErrorOrThrow(cause, message) {
let schemaError;
for (const reason of cause.reasons) {
if (!isFailReason(reason) || !isSchemaError(reason.error)) throw new globalThis.Error(message, { cause });
schemaError ??= reason.error;
}
if (schemaError === void 0) throw new globalThis.Error(message, { cause });
return schemaError;
}
function runSchemaErrorSync(self) {
const exit = runSyncExit(self);
if (isSuccess(exit)) return exit.value;
throw getSchemaErrorOrThrow(exit.cause, "Sync adapter can only throw schema errors");
}
/**
* Decodes an `unknown` input against a schema, returning an `Effect` that
* succeeds with the decoded value or fails with a {@link SchemaError}.
*
* **When to use**
*
* Use when you need to decode unknown input in an `Effect` whose failure
* channel is `SchemaError`.
*
* **Details**
*
* Prefer {@link decodeEffect} when the input is already typed as the schema's
* `Encoded` type.
* Options may be provided either when creating the decoder or when applying it;
* application options override creation options.
*
* @see {@link SchemaParser.decodeUnknownEffect} for the adapter that fails with `SchemaIssue.Issue` directly
*
* @stability stable
* @category decoding
* @since 4.0.0
*/
function decodeUnknownEffect(schema, options) {
const parser = decodeUnknownEffect$1(schema, options);
return (input, options) => {
return fromIssueEffect(parser(input, options));
};
}
/**
* Decodes an `unknown` input against a schema synchronously, returning the
* decoded value or throwing a {@link SchemaError} for schema mismatches.
*
* **When to use**
*
* Use when you need to validate unknown data at a synchronous boundary and want
* schema mismatches to throw `SchemaError`.
*
* **Details**
*
* For input already typed as the schema's `Encoded` type use `decodeSync`.
* Only service-free schemas can be decoded synchronously. For alternatives that
* do not throw on schema mismatches, see `decodeUnknownOption`,
* `decodeUnknownExit`, or `decodeUnknownEffect`. Options may be provided either
* when creating the decoder or when applying it; application options override
* creation options.
*
* **Gotchas**
*
* Non-schema failures may throw a runtime failure instead of `SchemaError`.
*
* **Example** (Decoding with a transformation schema)
*
* ```ts import.meta.vitest
* import { Schema } from "effect"
*
* const NumberFromString = Schema.NumberFromString
*
* Schema.decodeUnknownSync(NumberFromString)("42") // => 42
* ```
*
* @see {@link SchemaParser.decodeUnknownSync} for the adapter that throws an `Error` whose cause is `SchemaIssue.Issue`
*
* @stability stable
* @category decoding
* @since 4.0.0
*/
function decodeUnknownSync(schema, options) {
const parser = decodeUnknownEffect(schema, options);
return (input, options) => {
return runSchemaErrorSync(parser(input, options));
};
}
/**
* Creates a schema from an AST (Abstract Syntax Tree) node.
*
* **Details**
*
* This is the fundamental constructor for all schemas in the Effect Schema
* library. It takes an AST node and wraps it in a fully-typed schema that
* preserves all type information and provides the complete schema API.
*
* The `make` function is used internally to create all primitive schemas like
* `String`, `Number`, `Boolean`, etc., as well as more complex schemas. It's
* the bridge between the untyped AST representation and the strongly-typed
* schema.
*
* @stability stable
* @category constructors
* @since 3.10.0
*/
const make = make$1;
/**
* Creates a schema for a single literal value (string, number, bigint, boolean, or null).
*
* **Example** (Defining a string literal)
*
* ```ts import.meta.vitest
* import { Schema } from "effect"
*
* const schema = Schema.Literal("hello")
* // Type: Schema.Literal<"hello">
* Schema.decodeSync(schema)("hello") // => "hello"
* ```
*
* @see {@link Literals} for a schema that represents a union of literals.
* @see {@link tag} for a schema that represents a literal value that can be
* used as a discriminator field in tagged unions and has a constructor default.
* @stability stable
* @category constructors
* @since 3.10.0
*/
function Literal(literal) {
const out = make(new Literal$1(literal), {
literal,
transform(to) {
return out.pipe(decodeTo(Literal(to), {
decode: transform$1(() => to),
encode: transform$1(() => literal)
}));
}
});
return out;
}
/**
* Schema for the `null` literal. Validates that the input is strictly `null`.
*
* @see {@link NullOr} for a union with another schema.
* @stability stable
* @category schemas
* @since 3.10.0
*/
const Null = /*#__PURE__*/ make(null_);
/**
* Schema for `string` values. Validates that the input is `typeof` `"string"`.
*
* @stability stable
* @category schemas
* @since 4.0.0
*/
const String$1 = /*#__PURE__*/ make(string);
/**
* Schema for `number` values, including `NaN`, `Infinity`, and `-Infinity`.
*
* **Details**
*
* Default JSON serializer:
*
* - Finite numbers are serialized as numbers.
* - Non-finite values are serialized as strings (`"NaN"`, `"Infinity"`, `"-Infinity"`).
*
* @see {@link Finite} for a schema that excludes non-finite values.
* @stability stable
* @category schemas
* @since 4.0.0
*/
const Number$1 = /*#__PURE__*/ make(number);
function makeStruct(ast, fields) {
return make(ast, {
fields,
mapFields(f, options) {
const fields = f(this.fields);
return makeStruct(struct(fields, options?.unsafePreserveChecks ? this.ast.checks : void 0), fields);
}
});
}
/**
* Defines a struct schema from a map of field schemas.
*
* **Details**
*
* Each field value is a schema. Use {@link optionalKey} or {@link optional} to
* mark fields as optional, and {@link mutableKey} to mark them as mutable.
*
* The resulting schema's `Type` is a readonly object type with the fields'
* decoded types. The `Encoded` form mirrors the field schemas' encoded types.
* Declared fields may be inherited and are copied to own properties in the
* output. The `__proto__` field is accepted only when it is an own property.
* Parsing does not guarantee that output keys retain their input order.
*
* **Example** (Defining a basic struct)
*
* ```ts import.meta.vitest
* import { Schema } from "effect"
*
* const Person = Schema.Struct({
* name: Schema.String,
* age: Schema.Number,
* email: Schema.optionalKey(Schema.String)
* })
*
* // { readonly name: string; readonly age: number; readonly email?: string }
* type Person = typeof Person.Type
*
* Schema.decodeUnknownSync(Person)({ name: "Alice", age: 30 }) // => { name: "Alice", age: 30 }
* ```
*
* @stability stable
* @category constructors
* @since 3.10.0
*/
function Struct(fields) {
return makeStruct(struct(fields, void 0), fields);
}
/**
* @category constructors
* @since 4.0.0
*/
const ArraySchema = /*#__PURE__*/ lambda((schema) => make(new Arrays(false, [], [schema.ast]), { value: schema }));
/**
* Makes an array or tuple schema mutable, removing the `readonly` modifier.
*
* **Gotchas**
*
* This combinator does not support an encoding attached to the array or tuple
* node and throws if one is present. Encodings on element schemas are
* supported.
*
* **Example** (Defining mutable arrays)
*
* ```ts import.meta.vitest
* import { Schema } from "effect"
*
* const schema = Schema.mutable(Schema.Array(Schema.Number))
*
* // number[] (mutable)
* type T = typeof schema.Type
* const value: T = [1, 2]
* value.push(3)
* value // => [1, 2, 3]
* ```
*
* @stability stable
* @category transforming
* @since 3.10.0
*/
const mutable = /*#__PURE__*/ lambda((schema) => make(mutable$1(schema.ast), { schema }));
function makeUnion(ast, members) {
return make(ast, {
members,
mapMembers(f, options) {
const members = f(this.members);
return makeUnion(union(members, this.ast.options, options?.unsafePreserveChecks ? this.ast.checks : void 0), members);
}
});
}
/**
* Creates a union schema from an array of member schemas. Members are tested in
* order; the first match is returned.
*
* **Details**
*
* Optionally, specify `mode`:
* - `"anyOf"` (default) — matches if any member matches.
* - `"oneOf"` — matches if exactly one member matches.
*
* **Example** (Defining a string or number union)
*
* ```ts import.meta.vitest
* import { Schema } from "effect"
*
* const schema = Schema.Union([Schema.String, Schema.Number])
*
* Schema.decodeUnknownSync(schema)("hello") // => "hello"
* Schema.decodeUnknownSync(schema)(42) // => 42
* ```
*
* @stability stable
* @category constructors
* @since 3.10.0
*/
function Union(members, options) {
return makeUnion(union(members, options, void 0), members);
}
/**
* Creates a union schema from an array of literal values.
*
* **Example** (Defining status codes)
*
* ```ts import.meta.vitest
* import { Schema } from "effect"
*
* const schema = Schema.Literals(["active", "inactive", "pending"])
* Schema.decodeSync(schema)("active") // => "active"
* ```
*
* @see {@link Literal} for a schema that represents a single literal.
* @stability stable
* @category constructors
* @since 4.0.0
*/
function Literals(literals) {
const members = literals.map(Literal);
return make(union(members, void 0, void 0), {
literals,
members,
mapMembers(f) {
return Union(f(this.members));
},
pick(literals) {
return Literals(literals);
},
transform(to) {
return Union(members.map((member, index) => member.transform(to[index])));
}
});
}
/**
* Creates a union schema of `S | null`.
*
* @stability stable
* @category constructors
* @since 3.10.0
*/
const NullOr = /*#__PURE__*/ lambda((self) => Union([self, Null]));
function decodeTo(to, transformation) {
return (from) => {
return make(decodeTo$1(from.ast, to.ast, transformation ? makeTransformation(transformation) : passthrough()), {
from,
to
});
};
}
/**
* Creates a schema that validates values using `instanceof`.
* Decoding and encoding pass the value through unchanged.
*
* **Example** (Defining a schema for a built-in class)
*
* ```ts import.meta.vitest
* import { Schema } from "effect"
*
* const DateSchema = Schema.instanceOf(Date)
*
* const decoded = Schema.decodeUnknownSync(DateSchema)(new Date("2024-01-01"))
* decoded.toISOString() // => "2024-01-01T00:00:00.000Z"
* ```
*
* @stability stable
* @category constructors
* @since 3.10.0
*/
function instanceOf(constructor, annotations) {
return declare((u) => u instanceof constructor, annotations);
}
/**
* Creates a custom validation filter from a predicate function.
*
* **Details**
*
* The predicate receives the decoded input value, the schema AST, and parse
* options, and returns a `FilterOutput`. Non-success outputs are normalized into
* schema issues. The `annotations` parameter annotates the filter itself; with
* the default formatter, failures use `message` first, `expected` second, and
* `<filter>` when neither is provided.
*
* When `abort` is `true`, parsing stops after this filter fails instead of
* collecting later check failures.
*
* **Example** (Reporting failure at a nested path)
*
* ```ts import.meta.vitest
* import { Result, Schema } from "effect"
*
* const schema = Schema.Struct({ password: Schema.String, confirmPassword: Schema.String }).check(
* Schema.makeFilter((o) =>
* o.password === o.confirmPassword
* ? undefined
* : { path: ["password"], issue: "password and confirmPassword must match" }
* )
* )
*
* const result = Schema.decodeUnknownResult(schema)({ password: "123456", confirmPassword: "1234567" })
* if (Result.isFailure(result) && result.failure.issue._tag === "Filter" && result.failure.issue.issue._tag === "Pointer") {
* result.failure.issue.issue.path // => ["password"]
* }
* ```
*
* **Example** (Reporting multiple failures at once)
*
* ```ts import.meta.vitest
* import { Result, Schema } from "effect"
*
* const schema = Schema.Struct({ a: Schema.Finite, b: Schema.Finite, c: Schema.Finite }).check(
* Schema.makeFilter((o) => {
* const issues: Array<Schema.FilterIssue> = []
* if (o.a > 0) {
* if (o.b <= 0) issues.push({ path: ["b"], issue: "b must be greater than 0" })
* if (o.c <= 0) issues.push({ path: ["c"], issue: "c must be greater than 0" })
* }
* return issues
* })
* )
*
* const result = Schema.decodeUnknownResult(schema)({ a: 1, b: 0, c: 0 })
* if (Result.isFailure(result) && result.failure.issue._tag === "Filter" && result.failure.issue.issue._tag === "Composite") {
* result.failure.issue.issue.issues.map((issue) => issue._tag === "Pointer" ? issue.path : []) // => [["b"], ["c"]]
* }
* ```
*
* @stability stable
* @category constructors
* @since 4.0.0
*/
const makeFilter = makeFilter$1;
/**
* Creates a greater-than-or-equal-to (`>=`) check for any ordered type from an
* `Order.Order` instance.
*
* @stability stable
* @category validation
* @since 4.0.0
*/
function makeIsGreaterThanOrEqualTo(options) {
const gte = isGreaterThanOrEqualTo$1(options.order);
const formatter = options.formatter ?? format$1;
return (minimum, annotations) => {
return makeFilter((input) => gte(input, minimum), {
expected: `a value greater than or equal to ${formatter(minimum)}`,
arbitraryConstraint: {
order: options.order,
minimum
},
...options.annotate?.(minimum),
...annotations
});
};
}
/**
* Creates a less-than-or-equal-to (`<=`) check for any ordered type from an
* `Order.Order` instance.
*
* @stability stable
* @category validation
* @since 4.0.0
*/
function makeIsLessThanOrEqualTo(options) {
const lte = isLessThanOrEqualTo$1(options.order);
const formatter = options.formatter ?? format$1;
return (maximum, annotations) => {
return makeFilter((input) => lte(input, maximum), {
expected: `a value less than or equal to ${formatter(maximum)}`,
arbitraryConstraint: {
order: options.order,
maximum
},
...options.annotate?.(maximum),
...annotations
});
};
}
function encodeNumberPayload(number) {
if (!globalThis.Number.isFinite(number)) throw new globalThis.RangeError(`Expected a finite number, got ${format$1(number)}`);
return number;
}
/**
* Validates that a number is greater than or equal to the specified value
* (inclusive).
*
* **Details**
*
* JSON Schema:
*
* This check corresponds to the `minimum` constraint in JSON Schema.
*
* Arbitrary:
*
* During arbitrary generation, this applies a `minimum` constraint
* to ensure generated numbers are greater than or equal to the specified value.
*
* @stability stable
* @category validation
* @since 4.0.0
*/
const isGreaterThanOrEqualTo = /*#__PURE__*/ makeIsGreaterThanOrEqualTo({
order: Number$4,
annotate: (minimum) => ({
representation: {
id: "effect/schema/isGreaterThanOrEqualTo",
payload: { minimum: encodeNumberPayload(minimum) }
},
toJsonSchema: () => ({ minimum }),
toCode: () => ({ runtime: `Schema.isGreaterThanOrEqualTo(${format$1(minimum)})` })
})
});
/**
* Validates that a number is less than or equal to the specified value
* (inclusive).
*
* **Details**
*
* JSON Schema:
*
* This check corresponds to the `maximum` constraint in JSON Schema.
*
* Arbitrary:
*
* During arbitrary generation, this applies a `maximum` constraint
* to ensure generated numbers are less than or equal to the specified value.
*
* @stability stable
* @category validation
* @since 4.0.0
*/
const isLessThanOrEqualTo = /*#__PURE__*/ makeIsLessThanOrEqualTo({
order: Number$4,
annotate: (maximum) => ({
representation: {
id: "effect/schema/isLessThanOrEqualTo",
payload: { maximum: encodeNumberPayload(maximum) }
},
toJsonSchema: () => ({ maximum }),
toCode: () => ({ runtime: `Schema.isLessThanOrEqualTo(${format$1(maximum)})` })
})
});
/**
* Validates that a value has at least the specified length. Works with strings
* and arrays.
*
* **Details**
*
* JSON Schema:
*
* The bound must be finite; it is rounded down and clamped to zero. For arrays,
* this check corresponds to `minItems`. JavaScript counts UTF-16 code units
* while JSON Schema counts Unicode code points, so strings use
* `minLength: Math.ceil(minLength / 2)`, the tightest lower bound that cannot
* reject a string accepted by this check.
*
* Arbitrary:
*
* During arbitrary generation, this applies a `minLength`
* constraint to ensure generated strings or arrays have at least the required
* length.
*
* **Example** (Checking minimum length)
*
* ```ts import.meta.vitest
* import { Schema } from "effect"
*
* const NonEmptyStringSchema = Schema.String.check(Schema.isMinLength(1))
* const NonEmptyArraySchema = Schema.Array(Schema.Number).check(Schema.isMinLength(1))
* Schema.is(NonEmptyStringSchema)("a") // => true
* Schema.is(NonEmptyArraySchema)([1]) // => true
* ```
*
* @stability stable
* @category validation
* @since 4.0.0
*/
function isMinLength(minLength, annotations) {
minLength = normalizeCardinality(minLength);
return makeIsMinLength(minLength, Math.ceil(minLength / 2), annotations);
}
function makeIsMinLength(minLength, minCodePoints, annotations) {
return makeFilter((input) => input.length >= minLength, {
expected: `a value with a length of at least ${minLength}`,
representation: {
id: "effect/schema/isMinLength",
payload: { minLength }
},
toJsonSchema: ({ type }) => type === "string" ? minLength <= 1 ? { minLength: minCodePoints } : [{ minLength: minCodePoints }, true] : type === "array" ? { minItems: minLength } : type === void 0 ? [{
minLength: minCodePoints,
minItems: minLength
}, true] : [{}, true],
toCode: () => ({ runtime: `Schema.isMinLength(${minLength})` }),
[STRUCTURAL_ANNOTATION_KEY]: true,
arbitraryConstraint: { minLength },
...annotations
});
}
/**
* Validates that a value has at most the specified length. Works with strings
* and arrays.
*
* **Details**
*
* JSON Schema:
*
* The bound must be finite; it is rounded down and clamped to zero. This check
* corresponds to `maxItems` for arrays. Strings use the same bound for
* `maxLength`, which cannot reject a string accepted by this check because a
* string has no more code points than UTF-16 code units.
*
* Arbitrary:
*
* During arbitrary generation, this applies a `maxLength`
* constraint to ensure generated strings or arrays have at most the required
* length.
*
* @stability stable
* @category validation
* @since 4.0.0
*/
function isMaxLength(maxLength, annotations) {
maxLength = normalizeCardinality(maxLength);
return makeFilter((input) => input.length <= maxLength, {
expected: `a value with a length of at most ${maxLength}`,
representation: {
id: "effect/schema/isMaxLength",
payload: { maxLength }
},
toJsonSchema: ({ type }) => type === "string" ? maxLength === 0 ? { maxLength } : [{ maxLength }, true] : type === "array" ? { maxItems: maxLength } : type === void 0 ? [{
maxLength,
maxItems: maxLength
}, true] : [{}, true],
toCode: () => ({ runtime: `Schema.isMaxLength(${maxLength})` }),
[STRUCTURAL_ANNOTATION_KEY]: true,
arbitraryConstraint: { maxLength },
...annotations
});
}
function normalizeCardinality(value) {
if (!globalThis.Number.isFinite(value)) throw new globalThis.RangeError(`Expected a finite number, got ${value}`);
return Math.max(0, Math.floor(value));
}
globalThis.RegExp;
globalThis.URL;
globalThis.File;
globalThis.FormData;
globalThis.URLSearchParams;
globalThis.Uint8Array;
//#endregion
//#region ../schemas/libraries/effect/download/index.ts
const Image = Struct({
id: Number$1,
created: instanceOf(Date),
title: String$1.check(isMinLength(1), isMaxLength(100)),
type: Literals(["jpg", "png"]),
size: Number$1,
url: String$1.check(makeFilter((value) => URL.canParse(value)))
});
const Rating = Struct({
id: Number$1,
stars: Number$1.check(isGreaterThanOrEqualTo(1), isLessThanOrEqualTo(5)),
title: String$1.check(isMinLength(1), isMaxLength(100)),
text: String$1.check(isMinLength(1), isMaxLength(1e3)),
images: mutable(ArraySchema(Image))
});
decodeUnknownSync(Struct({
id: Number$1,
created: instanceOf(Date),
title: String$1.check(isMinLength(1), isMaxLength(100)),
brand: String$1.check(isMinLength(1), isMaxLength(30)),
description: String$1.check(isMinLength(1), isMaxLength(500)),
price: Number$1.check(isGreaterThanOrEqualTo(1), isLessThanOrEqualTo(1e4)),
discount: NullOr(Number$1.check(isGreaterThanOrEqualTo(1), isLessThanOrEqualTo(100))),
quantity: Number$1.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo(10)),
tags: mutable(ArraySchema(String$1.check(isMinLength(1), isMaxLength(30)))),
images: mutable(ArraySchema(Image)),
ratings: mutable(ArraySchema(Rating))
}))({});
//#endregion