const e = (e, t) => {
switch (t.length) {
case 0:
return e;
case 1:
return t[0](e);
case 2:
return t[1](t[0](e));
case 3:
return t[2](t[1](t[0](e)));
case 4:
return t[3](t[2](t[1](t[0](e))));
case 5:
return t[4](t[3](t[2](t[1](t[0](e)))));
case 6:
return t[5](t[4](t[3](t[2](t[1](t[0](e))))));
case 7:
return t[6](t[5](t[4](t[3](t[2](t[1](t[0](e)))))));
case 8:
return t[7](t[6](t[5](t[4](t[3](t[2](t[1](t[0](e))))))));
case 9:
return t[8](t[7](t[6](t[5](t[4](t[3](t[2](t[1](t[0](e)))))))));
default: {
let n = e;
for (let e = 0, r = t.length; e < r; e++) n = t[e](n);
return n;
}
}
},
t = {
pipe() {
return e(this, arguments);
},
},
n = (function () {
function e() {}
return ((e.prototype = t), e);
})(),
r = function (e, t) {
if (typeof e == `function`)
return function () {
return e(arguments) ? t.apply(this, arguments) : (e) => t(e, ...arguments);
};
switch (e) {
case 0:
case 1:
throw RangeError(`Invalid arity ${e}`);
case 2:
return function (e, n) {
return arguments.length >= 2
? t(e, n)
: function (n) {
return t(n, e);
};
};
case 3:
return function (e, n, r) {
return arguments.length >= 3
? t(e, n, r)
: function (r) {
return t(r, e, n);
};
};
default:
return function () {
if (arguments.length >= e) return t.apply(this, arguments);
let n = arguments;
return function (e) {
return t(e, ...n);
};
};
}
},
i = (e) => e,
a = (
(e) => () =>
e
)(void 0),
o = a;
function s(e) {
let t = new WeakMap();
return (n) => {
if (t.has(n)) return t.get(n);
let r = e(n);
return (t.set(n, r), r);
};
}
const c = (e) => {
let t = new Set(Reflect.ownKeys(e));
if (e.constructor === Object) return t;
e instanceof Error && t.delete(`stack`);
let n = Object.getPrototypeOf(e),
r = n;
for (; r !== null && r !== Object.prototype;) {
let e = Reflect.ownKeys(r);
for (let n = 0; n < e.length; n++) t.add(e[n]);
r = Object.getPrototypeOf(r);
}
return (
t.has(`constructor`) &&
typeof e.constructor == `function` &&
n === e.constructor.prototype &&
t.delete(`constructor`),
t
);
},
l = new WeakSet();
function u(e) {
return typeof e == `string`;
}
function d(e) {
return typeof e == `number`;
}
function f(e) {
return typeof e == `function`;
}
function ee(e) {
return e != null;
}
function p(e) {
return (typeof e == `object` && !!e) || f(e);
}
const m = r(2, (e, t) => p(e) && t in e),
h = `~effect/interfaces/Hash`,
g = (e) => {
switch (typeof e) {
case `number`:
return re(e);
case `bigint`:
return y(e.toString(10));
case `boolean`:
return y(String(e));
case `symbol`:
return y(String(e));
case `string`:
return y(e);
case `undefined`:
return y(`undefined`);
case `function`:
case `object`:
if (e === null) return y(`null`);
if (e instanceof Date) return y(e.toISOString());
if (e instanceof RegExp) return y(e.toString());
{
if (l.has(e)) return te(e);
if (de.has(e)) return de.get(e);
let t = pe(e, () =>
ne(e)
? e[h]()
: typeof e == `function`
? te(e)
: Array.isArray(e) || ArrayBuffer.isView(e)
? se(e)
: e instanceof Map
? ce(e)
: e instanceof Set
? le(e)
: ae(e),
);
return (de.set(e, t), t);
}
default:
throw Error(
`BUG: unhandled typeof ${typeof e} - please report an issue at https://github.com/Effect-TS/effect/issues`,
);
}
},
te = (e) => (ue.has(e) || ue.set(e, re(Math.floor(Math.random() * (2 ** 53 - 1)))), ue.get(e)),
_ = r(2, (e, t) => (e * 53) ^ t),
v = (e) => (e & 3221225471) | ((e >>> 1) & 1073741824),
ne = (e) => m(e, h),
re = (e) => {
if (e !== e) return y(`NaN`);
if (e === 1 / 0) return y(`Infinity`);
if (e === -1 / 0) return y(`-Infinity`);
let t = e | 0;
for (t !== e && (t ^= e * 4294967295); e > 4294967295;) t ^= e /= 4294967295;
return v(t);
},
y = (e) => {
let t = 5381,
n = e.length;
for (; n;) t = (t * 33) ^ e.charCodeAt(--n);
return v(t);
},
ie = (e, t) => {
let n = 12289;
for (let r of t) n ^= _(g(r), g(e[r]));
return v(n);
},
ae = (e) => ie(e, c(e)),
oe = (e, t) => (n) => {
let r = e;
for (let e of n) r ^= t(e);
return v(r);
},
se = oe(6151, g),
ce = oe(y(`Map`), ([e, t]) => _(g(e), g(t))),
le = oe(y(`Set`), g),
ue = new WeakMap(),
de = new WeakMap(),
fe = new WeakSet();
function pe(e, t) {
if (fe.has(e)) return y(`[Circular]`);
fe.add(e);
let n = t();
return (fe.delete(e), n);
}
const b = `~effect/interfaces/Equal`;
function x() {
return arguments.length === 1 ? (e) => S(e, arguments[0]) : S(arguments[0], arguments[1]);
}
function S(e, t) {
if (e === t) return !0;
if (e == null || t == null) return !1;
let n = typeof e;
return n === typeof t
? n === `number` && e !== e && t !== t
? !0
: (n !== `object` && n !== `function`) || l.has(e) || l.has(t)
? !1
: ve(e, t, _e)
: !1;
}
function me(e, t, n) {
let r = he.has(e),
i = ge.has(t);
if (r && i) return !0;
if (r || i) return !1;
(he.add(e), ge.add(t));
let a = n();
return (he.delete(e), ge.delete(t), a);
}
const he = new WeakSet(),
ge = new WeakSet();
function _e(e, t) {
if (g(e) !== g(t)) return !1;
if (e instanceof Date) return t instanceof Date && e.toISOString() === t.toISOString();
if (e instanceof RegExp) return t instanceof RegExp && e.toString() === t.toString();
let n = De(e),
r = De(t);
if (n !== r) return !1;
let i = n && r;
return typeof e == `function` && !i
? !1
: me(e, t, () =>
i
? e[b](t)
: Array.isArray(e)
? !Array.isArray(t) || e.length !== t.length
? !1
: be(e, t)
: ArrayBuffer.isView(e)
? !ArrayBuffer.isView(t) || e.byteLength !== t.byteLength
? !1
: xe(e, t)
: e instanceof Map
? !(t instanceof Map) || e.size !== t.size
? !1
: we(e, t)
: e instanceof Set
? !(t instanceof Set) || e.size !== t.size
? !1
: Ee(e, t)
: Se(e, t),
);
}
function ve(e, t, n) {
let r = ye.get(e);
if (!r) ((r = new WeakMap()), ye.set(e, r));
else if (r.has(t)) return r.get(t);
let i = n(e, t);
r.set(t, i);
let a = ye.get(t);
return (a || ((a = new WeakMap()), ye.set(t, a)), a.set(e, i), i);
}
const ye = new WeakMap();
function be(e, t) {
for (let n = 0; n < e.length; n++) if (!S(e[n], t[n])) return !1;
return !0;
}
function xe(e, t) {
if (e.length !== t.length) return !1;
for (let n = 0; n < e.length; n++) if (e[n] !== t[n]) return !1;
return !0;
}
function Se(e, t) {
let n = c(e),
r = c(t);
if (n.size !== r.size) return !1;
for (let i of n) if (!r.has(i) || !S(e[i], t[i])) return !1;
return !0;
}
function Ce(e, t) {
return function (n, r) {
for (let [i, a] of n) {
let n = !1;
for (let [o, s] of r)
if (e(i, o) && t(a, s)) {
n = !0;
break;
}
if (!n) return !1;
}
return !0;
};
}
const we = Ce(S, S);
function Te(e) {
return function (t, n) {
for (let r of t) {
let t = !1;
for (let i of n)
if (e(r, i)) {
t = !0;
break;
}
if (!t) return !1;
}
return !0;
};
}
const Ee = Te(S),
De = (e) => m(e, b),
Oe = () => x,
ke = (e) => (t, n) => t === n || e(t, n),
Ae = (e) => e.length > 0,
je = Symbol.for(`~effect/Redactable`),
Me = (e) => m(e, je);
function Ne(e) {
return Me(e) ? Pe(e) : e;
}
function Pe(e) {
return e[je](globalThis[`~effect/Fiber/currentFiber`]?.context ?? Ie);
}
const Fe = `~effect/Fiber/currentFiber`,
Ie = {
"~effect/Context": {},
mapUnsafe: new Map(),
pipe() {
return e(this, arguments);
},
};
function C(e, t) {
let n = t?.space ?? 0,
r = new WeakSet(),
i = n ? (typeof n == `number` ? ` `.repeat(n) : n) : ``,
a = (e) => i.repeat(e),
o = (e, t) => {
let n = e?.constructor;
return n && n !== Object.prototype.constructor && n.name ? `${n.name}(${t})` : t;
},
s = (e) => {
try {
return Reflect.ownKeys(e);
} catch {
return [`[ownKeys threw]`];
}
};
function c(e, n = 0) {
if (Array.isArray(e)) {
if (r.has(e)) return Le;
if ((r.add(e), !i || e.length <= 1)) return `[${e.map((e) => c(e, n)).join(`,`)}]`;
let t = e
.map((e) => c(e, n + 1))
.join(
`,
` + a(n + 1),
);
return `[\n${a(n + 1)}${t}\n${a(n)}]`;
}
if (e instanceof Date) return Be(e);
if (
!t?.ignoreToString &&
m(e, `toString`) &&
typeof e.toString == `function` &&
e.toString !== Object.prototype.toString &&
e.toString !== Array.prototype.toString
) {
let t = Ve(e);
return e instanceof Error && e.cause ? `${t} (cause: ${c(e.cause, n)})` : t;
}
if (typeof e == `string`) return JSON.stringify(e);
if (typeof e == `number` || e == null || typeof e == `boolean` || typeof e == `symbol`)
return String(e);
if (typeof e == `bigint`) return String(e) + `n`;
if (typeof e == `object` || typeof e == `function`) {
if (r.has(e)) return Le;
if ((r.add(e), je in e)) return C(Pe(e));
if (Symbol.iterator in e) return `${e.constructor.name}(${c(Array.from(e), n)})`;
let t = s(e);
if (!i || t.length <= 1) {
let r = `{${t.map((t) => `${Re(t)}:${c(e[t], n)}`).join(`,`)}}`;
return o(e, r);
}
let l = `{\n${t.map((t) => `${a(n + 1)}${Re(t)}: ${c(e[t], n + 1)}`).join(`,
`)}\n${a(n)}}`;
return o(e, l);
}
return String(e);
}
return c(e, 0);
}
const Le = `[Circular]`;
function Re(e) {
return typeof e == `string` ? JSON.stringify(e) : String(e);
}
function ze(e) {
return e.map((e) => `[${Re(e)}]`).join(``);
}
function Be(e) {
try {
return e.toISOString();
} catch {
return `Invalid Date`;
}
}
function Ve(e) {
try {
let t = e.toString();
return typeof t == `string` ? t : String(t);
} catch {
return `[toString threw]`;
}
}
const He = Symbol.for(`nodejs.util.inspect.custom`),
Ue = (e) => {
try {
if (m(e, `toJSON`) && f(e.toJSON) && e.toJSON.length === 0) return e.toJSON();
if (Array.isArray(e)) return e.map(Ue);
} catch {
return `[toJSON threw]`;
}
return Ne(e);
};
var We = class e {
called = !1;
self;
constructor(e) {
this.self = e;
}
next(e) {
return this.called
? { value: e, done: !0 }
: ((this.called = !0), { value: this.self, done: !1 });
}
[Symbol.iterator]() {
return new e(this.self);
}
};
const Ge = (() => {
let e = `~effect/Utils/internal`,
t = { [e]: (e) => e() },
n = {
[e]: (e) => {
try {
return e();
} finally {
}
},
};
return t[e](() => Error().stack)?.includes(e) === !0 ? t[e] : n[e];
})(),
w = `~effect/Effect`,
Ke = `~effect/Exit`,
qe = { _A: i, _E: i, _R: i },
Je = `${w}/identifier`,
T = `${w}/args`,
E = `${w}/evaluate`,
D = `${w}/successCont`,
O = `${w}/failureCont`,
Ye = `${w}/ensureCont`,
Xe = Symbol.for(`effect/Effect/Yield`),
Ze = {
pipe() {
return e(this, arguments);
},
toJSON() {
return { ...this };
},
toString() {
return C(this.toJSON(), { ignoreToString: !0, space: 2 });
},
[He]() {
return this.toJSON();
},
},
Qe = {
[w]: qe,
...Ze,
[Symbol.iterator]() {
return new We(this);
},
toJSON() {
return { _id: `Effect`, op: this[Je], ...(T in this ? { args: this[T] } : void 0) };
},
},
$e = (e) => m(e, Ke),
et = `~effect/Cause`,
tt = `~effect/Cause/Reason`,
nt = (e) => m(e, et);
var rt = class {
[et];
reasons;
constructor(e) {
((this[et] = et), (this.reasons = e));
}
pipe() {
return e(this, arguments);
}
toJSON() {
return { _id: `Cause`, failures: this.reasons.map((e) => e.toJSON()) };
}
toString() {
return `Cause(${C(this.reasons)})`;
}
[He]() {
return this.toJSON();
}
[b](e) {
return (
nt(e) &&
this.reasons.length === e.reasons.length &&
this.reasons.every((t, n) => x(t, e.reasons[n]))
);
}
[h]() {
return se(this.reasons);
}
};
const it = new WeakMap();
var at = class {
[tt];
annotations;
_tag;
constructor(e, t, n) {
if (((this[tt] = tt), (this._tag = e), t !== ot && typeof n == `object` && n && t.size > 0)) {
let e = it.get(n);
(e && (t = new Map([...e, ...t])), it.set(n, t));
}
this.annotations = t;
}
annotate(e, t) {
if (e.mapUnsafe.size === 0) return this;
let n = new Map(this.annotations);
e.mapUnsafe.forEach((e, r) => {
(t?.overwrite !== !0 && n.has(r)) || n.set(r, e);
});
let r = Object.assign(Object.create(Object.getPrototypeOf(this)), this);
return ((r.annotations = n), r);
}
pipe() {
return e(this, arguments);
}
toString() {
return C(this);
}
[He]() {
return this.toString();
}
};
const ot = new Map();
var st = class extends at {
error;
constructor(e, t = ot) {
(super(`Fail`, t, e), (this.error = e));
}
toString() {
return `Fail(${C(this.error)})`;
}
toJSON() {
return { _tag: `Fail`, error: this.error };
}
[b](e) {
return pt(e) && x(this.error, e.error) && x(this.annotations, e.annotations);
}
[h]() {
return _(y(this._tag))(_(g(this.error))(g(this.annotations)));
}
};
const ct = (e) => new rt(e),
lt = (e) => new rt([new st(e)]);
var ut = class extends at {
defect;
constructor(e, t = ot) {
(super(`Die`, t, e), (this.defect = e));
}
toString() {
return `Die(${C(this.defect)})`;
}
toJSON() {
return { _tag: `Die`, defect: this.defect };
}
[b](e) {
return mt(e) && x(this.defect, e.defect) && x(this.annotations, e.annotations);
}
[h]() {
return _(y(this._tag))(_(g(this.defect))(g(this.annotations)));
}
};
const dt = (e) => new rt([new ut(e)]),
ft = r(
(e) => nt(e[0]),
(e, t, n) => (t.mapUnsafe.size === 0 ? e : new rt(e.reasons.map((e) => e.annotate(t, n)))),
),
pt = (e) => e._tag === `Fail`,
mt = (e) => e._tag === `Die`,
ht = (e) => e._tag === `Interrupt`;
function gt(e) {
return St(`Effect.evaluate: Not implemented`);
}
const _t = (e) => ({ ...Qe, [Je]: e.op, [E]: e[E] ?? gt, [D]: e[D], [O]: e[O], [Ye]: e[Ye] }),
k = (e) => {
let t = _t(e);
return function () {
let n = Object.create(t);
return ((n[T] = e.single === !1 ? arguments : arguments[0]), n);
};
},
vt = (e) => {
let t = {
..._t(e),
[Ke]: Ke,
_tag: e.op,
get [e.prop]() {
return this[T];
},
toString() {
return `${e.op}(${C(this[T])})`;
},
toJSON() {
return { _id: `Exit`, _tag: e.op, [e.prop]: this[T] };
},
[b](e) {
return $e(e) && e._tag === this._tag && x(this[T], e[T]);
},
[h]() {
return _(y(e.op), g(this[T]));
},
};
return function (e) {
let n = Object.create(t);
return ((n[T] = e), n);
};
},
A = vt({
op: `Success`,
prop: `value`,
[E](e) {
let t = e.getCont(D);
return t ? t[D](this[T], e, this) : e.yieldWith(this);
},
}),
yt = { key: `effect/Cause/StackTrace` },
bt = { key: `effect/Cause/InterruptorStackTrace` },
j = vt({
op: `Failure`,
prop: `cause`,
[E](e) {
let t = this[T],
n = !1;
e.currentStackFrame &&
((t = ft(t, { mapUnsafe: new Map([[yt.key, e.currentStackFrame]]) })), (n = !0));
let r = e.getCont(O);
for (; e.interruptible && e._interruptedCause && r;) r = e.getCont(O);
return r ? r[O](t, e, n ? void 0 : this) : e.yieldWith(n ? j(t) : this);
},
}),
xt = (e) => j(lt(e)),
St = (e) => j(dt(e)),
Ct = k({
op: `WithFiber`,
[E](e) {
return this[T](e);
},
}),
wt = (function () {
class e extends globalThis.Error {}
let t = _t({
op: `YieldableError`,
[E]() {
return xt(this);
},
});
return (delete t.toString, Object.assign(e.prototype, t), e);
})(),
Tt = (function () {
let e = Symbol.for(`effect/Data/Error/plainArgs`);
return class extends wt {
constructor(t) {
(super(t?.message, t?.cause ? { cause: t.cause } : void 0),
t &&
(Object.assign(this, t), Object.defineProperty(this, e, { value: t, enumerable: !1 })));
}
toJSON() {
return { ...this[e], ...this };
}
};
})(),
M = (e) => {
class t extends Tt {
_tag = e;
}
return ((t.prototype.name = e), t);
};
M(`NoSuchElementError`);
const Et = `~effect/data/Option`,
Dt = {
[Et]: { _A: (e) => e },
...Ze,
[Symbol.iterator]() {
return new We(this);
},
},
Ot = Object.defineProperty(
Object.assign(Object.create(Dt), {
_tag: `Some`,
_op: `Some`,
[b](e) {
return jt(e) && Nt(e) && x(this.value, e.value);
},
[h]() {
return _(g(this._tag))(g(this.value));
},
toString() {
return `some(${C(this.value)})`;
},
toJSON() {
return { _id: `Option`, _tag: this._tag, value: Ue(this.value) };
},
}),
"valueOrUndefined",
{
get() {
return this.value;
},
},
),
kt = g(`None`),
At = Object.assign(Object.create(Dt), {
_tag: `None`,
_op: `None`,
valueOrUndefined: void 0,
[b](e) {
return jt(e) && Mt(e);
},
[h]() {
return kt;
},
toString() {
return `none()`;
},
toJSON() {
return { _id: `Option`, _tag: this._tag };
},
}),
jt = (e) => m(e, Et),
Mt = (e) => e._tag === `None`,
Nt = (e) => e._tag === `Some`,
Pt = Object.create(At),
Ft = (e) => {
let t = Object.create(Ot);
return ((t.value = e), t);
},
It = `~effect/data/Result`;
({ ...Ze });
function Lt(e) {
return (t, n) => (t === n ? 0 : e(t, n));
}
const Rt = Lt((e, t) =>
globalThis.Number.isNaN(e) && globalThis.Number.isNaN(t)
? 0
: globalThis.Number.isNaN(e)
? -1
: globalThis.Number.isNaN(t)
? 1
: e < t
? -1
: 1,
),
zt = (e) => r(2, (t, n) => e(t, n) !== 1),
Bt = (e) => r(2, (t, n) => e(t, n) !== -1),
Vt = () => Pt,
N = Ft,
Ht = Mt,
Ut = Nt,
Wt = r(2, (e, t) => (Ht(e) ? Vt() : N(t(e.value)))),
Gt = globalThis.Array,
Kt = (e) => (Gt.isArray(e) ? e : Gt.from(e)),
qt = r(2, (e, t) => [...e, t]),
Jt = r(2, (e, t) => Kt(e).concat(Kt(t)));
Gt.isArray;
const Yt = Ae,
Xt = Ae;
function Zt(e, t) {
return e < 0 || e >= t.length;
}
const Qt = r(2, (e, t) => {
let n = Math.floor(t);
if (Zt(n, e)) throw Error(`Index out of bounds: ${n}`);
return e[n];
})(0),
$t = (e) => e.slice(1),
en = r(3, (e, t, n) => {
let r = Kt(e),
i = Kt(t);
return Xt(r) ? (Xt(i) ? an(n)(Jt(r, i)) : r) : i;
}),
tn = r(2, (e, t) => en(e, t, Oe())),
nn = () => [],
rn = r(2, (e, t) => e.map(t)),
an = r(2, (e, t) => {
let n = Kt(e);
if (Xt(n)) {
let e = [Qt(n)],
r = $t(n);
for (let n of r) e.every((e) => !t(n, e)) && e.push(n);
return e;
}
return [];
}),
on = `~effect/BigDecimal`,
sn = {
[on]: on,
[h]() {
let e = pn(this);
return _(g(e.value), re(e.scale));
},
[b](e) {
return cn(e) && _n(this, e);
},
toString() {
return `BigDecimal(${vn(this)})`;
},
toJSON() {
return { _id: `BigDecimal`, value: String(this.value), scale: this.scale };
},
[He]() {
return this.toJSON();
},
pipe() {
return e(this, arguments);
},
},
cn = (e) => m(e, on),
ln = (e, t) => {
let n = Object.create(sn);
return ((n.value = e), (n.scale = t), n);
},
un = (e, t) => {
if (e !== P && e % dn === P) throw RangeError(`Value must be normalized`);
let n = ln(e, t);
return ((n.normalized = n), n);
},
P = BigInt(0),
dn = BigInt(10),
fn = un(P, 0),
pn = (e) => {
if (e.normalized === void 0)
if (e.value === P) e.normalized = fn;
else {
let t = `${e.value}`,
n = 0;
for (let e = t.length - 1; e >= 0 && t[e] === `0`; e--) n++;
n === 0 && (e.normalized = e);
let r = BigInt(t.substring(0, t.length - n)),
i = e.scale - n;
e.normalized = un(r, i);
}
return e.normalized;
},
mn = r(2, (e, t) =>
t > e.scale
? ln(e.value * dn ** BigInt(t - e.scale), t)
: t < e.scale
? ln(e.value / dn ** BigInt(e.scale - t), t)
: e,
),
hn = (e) => (e.value < P ? ln(-e.value, e.scale) : e),
gn = ke((e, t) =>
e.scale > t.scale
? mn(t, e.scale).value === e.value
: e.scale < t.scale
? mn(e, t.scale).value === t.value
: e.value === t.value,
),
_n = r(2, (e, t) => gn(e, t)),
vn = (e) => {
let t = pn(e);
if (Math.abs(t.scale) >= 16) return yn(t);
let n = t.value < P,
r = n ? `${t.value}`.substring(1) : `${t.value}`,
i,
a;
if (t.scale >= r.length) ((i = `0`), (a = `0`.repeat(t.scale - r.length) + r));
else {
let e = r.length - t.scale;
if (e > r.length) {
let t = e - r.length;
((i = `${r}${`0`.repeat(t)}`), (a = ``));
} else ((a = r.slice(e)), (i = r.slice(0, e)));
}
let o = a === `` ? i : `${i}.${a}`;
return n ? `-${o}` : o;
},
yn = (e) => {
if (bn(e)) return `0e+0`;
let t = pn(e),
n = `${hn(t).value}`,
r = n.slice(0, 1),
i = n.slice(1),
a = `${xn(t) ? `-` : ``}${r}`;
i !== `` && (a += `.${i}`);
let o = i.length - t.scale;
return `${a}e${o >= 0 ? `+` : ``}${o}`;
},
bn = (e) => e.value === P,
xn = (e) => e.value < P,
Sn = (e) => _t({ op: e.label, [E]: e.evaluate }),
Cn = Object.getOwnPropertyDescriptor,
wn = Object.prototype.hasOwnProperty,
Tn = Object.isExtensible,
En = (() => {
let e = Cn(Error, `stackTraceLimit`);
return e === void 0 ? Tn(Error) : wn.call(e, `writable`) ? e.writable === !0 : e.set !== void 0;
})(),
Dn = () => Error.stackTraceLimit,
On = (e) => {
En && (Error.stackTraceLimit = e);
},
kn = `~effect/Context/Service`,
An = function () {
let e = Dn();
On(2);
let t = Error();
On(e);
function n() {}
let r = n;
return (
Object.setPrototypeOf(r, jn),
Object.defineProperty(r, "stack", {
get() {
return t.stack;
},
}),
arguments.length > 0
? ((r.key = arguments[0]),
arguments[1]?.defaultValue &&
((r[Mn] = Mn), (r.defaultValue = arguments[1].defaultValue)),
r)
: function (e, t) {
return ((r.key = e), t?.make && (r.make = t.make), r);
}
);
},
jn = {
[kn]: kn,
...Sn({
label: `Service`,
evaluate(e) {
return A(Vn(e.context, this));
},
}),
toJSON() {
return { _id: `Service`, key: this.key, stack: this.stack };
},
of(e) {
return e;
},
context(e) {
return zn(this, e);
},
use(e) {
return Ct((t) => e(Vn(t.context, this)));
},
useSync(e) {
return Ct((t) => A(e(Vn(t.context, this))));
},
},
Mn = `~effect/Context/Reference`,
Nn = `~effect/Context`,
Pn = (e) => {
let t = Object.create(Fn);
return ((t.mapUnsafe = e), (t.mutable = !1), t);
},
Fn = {
...Ze,
[Nn]: { _Services: (e) => e },
toJSON() {
return {
_id: `Context`,
services: Array.from(this.mapUnsafe).map(([e, t]) => ({ key: e, value: t })),
};
},
[b](e) {
if (!In(e) || this.mapUnsafe.size !== e.mapUnsafe.size) return !1;
for (let t of this.mapUnsafe.keys())
if (!e.mapUnsafe.has(t) || !x(this.mapUnsafe.get(t), e.mapUnsafe.get(t))) return !1;
return !0;
},
[h]() {
return re(this.mapUnsafe.size);
},
},
In = (e) => m(e, Nn),
Ln = () => Rn,
Rn = Pn(new Map()),
zn = (e, t) => Pn(new Map([[e.key, t]])),
Bn = r(3, (e, t, n) =>
Kn(e, (e) => {
e.set(t.key, n);
}),
),
Vn = r(2, (e, t) => {
if (!e.mapUnsafe.has(t.key)) {
if (Mn in t) return Wn(t);
throw Gn(t);
}
return e.mapUnsafe.get(t.key);
}),
Hn = (e, t) => (e.mapUnsafe.has(t.key) ? e.mapUnsafe.get(t.key) : Wn(t)),
Un = `~effect/Context/defaultValue`,
Wn = (e) => (Un in e ? e[Un] : (e[Un] = e.defaultValue())),
Gn = (e) => {
let t = Error(`Service not found${e.key ? `: ${String(e.key)}` : ``}`);
if (e.stack) {
let n = e.stack.split(`
`);
if (n.length > 2) {
let e = n[2].match(/at (.*)/);
e && (t.message += ` (defined at ${e[1]})`);
}
}
if (t.stack) {
let e = t.stack.split(`
`);
(e.splice(1, 3),
(t.stack = e.join(`
`)));
}
return t;
},
Kn = (e, t) => {
if (e.mutable) return (t(e.mapUnsafe), e);
let n = new Map(e.mapUnsafe);
return (t(n), Pn(n));
},
qn = An,
Jn = qn(`effect/Scheduler`, { defaultValue: () => new Zn() }),
Yn =
`setImmediate` in globalThis
? (e) => {
let t = globalThis.setImmediate(e);
return () => globalThis.clearImmediate(t);
}
: (e) => {
let t = setTimeout(e, 0);
return () => clearTimeout(t);
};
var Xn = class {
buckets = [];
scheduleTask(e, t) {
let n = this.buckets,
r = n.length,
i,
a = 0;
for (; a < r && !(n[a][0] > t); a++) i = n[a];
i && i[0] === t ? i[1].push(e) : a === r ? n.push([t, [e]]) : n.splice(a, 0, [t, [e]]);
}
drain() {
let e = this.buckets;
return ((this.buckets = []), e);
}
},
Zn = class {
executionMode;
setImmediate;
constructor(e = `async`, t = Yn) {
((this.executionMode = e), (this.setImmediate = t));
}
shouldYield(e) {
return e.currentOpCount >= e.maxOpsBeforeYield;
}
makeDispatcher() {
return new Qn(this.setImmediate);
}
},
Qn = class {
tasks = new Xn();
running = void 0;
setImmediate;
constructor(e = Yn) {
this.setImmediate = e;
}
scheduleTask(e, t) {
(this.tasks.scheduleTask(e, t),
this.running === void 0 && (this.running = this.setImmediate(this.afterScheduled)));
}
afterScheduled = () => {
((this.running = void 0), this.runTasks());
};
runTasks() {
let e = this.tasks.drain();
for (let t = 0; t < e.length; t++) {
let n = e[t][1];
for (let e = 0; e < n.length; e++) n[e]();
}
}
flush() {
for (; this.tasks.buckets.length > 0;)
(this.running !== void 0 && (this.running(), (this.running = void 0)), this.runTasks());
}
};
const $n = qn(`effect/Scheduler/MaxOpsBeforeYield`, { defaultValue: () => 2048 }),
er = qn(`effect/Scheduler/PreventSchedulerYield`, { defaultValue: () => !1 }),
tr = `effect/Tracer/ParentSpan`;
An()(tr);
const nr = qn(`effect/References/CurrentStackFrame`, { defaultValue: a }),
rr = qn(`effect/References/CurrentLogLevel`, { defaultValue: () => `Info` }),
ir = qn(`effect/References/MinimumLogLevel`, { defaultValue: () => `Info` });
var ar = class extends at {
fiberId;
constructor(e, t = ot) {
(super(`Interrupt`, t, `Interrupted`), (this.fiberId = e));
}
toString() {
return `Interrupt(${this.fiberId})`;
}
toJSON() {
return { _tag: `Interrupt`, fiberId: this.fiberId };
}
[b](e) {
return ht(e) && this.fiberId === e.fiberId && this.annotations === e.annotations;
}
[h]() {
return _(y(`${this._tag}:${this.fiberId}`))(te(this.annotations));
}
};
const or = (e) => new rt([new ar(e)]),
sr = (e) => e.reasons.some(ht),
cr = r(2, (e, t) => {
if (e.reasons.length === 0) return t;
if (t.reasons.length === 0) return e;
let n = new rt(tn(e.reasons, t.reasons));
return x(e, n) ? e : n;
}),
lr = r(2, (e, t) => {
let n = !1,
r = e.reasons.map((e) => (pt(e) ? ((n = !0), new st(t(e.error))) : e));
return n ? ct(r) : e;
}),
ur = `~effect/Fiber/dev`,
dr = { _A: i, _E: i },
fr = { id: 0 },
pr = () => globalThis[Fe];
var mr = class {
constructor(e, t = !0) {
((this[ur] = dr),
this.setContext(e),
(this.id = ++fr.id),
(this.currentOpCount = 0),
(this.interruptible = t),
(this._stack = []),
(this._observers = []),
(this._exit = void 0),
(this._children = void 0),
(this._interruptedCause = void 0),
(this._yielded = void 0),
(this._running = !1),
(this._deferredInterrupt = !1),
this.runtimeMetrics?.recordFiberStart(this.context));
}
[ur];
id;
interruptible;
currentOpCount;
_stack;
_observers;
_exit;
_children;
_interruptedCause;
_yielded;
_running;
_deferredInterrupt;
context;
currentScheduler;
currentTracerContext;
currentSpan;
currentLogLevel;
minimumLogLevel;
currentStackFrame;
runtimeMetrics;
maxOpsBeforeYield;
currentPreventYield;
_dispatcher = void 0;
get currentDispatcher() {
return (this._dispatcher ??= this.currentScheduler.makeDispatcher());
}
getRef(e) {
return Hn(this.context, e);
}
addObserver(e) {
return this._exit
? (e(this._exit), o)
: (this._observers.push(e),
() => {
let t = this._observers.indexOf(e);
t >= 0 && this._observers.splice(t, 1);
});
}
interruptUnsafe(e, t) {
if (this._exit) return;
let n = or(e);
(this.currentStackFrame && (n = ft(n, zn(yt, this.currentStackFrame))),
t && (n = ft(n, t)),
(this._interruptedCause = this._interruptedCause ? cr(this._interruptedCause, n) : n),
this.interruptible &&
(this._running
? (this._deferredInterrupt = !0)
: this.evaluate(I(this._interruptedCause))));
}
pollUnsafe() {
return this._exit;
}
evaluate(e) {
if (this._exit) return;
if (this._yielded !== void 0) {
let e = this._yielded;
((this._yielded = void 0), e());
}
let t = this.runLoop(e);
if (t === Xe) return;
let n = gr.interruptChildren && gr.interruptChildren(this);
if (n !== void 0) return this.evaluate(L(n, () => t));
((this._exit = t), this.runtimeMetrics?.recordFiberEnd(this.context, this._exit));
for (let e = 0; e < this._observers.length; e++) this._observers[e](t);
((this._observers.length = 0),
(this._stack.length = 0),
(this._children = void 0),
(this.context = Ln()));
}
runLoop(e) {
let t = globalThis[Fe];
globalThis[Fe] = this;
let n = this._running;
this._running = !0;
let r = !1,
i = e;
this.currentOpCount = 0;
try {
for (;;) {
if (
(this._deferredInterrupt &&
((this._deferredInterrupt = !1), (i = I(this._interruptedCause))),
this.currentOpCount++,
!r && !this.currentPreventYield && this.currentScheduler.shouldYield(this))
) {
r = !0;
let e = i;
i = L(Cr, () => e);
}
if (
((i = this.currentTracerContext ? this.currentTracerContext(i, this) : i[E](this)),
i === Xe)
) {
let e = this._yielded;
if (Ke in e) return ((this._deferredInterrupt = !1), (this._yielded = void 0), e);
if (this._deferredInterrupt) {
((this._yielded = void 0), e());
continue;
}
return Xe;
}
}
} catch (e) {
return m(i, E) ? this.runLoop(St(e)) : St(`Fiber.runLoop: Not a valid effect: ${String(i)}`);
} finally {
((this._running = n), (globalThis[Fe] = t));
}
}
getCont(e) {
if (this._deferredInterrupt) return ((this._deferredInterrupt = !1), hr);
for (;;) {
let t = this._stack.pop();
if (!t) return;
let n = t[Ye] && t[Ye](this);
if (n) return ((n[e] = n), n);
if (t[e]) return t;
}
}
yieldWith(e) {
return ((this._yielded = e), Xe);
}
children() {
return (this._children ??= new Set());
}
pipe() {
return e(this, arguments);
}
setContext(e) {
this.context = e;
let t = this.getRef(Jn);
(t !== this.currentScheduler && ((this.currentScheduler = t), (this._dispatcher = void 0)),
(this.currentSpan = e.mapUnsafe.get(tr)),
(this.currentLogLevel = this.getRef(rr)),
(this.minimumLogLevel = this.getRef(ir)),
(this.currentStackFrame = e.mapUnsafe.get(nr.key)),
(this.maxOpsBeforeYield = this.getRef($n)),
(this.currentPreventYield = this.getRef(er)),
(this.runtimeMetrics = e.mapUnsafe.get(
`effect/observability/Metric/FiberRuntimeMetricsKey`,
)));
let n = e.mapUnsafe.get(`effect/Tracer`);
this.currentTracerContext = n ? n.context : void 0;
}
get currentSpanLocal() {
return this.currentSpan?._tag === `Span` ? this.currentSpan : void 0;
}
};
const hr = {
[D](e, t) {
return I(t._interruptedCause);
},
[O](e, t) {
return I(t._interruptedCause);
},
},
gr = { interruptChildren: void 0 },
_r = (e) => {
if (!e.currentStackFrame) return;
let t = new Map();
return (t.set(bt.key, e.currentStackFrame), Pn(t));
},
vr = (e) =>
jr((t) => {
let n = e[Symbol.iterator](),
r = [],
i;
function a() {
let e = n.next();
for (; !e.done;) {
if (e.value._exit) {
(r.push(e.value._exit), (e = n.next()));
continue;
}
i = e.value.addObserver((e) => {
(r.push(e), a());
});
return;
}
t(F(r));
}
return (a(), xr(() => i?.()));
}),
yr = (e) =>
Ct((t) => {
let n = _r(t),
r = nn();
for (let i of e) (i.interruptUnsafe(t.id, n), r.push(i));
return Ir(vr(r));
}),
F = A,
I = j,
br = xt,
xr = k({
op: `Sync`,
[E](e) {
let t = this[T](),
n = e.getCont(D);
return n ? n[D](t, e) : e.yieldWith(A(t));
},
}),
Sr = k({
op: `Suspend`,
[E](e) {
return this[T]();
},
}),
Cr = k({
op: `Yield`,
[E](e) {
let t = !1;
return (
e.currentDispatcher.scheduleTask(() => {
t || e.evaluate(Hr);
}, this[T] ?? 0),
e.yieldWith(() => {
t = !0;
})
);
},
})(0),
wr = (e) => F(N(e)),
Tr = F(Vt()),
Er = (e) => Sr(() => I(Ge(e))),
Dr = (e) => St(e),
Or = F(void 0),
kr = k({
op: `Async`,
single: !1,
[E](e) {
let t = Ge(() => this[T][0].bind(e.currentScheduler)),
n = !1,
r = !1,
i = this[T][1] ? new AbortController() : void 0,
a = t((t) => {
n || ((n = !0), r ? e.evaluate(t) : (r = t));
}, i?.signal);
return r === !1
? ((r = !0),
(e._yielded = () => {
n = !0;
}),
(i === void 0 && a === void 0) ||
e._stack.push(Ar(() => ((n = !0), i?.abort(), a ?? Hr))),
Xe)
: r;
},
}),
Ar = k({
op: `AsyncFinalizer`,
[Ye](e) {
e.interruptible && ((e.interruptible = !1), e._stack.push(Yr));
},
[O](e, t) {
return sr(e) ? L(this[T](), () => I(e)) : I(e);
},
}),
jr = (e) => kr(e, e.length >= 2),
Mr = (e, t) => Object.defineProperty(t, "length", { value: e, configurable: !0 }),
Nr = (e, ...t) =>
Mr(
e.length,
t.length === 0
? function () {
return Pr(() => e.apply(this, arguments));
}
: function () {
let n = Pr(() => e.apply(this, arguments));
for (let e of t) n = e(n);
return n;
},
),
Pr = (e) => {
try {
let t = e(),
n;
for (;;) {
let r = t.next(n);
if (r.done) return F(r.value);
let i = r.value;
if (i && i._tag === `Success`) {
n = i.value;
continue;
} else if (i && i._tag === `Failure`) return r.value;
else {
let n = !0;
return Sr(() => (n ? ((n = !1), L(r.value, (e) => Fr(t, e))) : Sr(() => Fr(e()))));
}
}
} catch (e) {
return Dr(e);
}
},
Fr = k({
op: `Iterator`,
single: !1,
[D](e, t) {
let n = this[T][0];
for (;;) {
let r = n.next(e);
if (r.done) return F(r.value);
if (!R(r.value)) return (t._stack.push(this), r.value);
if (r.value._tag === `Failure`) return r.value;
e = r.value.value;
}
},
[E](e) {
return this[D](this[T][1], e);
},
}),
Ir = (e) => L(e, (e) => Hr),
L = r(2, (e, t) => {
let n = Object.create(Lr);
return ((n[T] = e), (n[D] = t.length === 1 ? t : (e) => t(e)), n);
}),
Lr = _t({
op: `OnSuccess`,
[E](e) {
return (e._stack.push(this), this[T]);
},
}),
R = (e) => Ke in e,
Rr = r(2, (e, t) => (R(e) ? (e._tag === `Success` ? t(e.value) : e) : L(e, t))),
zr = r(2, (e, t) => L(e, (e) => F(Ge(() => t(e))))),
Br = r(2, (e, t) => (R(e) ? Ur(e, t) : zr(e, t))),
Vr = (e) => e._tag === `Success`,
Hr = A(void 0),
Ur = r(2, (e, t) => (e._tag === `Success` ? A(t(e.value)) : e)),
Wr = r(2, (e, t) => {
let n = Object.create(Gr);
return ((n[T] = e), (n[O] = t.length === 1 ? t : (e) => t(e)), n);
}),
Gr = _t({
op: `OnFailure`,
[E](e) {
return (e._stack.push(this), this[T]);
},
}),
Kr = (e) => (R(e) ? A(e) : qr(e)),
qr = k({
op: `Exit`,
[E](e) {
return (e._stack.push(this), this[T]);
},
[D](e, t, n) {
return F(n ?? A(e));
},
[O](e, t, n) {
return F(n ?? j(e));
},
}),
Jr = (e) => Ct((t) => (t.interruptible ? ((t.interruptible = !1), t._stack.push(Yr), e) : e)),
Yr = k({
op: `SetInterruptible`,
[Ye](e) {
if (((e.interruptible = this[T]), e._interruptedCause && e.interruptible))
return () => I(e._interruptedCause);
},
})(!0),
Xr = (e) => {
let t = e.onItem,
n = e.step;
return (e, r, i) => {
let a = i?.start ?? 0,
o = i?.end ?? r.length,
s = i?.concurrency ?? 1,
c = i?.orderedStep === !0 && s > 1,
l = !1,
u,
d,
f,
ee = !1,
p,
m,
h = a,
g = c ? Array(o) : void 0,
te = (e) => {
let t = St(e);
return (
(p = t), (l = !0), (ee = !0), d && d.size > 0 ? L(Jr(yr(Array.from(d))), () => t) : t
);
},
_ = (t, i, a) => {
if (!c) return n(e, t, i, a);
if (p) return p;
for (g[a] = i; h < o;) {
let t = g[h];
if (t === void 0) return;
g[h] = void 0;
let i = h++,
a = n(e, r[i], t, i);
if (a) return a;
}
},
v = () => {
let n = !1;
for (; !p && a < o; a++) {
let i = r[a],
o = m ?? t(e, i, a);
if (R(o)) {
if (((p = _(i, o, a)), p)) break;
} else if (s === 1) return L(Kr(o), (e) => ((p = _(i, e, a)), a++, p ?? v() ?? Or));
else if (u) {
m = void 0;
let e = Qr(u, o, !0, !0, `inherit`);
if (e._exit) {
if (((p = _(i, e._exit, a)), p)) break;
continue;
}
d.add(e);
let t = a;
if (
(e.addObserver((r) => {
d.delete(e);
try {
if (p) {
if (!ee && r._tag === `Failure`)
for (let e of r.cause.reasons)
if (e._tag === `Interrupt`) continue;
else p._tag === `Failure` ? p.cause.reasons.push(e) : (p = j(ct([e])));
} else {
let e = _(i, r, t);
e && ((p = e._tag === `Failure` ? j(ct(e.cause.reasons.slice())) : e), v());
}
if (n) {
let e = v();
e && f(e);
} else l && d.size === 0 && f(p ?? Or);
} catch (e) {
f(te(e));
}
}),
d.size < s)
)
continue;
((n = !0), a++);
return;
} else
return jr((e) => {
((u = pr()), (d = new Set()), (m = o), (f = e));
let t;
try {
t = v();
} catch (t) {
return e(te(t));
}
return t ? e(t) : Sr(() => ((p = Hr), (ee = !0), d ? yr(d) : Or));
});
}
if (((l = !0), p)) {
if (d && d.size > 0) {
let e = _r(u);
d.forEach((t) => t.interruptUnsafe(u.id, e));
return;
}
if (f || p._tag === `Failure`) return p;
} else if (f)
if (d) d.size === 0 && f(Or);
else return Hr;
};
return v();
};
},
Zr = () => Xr,
Qr = (e, t, n = !1, r = !1, i = !1) => {
let a = i === `inherit` ? e.interruptible : !i,
o = new mr(e.context, a);
return (
n ? o.evaluate(t) : e.currentDispatcher.scheduleTask(() => o.evaluate(t), 0),
!r && !o._exit && (e.children().add(o), o.addObserver(() => e._children.delete(o))),
o
);
},
$r = (e) => (t, n) => {
let r = new mr(n?.scheduler ? Bn(e, Jn, n.scheduler) : e, n?.uninterruptible !== !0);
if ((r.evaluate(t), r._exit)) return r;
if (n?.signal)
if (n.signal.aborted) r.interruptUnsafe();
else {
let e = () => r.interruptUnsafe();
(n.signal.addEventListener(`abort`, e, { once: !0 }),
r.addObserver(() => n.signal.removeEventListener(`abort`, e)));
}
return (n?.onFiberStart && n.onFiberStart(r), r);
},
ei = ((e) => {
let t = $r(e);
return (e) => {
if (R(e)) return e;
let n = new Zn(`sync`),
r = t(e, { scheduler: n });
return (r._dispatcher?.flush(), r._exit ?? St(new ni(r)));
};
})(Ln());
(M(`TimeoutError`), M(`IllegalArgumentError`), M(`ExceededCapacityError`));
const ti = `~effect/Cause/AsyncFiberError`;
var ni = class extends M(`AsyncFiberError`) {
[ti] = ti;
constructor(e) {
super({ message: `An asynchronous Effect was executed with Effect.runSync`, fiber: e });
}
};
M(`UnknownError`);
const z = {
bold: `1`,
red: `31`,
green: `32`,
yellow: `33`,
blue: `34`,
cyan: `36`,
white: `37`,
gray: `90`,
black: `30`,
bgBrightRed: `101`,
};
(z.gray, z.blue, z.green, z.yellow, z.red, z.bgBrightRed, z.black);
const ri = pt,
ii = lr;
(An()(`effect/Cause/StackTrace`),
An()(`effect/Cause/InterruptorStackTrace`),
class extends n {
constructor(e) {
(super(), e && Object.assign(this, e));
}
});
const ai = M,
oi = j,
si = xt,
ci = Hr,
li = Vr,
ui = `~effect/time/DateTime`,
di = `~effect/time/DateTime/TimeZone`,
fi = {
[ui]: ui,
pipe() {
return e(this, arguments);
},
[He]() {
return this.toString();
},
toJSON() {
return mi(this).toJSON();
},
};
(({ ...fi }), { ...fi });
const pi = {
[di]: di,
[He]() {
return this.toString();
},
};
(({ ...pi }), { ...pi });
const mi = (e) => new Date(e.epochMilliseconds),
B = F,
hi = Tr,
gi = wr,
V = br,
_i = Er,
vi = L,
yi = Kr,
bi = Wr,
xi = ei;
An()(`effect/Effect/Transaction`);
const Si = Br,
H = Rr,
Ci = Nr;
(An()(`effect/DateTime/CurrentTimeZone`), ai(`EncodingError`));
function wi(e, t, n) {
return (
t === `__proto__`
? Object.defineProperty(e, t, { value: n, writable: !0, enumerable: !0, configurable: !0 })
: (e[t] = n),
e
);
}
function Ti(e) {
return e.checks ? e.checks[e.checks.length - 1].annotations : e.annotations;
}
function Ei(e) {
return (t) => Ti(t)?.[e];
}
const Di = Ei(`identifier`),
Oi = s((e) => {
let t = Di(e);
return typeof t == `string` ? t : e.getExpected(Oi);
}),
ki = `~effect/SchemaIssue/Issue`;
function Ai(e) {
return m(e, ki);
}
var U = class {
[ki] = ki;
toString() {
return Ji(this);
}
},
ji = class extends U {
_tag = `Filter`;
actual;
filter;
issue;
constructor(e, t, n) {
(super(), (this.actual = e), (this.filter = t), (this.issue = n));
}
},
Mi = class extends U {
_tag = `Encoding`;
ast;
actual;
issue;
constructor(e, t, n) {
(super(), (this.ast = e), (this.actual = t), (this.issue = n));
}
},
W = class extends U {
_tag = `Pointer`;
path;
issue;
constructor(e, t) {
(super(), (this.path = e), (this.issue = t));
}
},
Ni = class extends U {
_tag = `MissingKey`;
annotations;
constructor(e) {
(super(), (this.annotations = e));
}
},
Pi = class extends U {
_tag = `UnexpectedKey`;
ast;
actual;
constructor(e, t) {
(super(), (this.ast = e), (this.actual = t));
}
},
G = class extends U {
_tag = `Composite`;
ast;
actual;
issues;
constructor(e, t, n) {
(super(), (this.ast = e), (this.actual = t), (this.issues = n));
}
},
Fi = class extends U {
_tag = `InvalidType`;
ast;
actual;
constructor(e, t) {
(super(), (this.ast = e), (this.actual = t));
}
},
Ii = class extends U {
_tag = `InvalidValue`;
actual;
annotations;
constructor(e, t) {
(super(), (this.actual = e), (this.annotations = t));
}
},
Li = class extends U {
_tag = `AnyOf`;
ast;
actual;
issues;
constructor(e, t, n) {
(super(), (this.ast = e), (this.actual = t), (this.issues = n));
}
},
Ri = class extends U {
_tag = `OneOf`;
ast;
actual;
successes;
constructor(e, t, n) {
(super(), (this.ast = e), (this.actual = t), (this.successes = n));
}
};
function zi(e, t) {
if (Ai(t)) return t;
if (typeof t == `string`) return new Ii(N(e), { message: t });
let n = typeof t.issue == `string` ? new Ii(N(e), { message: t.issue }) : t.issue;
return new W(t.path, n);
}
function Bi(e, t) {
if (t !== void 0) return typeof t == `boolean` ? (t ? void 0 : new Ii(N(e))) : zi(e, t);
}
function Vi(e, t, n) {
return Array.isArray(n)
? Xt(n)
? n.length === 1
? zi(e, n[0])
: new G(
t,
N(e),
rn(n, (t) => zi(e, t)),
)
: void 0
: Bi(e, n);
}
const Hi = (e) => {
let t = Xi(e);
if (t !== void 0) return t;
switch (e._tag) {
case `InvalidType`:
return Wi(Oi(e.ast), Qi(e.actual));
case `InvalidValue`:
return `Invalid data ${Qi(e.actual)}`;
case `MissingKey`:
return `Missing key`;
case `UnexpectedKey`:
return `Unexpected key with value ${C(e.actual)}`;
case `Forbidden`:
return `Forbidden operation`;
case `OneOf`:
return `Expected exactly one member to match the input ${C(e.actual)}`;
}
},
Ui = (e) => Xi(e.issue) ?? Xi(e);
function Wi(e, t) {
return `Expected ${e}, got ${t}`;
}
function Gi(e, t, n, r) {
switch (e._tag) {
case `Filter`: {
let i = r(e);
if (i !== void 0) return [{ path: t, message: i }];
switch (e.issue._tag) {
case `InvalidValue`:
return [{ path: t, message: Wi(Ki(e.filter), C(e.actual)) }];
default:
return Gi(e.issue, t, n, r);
}
}
case `Encoding`:
return Gi(e.issue, t, n, r);
case `Pointer`:
return Gi(e.issue, [...t, ...e.path], n, r);
case `Composite`:
return e.issues.flatMap((e) => Gi(e, t, n, r));
case `AnyOf`: {
let i = Xi(e);
return e.issues.length === 0
? i === void 0
? [{ path: t, message: Wi(Oi(e.ast), C(e.actual)) }]
: [{ path: t, message: i }]
: e.issues.flatMap((e) => Gi(e, t, n, r));
}
default:
return [{ path: t, message: n(e) }];
}
}
function Ki(e) {
let t = e.annotations?.expected;
if (typeof t == `string`) return t;
switch (e._tag) {
case `Filter`:
return `<filter>`;
case `FilterGroup`:
return e.checks.map((e) => Ki(e)).join(` & `);
}
}
function qi() {
return (e) =>
Gi(e, [], Hi, Ui).map(Yi).join(`
`);
}
const Ji = qi();
function Yi(e) {
let t = e.message;
if (e.path && e.path.length > 0) {
let n = ze(e.path);
t += `\n at ${n}`;
}
return t;
}
function Xi(e) {
switch (e._tag) {
case `InvalidType`:
case `OneOf`:
case `Composite`:
case `AnyOf`:
return Zi(e.ast.annotations);
case `InvalidValue`:
case `Forbidden`:
return Zi(e.annotations);
case `MissingKey`:
return Zi(e.annotations, `messageMissingKey`);
case `UnexpectedKey`:
return Zi(e.ast.annotations, `messageUnexpectedKey`);
case `Filter`:
return Zi(e.filter.annotations);
case `Encoding`:
return Xi(e.issue);
}
}
function Zi(e, t = `message`) {
let n = e?.[t];
if (typeof n == `string`) return n;
}
function Qi(e) {
return Ht(e) ? `no value provided` : C(e.value);
}
function $i(e) {
let t;
for (let n of e.reasons) {
if (!ri(n) || !Ai(n.error)) return;
t ??= n.error;
}
return t;
}
function ea(e, t) {
let n = $i(e);
if (n === void 0) throw Error(t, { cause: e });
return n;
}
var ta = class e extends n {
run;
constructor(e) {
(super(), (this.run = e));
}
map(t) {
return new e((e, n) => this.run(e, n).pipe(Si(Wt(t))));
}
compose(t) {
return ra(this)
? t
: ra(t)
? this
: new e((e, n) => this.run(e, n).pipe(H((e) => t.run(e, n))));
}
};
const na = new ta(B);
function ra(e) {
return e.run === na.run;
}
function ia() {
return na;
}
function K(e) {
return aa(Wt(e));
}
function aa(e) {
return new ta((t) => B(e(t)));
}
function oa() {
return K(globalThis.String);
}
function sa() {
return K(globalThis.Number);
}
const ca = `~effect/SchemaTransformation/Transformation`;
var la = class e {
[ca] = ca;
_tag = `Transformation`;
decode;
encode;
constructor(e, t) {
((this.decode = e), (this.encode = t));
}
flip() {
return new e(this.encode, this.decode);
}
compose(t) {
return new e(this.decode.compose(t.decode), t.encode.compose(this.encode));
}
};
function ua(e) {
return m(e, ca);
}
const da = (e) => (ua(e) ? e : new la(e.decode, e.encode)),
fa = new la(ia(), ia());
function pa() {
return fa;
}
const ma = new la(sa(), oa());
function ha(e) {
return (t) => t._tag === e;
}
const ga = ha(`Declaration`),
_a = ha(`Never`),
va = ha(`Literal`),
ya = ha(`UniqueSymbol`),
ba = ha(`Arrays`),
xa = ha(`Objects`);
var q = class {
to;
transformation;
constructor(e, t) {
((this.to = e), (this.transformation = t));
}
};
const Sa = {};
var Ca = class {
isOptional;
isMutable;
defaultValue;
annotations;
constructor(e, t, n = void 0, r = void 0) {
((this.isOptional = e), (this.isMutable = t), (this.defaultValue = n), (this.annotations = r));
}
};
const wa = `~effect/Schema`;
var J = class {
[wa] = wa;
annotations;
checks;
encoding;
context;
constructor(e = void 0, t = void 0, n = void 0, r = void 0) {
((this.annotations = e), (this.checks = t), (this.encoding = n), (this.context = r));
}
toString() {
return `<${this._tag}>`;
}
},
Ta = class e extends J {
_tag = `Declaration`;
typeParameters;
run;
encodingChecks;
constructor(e, t, n, r, i, a, o) {
(super(n, r, i, a), (this.typeParameters = e), (this.run = t), (this.encodingChecks = o));
}
getParser() {
let e = this.run(this.typeParameters);
return (t, n) => (Ht(t) ? hi : Si(e(t.value, this, n), N));
}
_rebuild(t, n, r) {
let i = Co(this.typeParameters, t);
return i === this.typeParameters && n === this.checks && r === this.encodingChecks
? this
: new e(i, this.run, this.annotations, n, void 0, this.context, r);
}
recur(e) {
return this._rebuild(e, this.checks, this.encodingChecks);
}
flip(e) {
return this._rebuild(e, this.encodingChecks, this.checks);
}
getExpected() {
let e = this.annotations?.expected;
return typeof e == `string` ? e : `<Declaration>`;
}
};
const Ea = new (class extends J {
_tag = `Null`;
getParser() {
return jo(this, null);
}
getExpected() {
return `null`;
}
})();
(class extends J {
_tag = `Undefined`;
getParser() {
return jo(this, void 0);
}
toCodecJson() {
return Y(this, [Da]);
}
getExpected() {
return `undefined`;
}
});
const Da = new q(
Ea,
new la(
K(() => void 0),
K(() => null),
),
);
var Oa = class extends J {
_tag = `Literal`;
literal;
constructor(e, t, n, r, i) {
if ((super(t, n, r, i), typeof e == `number` && !globalThis.Number.isFinite(e)))
throw Error(`A numeric literal must be finite, got ${C(e)}`);
this.literal = e;
}
getParser() {
return jo(this, this.literal);
}
matchPart(e, t) {
return e === globalThis.String(this.literal) ? this.literal : void 0;
}
toCodecJson() {
return typeof this.literal == `bigint` ? ka(this) : this;
}
toCodecStringTree() {
return typeof this.literal == `string` ? this : ka(this);
}
getExpected() {
return typeof this.literal == `string`
? JSON.stringify(this.literal)
: globalThis.String(this.literal);
}
};
function ka(e) {
let t = globalThis.String(e.literal);
return Y(e, [
new q(
new Oa(t),
new la(
K(() => e.literal),
K(() => t),
),
),
]);
}
const Aa = new (class extends J {
_tag = `String`;
getParser() {
return Mo(this, u);
}
matchPart(e, t) {
return No(this, e, t);
}
getExpected() {
return `string`;
}
})();
var ja = class extends J {
_tag = `Number`;
getParser() {
return Mo(this, d);
}
matchKey(e, t) {
return this._match(Io, e, t);
}
matchPart(e, t) {
return this._match(Fo, e, t);
}
_match(e, t, n) {
return e.test(t) ? No(this, globalThis.Number(t), n) : void 0;
}
toCodecJson() {
return this.checks && (Ma(this.checks, `isFinite`) || Ma(this.checks, `isInt`))
? this
: Y(this, [so]);
}
toCodecStringTree() {
return this.checks && (Ma(this.checks, `isFinite`) || Ma(this.checks, `isInt`))
? Y(this, [zo])
: Y(this, [Bo]);
}
getExpected() {
return `number`;
}
};
function Ma(e, t) {
return e.some((e) => {
switch (e._tag) {
case `Filter`:
return e.annotations?.meta?._tag === t;
case `FilterGroup`:
return Ma(e.checks, t);
}
});
}
const Na = new ja();
var Pa = class e extends J {
_tag = `Arrays`;
isMutable;
elements;
rest;
encodingChecks;
constructor(e, t, n, r, i, a, o, s) {
(super(r, i, a, o),
(this.isMutable = e),
(this.elements = t),
(this.rest = n),
(this.encodingChecks = s));
let c = t.findIndex(X);
if (c !== -1 && (t.slice(c + 1).some((e) => !X(e)) || n.length > 1))
throw Error(`A required element cannot follow an optional element. ts(1257)`);
if (n.length > 1 && n.slice(1).some(X))
throw Error(`An optional element cannot follow a rest element. ts(1266)`);
}
getParser(e) {
let t = this,
n = t.elements.map((t) => ({ ast: t, parser: e(t) })),
r = t.rest.map((t) => ({ ast: t, parser: e(t) })),
i = n.length,
[a, ...o] = r,
s = o.length;
function c(e, t) {
return t < i ? n[t] : t >= e ? o[t - e] : a;
}
return Ci(function* (e, n) {
if (e._tag === `None`) return e;
let r = e.value;
if (!Array.isArray(r)) return yield* V(new Fi(t, e));
let a = r.length,
o = {
ast: t,
getParser: c,
oinput: e,
len: a,
tailThreshold: Ia(a, i, s),
output: new globalThis.Array(a),
issues: void 0,
options: n,
},
l = La(n?.concurrency),
u = Fa(o, r, {
concurrency: l?.concurrency,
end: t.rest.length === 0 ? i : Math.max(a, i + s),
});
if ((u && (yield* u), t.rest.length === 0 && a > i))
for (let s = i; s <= a - 1; s++) {
let i = new W([s], new Pi(t, r[s]));
if (n.errors === `all`) o.issues ? o.issues.push(i) : (o.issues = [i]);
else return yield* V(new G(t, e, [i]));
}
return o.issues ? yield* V(new G(t, e, o.issues)) : N(o.output);
});
}
_rebuild(t, n, r) {
let i = Co(this.elements, t),
a = Co(this.rest, t);
return i === this.elements && a === this.rest && n === this.checks && r === this.encodingChecks
? this
: new e(this.isMutable, i, a, this.annotations, n, void 0, this.context, r);
}
recur(e) {
return this._rebuild(e, this.checks, this.encodingChecks);
}
flip(e) {
return this._rebuild(e, this.encodingChecks, this.checks);
}
getExpected() {
return `array`;
}
};
const Fa = Zr()({
onItem(e, t, n) {
let r = n < e.len ? N(t) : Vt();
return e.getParser(e.tailThreshold, n).parser(r, e.options);
},
step(e, t, n, r) {
if (n._tag === `Failure`) return Ra(e, e.ast, r, n);
if (n.value._tag === `Some`) e.output[r] = n.value.value;
else {
let t = e.getParser(e.tailThreshold, r);
if (X(t.ast)) return;
let n = new W([r], new Ni(t.ast.context?.annotations));
if (e.options.errors === `all`) e.issues ? e.issues.push(n) : (e.issues = [n]);
else return si(new G(e.ast, e.oinput, [n]));
}
},
});
function Ia(e, t, n) {
return Math.max(t, e - n);
}
const La = (e) => ((e = e === `unbounded` ? 1 / 0 : (e ?? 1)), e > 1 ? { concurrency: e } : void 0),
Ra = (e, t, n, r) => {
if (r.cause.reasons.length === 0) return r;
let i = $i(r.cause);
if (i === void 0) return oi(ii(r.cause, (r) => new G(t, e.oinput, [new W([n], r)])));
let a = new W([n], i);
if (e.options.errors === `all`) e.issues ? e.issues.push(a) : (e.issues = [a]);
else return si(new G(t, e.oinput, [a]));
},
za = `[+-]?\\d*\\.?\\d+(?:[Ee][+-]?\\d+)?`;
function Ba(e, t, n = Sa) {
let r, i;
function a(t) {
switch (t._tag) {
case `String`:
case `TemplateLiteral`:
return (r ??= Object.keys(e)).filter((e) => t.matchPart(e, n) !== void 0);
case `Number`:
return (r ??= Object.keys(e)).filter((e) => t.matchKey(e, n) !== void 0);
case `Symbol`:
return (i ??= Object.getOwnPropertySymbols(e)).filter((e) => t.matchKey(e, n) !== void 0);
case `Union`:
return [...new Set(t.types.flatMap(a))];
default:
return [];
}
}
return a(Po(Do(t)));
}
var Va = class {
name;
type;
constructor(e, t) {
((this.name = e), (this.type = t));
}
};
function Ha(e) {
switch (e._tag) {
case `String`:
case `Number`:
case `Symbol`:
case `TemplateLiteral`:
return !0;
case `Union`:
return e.types.every(Ha);
default:
return !1;
}
}
function Ua(e) {
return Ha(e) && Ha(Do(e));
}
var Wa = class {
parameter;
type;
merge;
constructor(e, t, n) {
if (!Ua(e)) throw Error(`Invalid index signature parameter ${e._tag}`);
if (((this.parameter = e), (this.type = t), (this.merge = n), X(t) && !Ao(t)))
throw Error(
"Cannot use `Schema.optionalKey` with index signatures, use `Schema.optional` instead.",
);
}
},
Ga = class e extends J {
_tag = `Objects`;
propertySignatures;
indexSignatures;
encodingChecks;
constructor(e, t, n, r, i, a, o) {
(super(n, r, i, a),
(this.propertySignatures = e),
(this.indexSignatures = t),
(this.encodingChecks = o));
let s = e.map((e) => e.name).filter((e, t, n) => n.indexOf(e) !== t);
if (s.length > 0) throw Error(`Duplicate identifiers: ${JSON.stringify(s)}. ts(2300)`);
}
getParser(e) {
let t = this,
n = [],
r = new Set(),
i = [];
for (let a of t.propertySignatures)
(n.push(a.name),
r.add(a.name),
i.push({ ps: a, parser: e(a.type), name: a.name, type: a.type }));
let a = t.indexSignatures.length;
if (t.propertySignatures.length === 0 && t.indexSignatures.length === 0) return Mo(t, ee);
let o =
a > 0
? Zr()({
onItem: Ci(function* (n, [i, a]) {
let o = e(Po(a.parameter))(N(i), n.options),
s = R(o) ? o : yield* yi(o);
if (s._tag === `Failure`) {
let e = Ra(n, t, i, s);
e && (yield* e);
return;
}
let c = N(n.input[i]),
l = e(a.type)(c, n.options),
u = R(l) ? l : yield* yi(l);
if (u._tag === `Failure`) {
let e = Ra(n, t, i, u);
e && (yield* e);
return;
} else if (s.value._tag === `Some` && u.value._tag === `Some`) {
let e = s.value.value;
if (r.has(i) || r.has(e)) return;
let t = u.value.value;
if (a.merge && a.merge.decode && Object.hasOwn(n.out, e)) {
let [r, i] = a.merge.decode.combine([e, n.out[e]], [e, t]);
wi(n.out, r, i);
} else wi(n.out, e, t);
}
}),
step: (e, t, n) => (n._tag === `Failure` ? n : void 0),
})
: void 0;
return Ci(function* (e, s) {
if (e._tag === `None`) return e;
let c = e.value;
if (!(typeof c == `object` && c && !Array.isArray(c))) return yield* V(new Fi(t, e));
let l = {},
u = { ast: t, oinput: e, input: c, out: l, issues: void 0, options: s },
d = s.errors === `all`,
f = s.onExcessProperty === `error`,
ee = s.onExcessProperty === `preserve`,
p;
if (t.indexSignatures.length === 0 && (f || ee)) {
p = Reflect.ownKeys(c);
for (let n = 0; n < p.length; n++) {
let i = p[n];
if (!r.has(i))
if (f) {
let n = new W([i], new Pi(t, c[i]));
if (d) {
u.issues ? u.issues.push(n) : (u.issues = [n]);
continue;
} else return yield* V(new G(t, e, [n]));
} else wi(l, i, c[i]);
}
}
let m = La(s?.concurrency),
h = Ka(u, i, m);
if ((h && (yield* h), o)) {
let e = nn();
for (let n = 0; n < a; n++) {
let r = t.indexSignatures[n],
i = Ba(c, r.parameter, s);
for (let t = 0; t < i.length; t++) {
let n = i[t];
e.push([n, r]);
}
}
let n = o(u, e, m);
n && (yield* n);
}
if (u.issues) return yield* V(new G(t, e, u.issues));
if (s.propertyOrder === `original`) {
let e = (p ?? Reflect.ownKeys(c)).concat(n),
t = {};
for (let n of e) Object.hasOwn(l, n) && wi(t, n, l[n]);
return N(t);
}
return N(l);
});
}
_rebuild(t, n, r, i, a) {
let o = Co(this.propertySignatures, (e) => {
let n = t(e.type);
return n === e.type ? e : new Va(e.name, n);
}),
s = Co(this.indexSignatures, (e) => {
let i = n(e.parameter),
a = t(e.type),
o = r ? e.merge?.flip() : e.merge;
return i === e.parameter && a === e.type && o === e.merge ? e : new Wa(i, a, o);
});
return o === this.propertySignatures &&
s === this.indexSignatures &&
i === this.checks &&
a === this.encodingChecks
? this
: new e(o, s, this.annotations, i, void 0, this.context, a);
}
flip(e) {
return this._rebuild(e, e, !0, this.encodingChecks, this.checks);
}
recur(e, t = e) {
return this._rebuild(e, t, !1, this.checks, this.encodingChecks);
}
getExpected() {
return this.propertySignatures.length === 0 && this.indexSignatures.length === 0
? `object | array`
: `object`;
}
};
const Ka = Zr()({
onItem(e, t) {
let n = Object.hasOwn(e.input, t.name) ? N(e.input[t.name]) : Vt();
return t.parser(n, e.options);
},
step(e, t, n) {
if (n._tag === `Failure`) return Ra(e, e.ast, t.name, n);
if (n.value._tag === `Some`) wi(e.out, t.name, n.value.value);
else if (!X(t.type)) {
let n = new W([t.name], new Ni(t.type.context?.annotations));
if (e.options.errors === `all`) {
e.issues ? e.issues.push(n) : (e.issues = [n]);
return;
} else return si(new G(e.ast, e.oinput, [n]));
}
},
});
function qa(e, t) {
return e ? (t ? [...e, ...t] : e) : t;
}
function Ja(e, t, n) {
return new Ga(
Reflect.ownKeys(e).map((t) => new Va(t, e[t].ast)),
[],
n,
t,
);
}
function Ya(e) {
return e.ast;
}
function Xa(e, t = void 0) {
return new Pa(
!1,
e.map((e) => e.ast),
[],
void 0,
t,
);
}
function Za(e, t, n) {
return new io(e.map(Ya), t, void 0, n);
}
function Qa(e) {
switch (e._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 e.propertySignatures.length || e.indexSignatures.length
? [`object`]
: [`object`, `array`];
case `Enum`:
return Array.from(new Set(e.enums.map(([, e]) => typeof e)));
case `Literal`:
return [typeof e.literal];
case `Union`:
return Array.from(new Set(e.types.flatMap(Qa)));
default:
return [
`null`,
`undefined`,
`string`,
`number`,
`boolean`,
`symbol`,
`bigint`,
`object`,
`array`,
`function`,
];
}
}
function $a(e) {
switch (e._tag) {
default:
return [];
case `Declaration`: {
let t = e.annotations?.[`~sentinels`];
return Array.isArray(t) ? t : [];
}
case `Objects`:
return e.propertySignatures.flatMap((e) => {
let t = e.type;
if (!X(t)) {
if (va(t)) return [{ key: e.name, literal: t.literal }];
if (ya(t)) return [{ key: e.name, literal: t.symbol }];
}
return [];
});
case `Arrays`:
return e.elements.flatMap((e, t) => (va(e) && !X(e) ? [{ key: t, literal: e.literal }] : []));
case `Suspend`:
return $a(e.thunk());
}
}
const eo = new WeakMap();
function to(e) {
let t = eo.get(e);
if (t) return t;
t = {};
for (let n = 0; n < e.length; n++) {
let r = e[n],
i = Do(r);
if (_a(i)) continue;
let a = Qa(i),
o = $a(i);
t.byType ??= {};
for (let e of a) (t.byType[e] ??= []).push(n);
if (o.length > 0) {
t.bySentinel ??= new Map();
for (let { key: e, literal: r } of o) {
let i = t.bySentinel.get(e);
i || t.bySentinel.set(e, (i = new Map()));
let a = i.get(r);
(a || i.set(r, (a = [])), a.push(n));
}
} else {
t.otherwise ??= {};
for (let e of a) (t.otherwise[e] ??= []).push(n);
}
}
return (eo.set(e, t), t);
}
function no(e) {
return (t) => {
let n = Do(t);
return n._tag === `Literal` ? n.literal === e : n._tag !== `UniqueSymbol` || n.symbol === e;
};
}
function ro(e, t) {
let n = to(t),
r = e === null ? `null` : Array.isArray(e) ? `array` : typeof e;
if (n.bySentinel) {
let i = n.otherwise?.[r] ?? [];
if (r === `object` || r === `array`) {
let r = new Set(i);
for (let [t, i] of n.bySentinel)
if (Object.hasOwn(e, t)) {
let n = i.get(e[t]);
if (n) for (let e of n) r.add(e);
}
return Array.from(r)
.sort((e, t) => e - t)
.map((e) => t[e])
.filter(no(e));
}
return i.map((e) => t[e]);
}
return (n.byType?.[r] ?? []).map((e) => t[e]).filter(no(e));
}
var io = class e extends J {
_tag = `Union`;
types;
mode;
encodingChecks;
constructor(e, t, n, r, i, a, o) {
(super(n, r, i, a), (this.types = e), (this.mode = t), (this.encodingChecks = o));
}
getParser(e) {
let t = this;
return (n, r) => {
if (n._tag === `None`) return B(n);
let i = n.value,
a = ro(i, t.types),
o = {
ast: t,
recur: e,
oinput: n,
input: i,
out: void 0,
successes: [],
issues: void 0,
options: r,
},
s = La(r?.concurrency),
c = ao(o, a, s ? { ...s, orderedStep: !0 } : void 0);
return c
? vi(c, (e) => (o.out ? B(o.out) : V(new Li(t, i, o.issues ?? []))))
: o.out
? B(o.out)
: V(new Li(t, i, o.issues ?? []));
};
}
_rebuild(t, n, r) {
let i = Co(this.types, t);
return i === this.types && n === this.checks && r === this.encodingChecks
? this
: new e(i, this.mode, this.annotations, n, void 0, this.context, r);
}
recur(e) {
return this._rebuild(e, this.checks, this.encodingChecks);
}
flip(e) {
return this._rebuild(e, this.encodingChecks, this.checks);
}
matchPart(e, t) {
for (let n of this.types) {
let r = n.matchPart(e, t);
if (r !== void 0) return r;
}
}
getExpected(e) {
let t = this.annotations?.expected;
if (typeof t == `string`) return t;
if (this.types.length === 0) return `never`;
let n = this.types.map((t) => {
let n = Do(t);
switch (n._tag) {
case `Arrays`: {
let t = n.elements.filter(va);
if (t.length > 0)
return `${co(n.isMutable)}[ ${t.map((t) => e(t) + lo(t.context?.isOptional)).join(`, `)}, ... ]`;
break;
}
case `Objects`: {
let t = n.propertySignatures.filter((e) => va(e.type));
if (t.length > 0)
return `{ ${t.map((t) => `${co(t.type.context?.isMutable)}${Re(t.name)}${lo(t.type.context?.isOptional)}: ${e(t.type)}`).join(`, `)}, ... }`;
break;
}
}
return e(n);
});
return Array.from(new Set(n)).join(` | `);
}
};
const ao = Zr()({
onItem(e, t) {
return e.recur(t)(e.oinput, e.options);
},
step(e, t, n) {
if (n._tag === `Failure`) {
let t = $i(n.cause);
if (t === void 0) return n;
e.issues ? e.issues.push(t) : (e.issues = [t]);
} else {
if (e.out && e.ast.mode === `oneOf`)
return (e.successes.push(t), si(new Ri(e.ast, e.input, e.successes)));
if (((e.out = n.value), e.successes.push(t), e.ast.mode === `anyOf`)) return ci;
}
},
}),
oo = new io([new Oa(`Infinity`), new Oa(`-Infinity`), new Oa(`NaN`)], `anyOf`),
so = new q(
new io([Na, oo], `anyOf`),
new la(
sa(),
K((e) => (globalThis.Number.isFinite(e) ? e : globalThis.String(e))),
),
);
function co(e) {
return e ? `` : `readonly `;
}
function lo(e) {
return e ? `?` : ``;
}
var uo = class e extends n {
_tag = `Filter`;
run;
annotations;
aborted;
constructor(e, t = void 0, n = !1) {
(super(), (this.run = e), (this.annotations = t), (this.aborted = n));
}
annotate(t) {
return new e(this.run, { ...this.annotations, ...t }, this.aborted);
}
abort() {
return new e(this.run, this.annotations, !0);
}
and(e, t) {
return new fo([this, e], t);
}
},
fo = class e extends n {
_tag = `FilterGroup`;
checks;
annotations;
constructor(e, t = void 0) {
(super(), (this.checks = e), (this.annotations = t));
}
annotate(t) {
return new e(this.checks, { ...this.annotations, ...t });
}
and(t, n) {
return new e([this, t], n);
}
};
function po(e, t, n = !1) {
return new uo((t, n, r) => Vi(t, n, e(t, n, r)), t, n);
}
function mo(e, t) {
let n = e.source;
return po((t) => e.test(t), {
expected: `a string matching the RegExp ${n}`,
meta: { _tag: `isPattern`, regExp: e },
arbitrary: { constraint: { patterns: [e.source] } },
...t,
});
}
function ho(e, t) {
let n = Object.getOwnPropertyDescriptors(e);
return (t(n), Object.create(Object.getPrototypeOf(e), n));
}
function Y(e, t) {
return e.encoding === t
? e
: ho(e, (e) => {
e.encoding.value = t;
});
}
function go(e, t) {
return e.context === t
? e
: ho(e, (e) => {
e.context.value = t;
});
}
function _o(e, t) {
if (e.checks) {
let n = e.checks[e.checks.length - 1];
return vo(e, qt(e.checks.slice(0, -1), n.annotate(t)));
}
return ho(e, (e) => {
e.annotations.value = { ...e.annotations.value, ...t };
});
}
function vo(e, t) {
if (e._tag === `Suspend` && t !== void 0) throw Error(`Cannot add checks to Suspend`);
return e.checks === t
? e
: ho(e, (e) => {
e.checks.value = t;
});
}
function yo(e, t) {
return vo(e, qa(e.checks, t));
}
function bo(e, t) {
let n = e,
r = n[n.length - 1],
i = t(r.to);
return i === r.to ? e : qt(e.slice(0, e.length - 1), new q(i, r.transformation));
}
function xo(e) {
function t(n) {
return n.encoding ? Y(n, bo(n.encoding, t)) : e(n);
}
return s(t);
}
function So(e, t, n) {
let r = new q(e, t);
return Y(n, n.encoding ? [...n.encoding, r] : [r]);
}
function Co(e, t) {
let n = !1,
r = Array(e.length);
for (let i = 0; i < e.length; i++) {
let a = e[i],
o = t(a);
(o !== a && (n = !0), (r[i] = o));
}
return n ? r : e;
}
function wo(e, t) {
return go(
e,
e.context
? new Ca(e.context.isOptional, e.context.isMutable, e.context.defaultValue, {
...e.context.annotations,
...t,
})
: new Ca(!1, !1, void 0, t),
);
}
function To(e, t, n) {
return So(e, n, t);
}
function X(e) {
return e.context?.isOptional ?? !1;
}
const Eo = s((e) => {
if (e.encoding) return Eo(Y(e, void 0));
let t = e,
n = t.recur?.(Eo) ?? t,
r = n.encodingChecks;
return r
? ho(n, (t) => {
((t.encodingChecks.value = void 0), n === e && (t.checks.value = qa(n.checks, r)));
})
: n;
}),
Do = s((e) => Eo(ko(e)));
function Oo(e, t) {
let n = t,
r = n.length,
i = n[r - 1],
a = [new q(ko(Y(e, void 0)), n[0].transformation.flip())];
for (let e = 1; e < r; e++) a.unshift(new q(ko(n[e - 1].to), n[e].transformation.flip()));
let o = ko(i.to);
return o.encoding ? Y(o, [...o.encoding, ...a]) : Y(o, a);
}
const ko = s((e) => {
if (e.encoding) return Oo(e, e.encoding);
let t = e;
return t.flip?.(ko) ?? t.recur?.(ko) ?? t;
});
function Ao(e) {
switch (e._tag) {
case `Undefined`:
return !0;
case `Union`:
return e.types.some(Ao);
default:
return !1;
}
}
function jo(e, t) {
let n = gi(t);
return (r) => (r._tag === `None` ? hi : r.value === t ? n : V(new Fi(e, r)));
}
function Mo(e, t) {
return (n) => (n._tag === `None` ? hi : t(n.value) ? B(n) : V(new Fi(e, n)));
}
function No(e, t, n) {
if (n?.disableChecks || e.checks === void 0) return t;
let r = [];
return (Vo(e.checks, t, r, e, n), r.length === 0 ? t : void 0);
}
const Po = xo((e) => {
switch (e._tag) {
default:
return e;
case `Number`:
return e.toCodecStringTree();
case `Union`:
return e.recur(Po);
}
}),
Fo = new globalThis.RegExp(`^${za}$`),
Io = new globalThis.RegExp(`(?:${za}|Infinity|-Infinity|NaN)`);
function Lo(e) {
return mo(Fo, {
expected: `a string representing a finite number`,
meta: { _tag: `isStringFinite`, regExp: Fo },
...e,
});
}
const Ro = yo(Aa, [Lo()]),
zo = new q(Ro, ma),
Bo = new q(new io([Ro, oo], `anyOf`), ma);
function Vo(e, t, n, r, i) {
for (let a = 0; a < e.length; a++) {
let o = e[a];
if (o._tag === `FilterGroup`) Vo(o.checks, t, n, r, i);
else {
let e = o.run(t, r, i);
if (e && (n.push(new ji(t, o, e)), o.aborted || i?.errors !== `all`)) return;
}
}
}
const Ho = `~structural`,
Uo = (e) => e,
Wo = s((e) => {
switch (e._tag) {
case `Declaration`: {
let t = e.annotations?.[`~effect/Schema/Class`];
if (f(t)) {
let n = t(e.typeParameters),
r = Wo(n.to);
return Y(e, r === n.to ? [n] : [new q(r, n.transformation)]);
}
return e;
}
case `Objects`:
case `Arrays`:
return e.recur((e) => {
let t = e.context?.defaultValue;
if (t) {
let n = Wo(e);
return Y(n, n.encoding ? [...n.encoding, ...t] : t);
}
return Wo(e);
});
case `Suspend`:
return e.recur(Wo);
default:
return e;
}
});
function Go(e) {
let t = Xo(Wo(Eo(e.ast)));
return (e, n) =>
t(
e,
n?.disableChecks
? n?.parseOptions
? { ...n.parseOptions, disableChecks: !0 }
: { disableChecks: !0 }
: n?.parseOptions,
);
}
function Ko(e) {
let t = Go(e);
return (e, n) => {
let r = xi(t(e, n));
return li(r)
? N(r.value)
: (ea(r.cause, `Option adapter can only return none for schema issues`), Vt());
};
}
function qo(e) {
let t = Go(e);
return (e, n) => {
let r = xi(t(e, n));
if (li(r)) return r.value;
let i = ea(r.cause, `Constructor adapter can only throw schema issues`);
throw Error(i.toString(), { cause: i });
};
}
function Jo(e, t) {
let n = Xo(e.ast);
return t === void 0 ? n : (e, r) => n(e, Yo(t, r));
}
const Yo = (e, t) => (t === void 0 ? e : { ...e, ...t });
function Xo(e) {
let t = Qo(e);
return (e, n) => H(t(N(e), n ?? Sa), (e) => (e._tag === `None` ? V(new Ii(e)) : B(e.value)));
}
function Zo(e, t) {
return bi(e, (e) => _i(() => ii(e, t)));
}
const Qo = s((e) => {
let t,
n = e.checks,
r = e.encoding,
i = r,
a = i?.length ?? 0,
o = e.encodingChecks,
s = (n ? n[n.length - 1].annotations : e.annotations)?.parseOptions;
if (!e.context && !r && !n && !o)
return (n, r) => ((t ??= e.getParser(Qo)), s && (r = { ...r, ...s }), t(n, r));
let c = ba(e) || xa(e) || (ga(e) && e.typeParameters.length > 0),
l = n && c ? n.filter((e) => e.annotations?.[Ho]) : void 0;
return (r, c) => {
s && (c = { ...c, ...s });
let u;
if (i) {
for (let e = a - 1; e >= 0; e--) {
let t = i[e],
n = t.to,
a = Qo(n);
if (
((u = u ? H(u, (e) => a(e, c)) : a(r, c)), t.transformation._tag === `Transformation`)
) {
let e = t.transformation.decode;
u = H(u, (t) => e.run(t, c));
} else u = t.transformation.decode(u, c);
}
u = Zo(u, (t) => new Mi(e, r, t));
}
t ??= e.getParser(Qo);
let d = (r) => {
let i = t(r, c);
return (
o &&
!c?.disableChecks &&
(i = H(i, (t) => {
if (Ut(r) && Ut(t)) {
let t = [];
if ((Vo(o, r.value, t, e, c), Yt(t))) return V(new G(e, r, t));
}
return B(t);
})),
n &&
!c?.disableChecks &&
(c?.errors === `all` &&
l &&
l.length > 0 &&
Ut(r) &&
(i = Zo(i, (t) => {
let n = [];
return (
Vo(l, r.value, n, e, c),
Yt(n)
? t._tag === `Composite` && t.ast === e
? new G(e, t.actual, [...t.issues, ...n])
: new G(e, r, [t, ...n])
: t
);
})),
(i = H(i, (t) => {
if (Ut(t)) {
let r = t.value,
i = [];
if ((Vo(n, r, i, e, c), Yt(i))) return V(new G(e, t, i));
}
return B(t);
}))),
i
);
};
return u ? H(u, d) : d(r);
};
}),
$o = `~effect/SchemaError/SchemaError`;
var es = class extends ai(`SchemaError`) {
[$o] = $o;
constructor(e) {
super({ issue: e });
}
get message() {
return this.issue.toString();
}
toString() {
return `SchemaError(${this.message})`;
}
};
function ts(e) {
return m(e, $o);
}
const ns = `~effect/Schema/Schema`,
rs = {
[ns]: ns,
pipe() {
return e(this, arguments);
},
annotate(e) {
return this.rebuild(_o(this.ast, e));
},
annotateKey(e) {
return this.rebuild(wo(this.ast, e));
},
check(...e) {
return this.rebuild(yo(this.ast, e));
},
};
function is(e, t) {
let n = Object.create(rs);
(t && Object.assign(n, t), (n.ast = e), (n.rebuild = (e) => is(e, t)));
let r = Go(n);
return ((n.makeEffect = (e, t) => as(r(e, t))), (n.make = qo(n)), (n.makeOption = Ko(n)), n);
}
function as(e) {
return bi(e, (e) => _i(() => ii(e, (e) => new es(e))));
}
function os() {
return (e, t, n) => Z(new Ta(e.map(Ya), (e) => t(e.map((e) => Z(e))), n));
}
function ss(e, t) {
return os()([], () => (t, n) => (e(t) ? B(t) : V(new Fi(n, N(t)))), t);
}
function cs(e, t) {
let n = Jo(e, t);
return (e, t) => as(n(e, t));
}
function ls(e, t) {
let n;
for (let r of e.reasons) {
if (!ri(r) || !ts(r.error)) throw new globalThis.Error(t, { cause: e });
n ??= r.error;
}
if (n === void 0) throw new globalThis.Error(t, { cause: e });
return n;
}
function us(e) {
let t = xi(e);
if (li(t)) return t.value;
throw ls(t.cause, `Sync adapter can only throw schema errors`);
}
function ds(e, t) {
let n = cs(e, t);
return (e, t) => us(n(e, t));
}
const Z = is;
function fs(e) {
let t = Z(new Oa(e), {
literal: e,
transform(n) {
return t.pipe(Cs(fs(n), { decode: K(() => n), encode: K(() => e) }));
},
});
return t;
}
const ps = Z(Ea),
Q = Z(Aa),
$ = Z(Na);
function ms(e, t) {
return Z(e, {
fields: t,
mapFields(e, t) {
let n = e(this.fields);
return ms(Ja(n, t?.unsafePreserveChecks ? this.ast.checks : void 0), n);
},
});
}
function hs(e) {
return ms(Ja(e, void 0), e);
}
function gs(e, t) {
return Z(e, {
elements: t,
mapElements(e, t) {
let n = e(this.elements);
return gs(Xa(n, t?.unsafePreserveChecks ? this.ast.checks : void 0), n);
},
});
}
const _s = Uo((e) => Z(new Pa(!1, [], [e.ast]), { value: e })),
vs = Uo((e) => Z(new Pa(!0, e.ast.elements, e.ast.rest), { schema: e }));
function ys(e, t) {
return Z(e, {
members: t,
mapMembers(e, t) {
let n = e(this.members);
return ys(Za(n, this.ast.mode, t?.unsafePreserveChecks ? this.ast.checks : void 0), n);
},
});
}
function bs(e, t) {
return ys(Za(e, t?.mode ?? `anyOf`, void 0), e);
}
function xs(e) {
let t = e.map(fs);
return Z(Za(t, `anyOf`, void 0), {
literals: e,
members: t,
mapMembers(e) {
return bs(e(this.members));
},
pick(e) {
return xs(e);
},
transform(e) {
return bs(t.map((t, n) => t.transform(e[n])));
},
});
}
const Ss = Uo((e) => bs([e, ps]));
function Cs(e, t) {
return (n) => Z(To(n.ast, e.ast, t ? da(t) : pa()), { from: n, to: e });
}
function ws(e, t) {
return ss((t) => t instanceof e, t);
}
const Ts = po;
function Es(e) {
let t = Bt(e.order),
n = e.formatter ?? C;
return (r, i) =>
Ts((e) => t(e, r), {
expected: `a value greater than or equal to ${n(r)}`,
arbitrary: { constraint: { ordered: { order: e.order, minimum: r } } },
...e.annotate?.(r),
...i,
});
}
function Ds(e) {
let t = zt(e.order),
n = e.formatter ?? C;
return (r, i) =>
Ts((e) => t(e, r), {
expected: `a value less than or equal to ${n(r)}`,
arbitrary: { constraint: { ordered: { order: e.order, maximum: r } } },
...e.annotate?.(r),
...i,
});
}
const Os = Es({
order: Rt,
annotate: (e) => ({ meta: { _tag: `isGreaterThanOrEqualTo`, minimum: e } }),
}),
ks = Ds({ order: Rt, annotate: (e) => ({ meta: { _tag: `isLessThanOrEqualTo`, maximum: e } }) });
function As(e, t) {
return (
(e = Math.max(0, Math.floor(e))),
Ts((t) => t.length >= e, {
expected: `a value with a length of at least ${e}`,
meta: { _tag: `isMinLength`, minLength: e },
[Ho]: !0,
arbitrary: { constraint: { minLength: e } },
...t,
})
);
}
function js(e, t) {
return (
(e = Math.max(0, Math.floor(e))),
Ts((t) => t.length <= e, {
expected: `a value with a length of at most ${e}`,
meta: { _tag: `isMaxLength`, maxLength: e },
[Ho]: !0,
arbitrary: { constraint: { maxLength: e } },
...t,
})
);
}
(globalThis.RegExp,
globalThis.URL,
globalThis.File,
globalThis.FormData,
globalThis.URLSearchParams,
globalThis.Uint8Array);
const Ms = hs({
id: $,
created: ws(Date),
title: Q.check(As(1), js(100)),
type: xs([`jpg`, `png`]),
size: $,
url: Q.check(Ts((e) => URL.canParse(e))),
}),
Ns = hs({
id: $,
stars: $.check(Os(0), ks(5)),
title: Q.check(As(1), js(100)),
text: Q.check(As(1), js(1e3)),
images: vs(_s(Ms)),
});
ds(
hs({
id: $,
created: ws(Date),
title: Q.check(As(1), js(100)),
brand: Q.check(As(1), js(30)),
description: Q.check(As(1), js(500)),
price: $.check(Os(1), ks(1e4)),
discount: Ss($.check(Os(1), ks(100))),
quantity: $.check(Os(1), ks(10)),
tags: vs(_s(Q.check(As(1), js(30)))),
images: vs(_s(Ms)),
ratings: vs(_s(Ns)),
}),
)({});