@effect-app/vue-components 4.0.0-beta.22 → 4.0.0-beta.221

package/dist/vue-components57.es.js

@@ -0,0 +1,819 @@
+import { Class as e } from "./vue-components12.es.js";
+import { memoize as t } from "./vue-components13.es.js";
+import { isBoolean as n, isNotNullish as r, isNumber as i, isString as a, isUnknown as o } from "./vue-components15.es.js";
+import { format as s, formatPropertyKey as c } from "./vue-components21.es.js";
+import { isNone as l, none as u, some as d } from "./vue-components28.es.js";
+import { isFailure as f } from "./vue-components29.es.js";
+import { append as p, empty as ee } from "./vue-components30.es.js";
+import { effectIsExit as m, iterateEager as h } from "./vue-components37.es.js";
+import { findError as g } from "./vue-components38.es.js";
+import { fail as _, void_ as te } from "./vue-components40.es.js";
+import { exit as ne, fail as v, flatMap as re, fnUntracedEager as y, mapEager as ie, succeed as b, succeedNone as x, succeedSome as ae } from "./vue-components46.es.js";
+import { resolveDescription as oe } from "./vue-components49.es.js";
+import { set as S } from "./vue-components50.es.js";
+import { escape as se } from "./vue-components51.es.js";
+import { AnyOf as ce, Composite as C, Filter as le, InvalidType as w, InvalidValue as ue, MissingKey as de, OneOf as fe, Pointer as T, UnexpectedKey as pe, make as me } from "./vue-components54.es.js";
+import { Number as he, passthrough as ge, transform as E, withDefault as _e } from "./vue-components55.es.js";
+import { Transformation as D, numberFromString as ve, passthrough as ye } from "./vue-components56.es.js";
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.62/node_modules/effect/dist/SchemaAST.js
+function O(e) {
+	return (t) => t._tag === e;
+}
+var be = /* @__PURE__ */ O("Declaration"), xe = /* @__PURE__ */ O("Null"), Se = /* @__PURE__ */ O("Undefined"), Ce = /* @__PURE__ */ O("Never"), we = /* @__PURE__ */ O("String"), Te = /* @__PURE__ */ O("Number"), Ee = /* @__PURE__ */ O("Boolean"), k = /* @__PURE__ */ O("Literal"), De = /* @__PURE__ */ O("UniqueSymbol"), Oe = /* @__PURE__ */ O("Arrays"), ke = /* @__PURE__ */ O("Objects"), Ae = /* @__PURE__ */ O("Union"), A = class {
+	to;
+	transformation;
+	constructor(e, t) {
+		this.to = e, this.transformation = t;
+	}
+}, je = {}, j = 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;
+	}
+}, Me = "~effect/Schema", M = class {
+	[Me] = Me;
+	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}>`;
+	}
+}, Ne = class e extends M {
+	_tag = "Declaration";
+	typeParameters;
+	run;
+	constructor(e, t, n, r, i, a) {
+		super(n, r, i, a), this.typeParameters = e, this.run = t;
+	}
+	getParser() {
+		let e = this.run(this.typeParameters);
+		return (t, n) => l(t) ? x : ie(e(t.value, this, n), d);
+	}
+	recur(t) {
+		let n = q(this.typeParameters, t);
+		return n === this.typeParameters ? this : new e(n, this.run, this.annotations, this.checks, void 0, this.context);
+	}
+	getExpected() {
+		let e = this.annotations?.expected;
+		return typeof e == "string" ? e : "<Declaration>";
+	}
+}, Pe = /* @__PURE__ */ new class extends M {
+	_tag = "Null";
+	getParser() {
+		return Q(this, null);
+	}
+	getExpected() {
+		return "null";
+	}
+}(), Fe = class extends M {
+	_tag = "Undefined";
+	getParser() {
+		return Q(this, void 0);
+	}
+	toCodecJson() {
+		return W(this, [Ie]);
+	}
+	getExpected() {
+		return "undefined";
+	}
+}, Ie = /* @__PURE__ */ new A(Pe, /* @__PURE__ */ new D(/* @__PURE__ */ E(() => void 0), /* @__PURE__ */ E(() => null))), Le = /* @__PURE__ */ new Fe(), Re = /* @__PURE__ */ new class extends M {
+	_tag = "Unknown";
+	getParser() {
+		return $(this, o);
+	}
+	getExpected() {
+		return "unknown";
+	}
+}(), N = class extends M {
+	_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 ${s(e)}`);
+		this.literal = e;
+	}
+	getParser() {
+		return Q(this, this.literal);
+	}
+	toCodecJson() {
+		return typeof this.literal == "bigint" ? P(this) : this;
+	}
+	toCodecStringTree() {
+		return typeof this.literal == "string" ? this : P(this);
+	}
+	getExpected() {
+		return typeof this.literal == "string" ? JSON.stringify(this.literal) : globalThis.String(this.literal);
+	}
+};
+function P(e) {
+	let t = globalThis.String(e.literal);
+	return W(e, [new A(new N(t), new D(E(() => e.literal), E(() => t)))]);
+}
+var F = /* @__PURE__ */ new class extends M {
+	_tag = "String";
+	getParser() {
+		return $(this, a);
+	}
+	getExpected() {
+		return "string";
+	}
+}(), ze = class extends M {
+	_tag = "Number";
+	getParser() {
+		return $(this, i);
+	}
+	toCodecJson() {
+		return this.checks && (I(this.checks, "isFinite") || I(this.checks, "isInt")) ? this : W(this, [st]);
+	}
+	toCodecStringTree() {
+		return this.checks && (I(this.checks, "isFinite") || I(this.checks, "isInt")) ? W(this, [zt]) : W(this, [Bt]);
+	}
+	getExpected() {
+		return "number";
+	}
+};
+function I(e, t) {
+	return e.some((e) => {
+		switch (e._tag) {
+			case "Filter": return e.annotations?.meta?._tag === t;
+			case "FilterGroup": return I(e.checks, t);
+		}
+	});
+}
+var Be = /* @__PURE__ */ new ze(), Ve = /* @__PURE__ */ new class extends M {
+	_tag = "Boolean";
+	getParser() {
+		return $(this, n);
+	}
+	getExpected() {
+		return "boolean";
+	}
+}(), He = class e extends M {
+	_tag = "Arrays";
+	isMutable;
+	elements;
+	rest;
+	constructor(e, t, n, r, i, a, o) {
+		super(r, i, a, o), this.isMutable = e, this.elements = t, this.rest = n;
+		let s = t.findIndex(J);
+		if (s !== -1 && (t.slice(s + 1).some((e) => !J(e)) || n.length > 1)) throw Error("A required element cannot follow an optional element. ts(1257)");
+		if (n.length > 1 && n.slice(1).some(J)) 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 y(function* (e, n) {
+			if (e._tag === "None") return e;
+			let r = e.value;
+			if (!Array.isArray(r)) return yield* v(new w(t, e));
+			let a = r.length, o = {
+				ast: t,
+				getParser: c,
+				oinput: e,
+				len: a,
+				tailThreshold: We(a, i, s),
+				output: new globalThis.Array(a),
+				issues: void 0,
+				options: n
+			}, l = Ue(o, r, {
+				concurrency: L(n?.concurrency)?.concurrency,
+				end: t.rest.length === 0 ? i : Math.max(a, i + s)
+			});
+			if (l && (yield* l), t.rest.length === 0 && a > i) for (let s = i; s <= a - 1; s++) {
+				let i = new T([s], new pe(t, r[s]));
+				if (n.errors === "all") o.issues ? o.issues.push(i) : o.issues = [i];
+				else return yield* v(new C(t, e, [i]));
+			}
+			return o.issues ? yield* v(new C(t, e, o.issues)) : d(o.output);
+		});
+	}
+	recur(t) {
+		let n = q(this.elements, t), r = q(this.rest, t);
+		return n === this.elements && r === this.rest ? this : new e(this.isMutable, n, r, this.annotations, this.checks, void 0, this.context);
+	}
+	getExpected() {
+		return "array";
+	}
+}, Ue = /* @__PURE__ */ h()({
+	onItem(e, t, n) {
+		let r = n < e.len ? d(t) : u();
+		return e.getParser(e.tailThreshold, n).parser(r, e.options);
+	},
+	step(e, t, n, r) {
+		if (n._tag === "Failure") return R(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 (J(t.ast)) return;
+			let n = new T([r], new de(t.ast.context?.annotations));
+			if (e.options.errors === "all") e.issues ? e.issues.push(n) : e.issues = [n];
+			else return _(new C(e.ast, e.oinput, [n]));
+		}
+	}
+});
+function We(e, t, n) {
+	return Math.max(t, e - n);
+}
+var L = (e) => (e = e === "unbounded" ? Infinity : e ?? 1, e > 1 ? { concurrency: e } : void 0), R = (e, t, n, r) => {
+	let i = g(r.cause);
+	if (f(i)) return r;
+	let a = new T([n], i.success);
+	if (e.options.errors === "all") e.issues ? e.issues.push(a) : e.issues = [a];
+	else return _(new C(t, e.oinput, [a]));
+}, z = "[+-]?\\d*\\.?\\d+(?:[Ee][+-]?\\d+)?", Ge = /* @__PURE__ */ new globalThis.RegExp(`(?:${z}|Infinity|-Infinity|NaN)`);
+function Ke(e, t) {
+	let n = X(t);
+	switch (n._tag) {
+		case "String": return Object.keys(e);
+		case "TemplateLiteral": {
+			let t = At(n);
+			return Object.keys(e).filter((e) => t.test(e));
+		}
+		case "Symbol": return Object.getOwnPropertySymbols(e);
+		case "Number": return Object.keys(e).filter((e) => Ge.test(e));
+		case "Union": return [...new Set(n.types.flatMap((t) => Ke(e, t)))];
+		default: return [];
+	}
+}
+var B = class {
+	name;
+	type;
+	constructor(e, t) {
+		this.name = e, this.type = t;
+	}
+}, qe = class {
+	parameter;
+	type;
+	merge;
+	constructor(e, t, n) {
+		if (this.parameter = e, this.type = t, this.merge = n, J(t) && !Ot(t)) throw Error("Cannot use `Schema.optionalKey` with index signatures, use `Schema.optional` instead.");
+	}
+}, Je = class e extends M {
+	_tag = "Objects";
+	propertySignatures;
+	indexSignatures;
+	constructor(e, t, n, r, i, a) {
+		super(n, r, i, a), this.propertySignatures = e, this.indexSignatures = t;
+		let o = e.map((e) => e.name).filter((e, t, n) => n.indexOf(e) !== t);
+		if (o.length > 0) throw Error(`Duplicate identifiers: ${JSON.stringify(o)}. ts(2300)`);
+	}
+	getParser(e) {
+		let t = this, n = [], i = /* @__PURE__ */ new Set(), a = [];
+		for (let r of t.propertySignatures) n.push(r.name), i.add(r.name), a.push({
+			ps: r,
+			parser: e(r.type),
+			name: r.name,
+			type: r.type
+		});
+		let o = t.indexSignatures.length;
+		if (t.propertySignatures.length === 0 && t.indexSignatures.length === 0) return $(t, r);
+		let s = o > 0 ? h()({
+			onItem: y(function* (n, [r, i]) {
+				let a = e(Pt(i.parameter))(d(r), n.options), o = m(a) ? a : yield* ne(a);
+				if (o._tag === "Failure") {
+					let e = R(n, t, r, o);
+					e && (yield* e);
+					return;
+				}
+				let s = d(n.input[r]), c = e(i.type)(s, n.options), l = m(c) ? c : yield* ne(c);
+				if (l._tag === "Failure") {
+					let e = R(n, t, r, l);
+					e && (yield* e);
+					return;
+				} else if (o.value._tag === "Some" && l.value._tag === "Some") {
+					let e = o.value.value, t = l.value.value;
+					if (i.merge && i.merge.decode && Object.hasOwn(n.out, e)) {
+						let [r, a] = i.merge.decode.combine([e, n.out[e]], [e, t]);
+						S(n.out, r, a);
+					} else S(n.out, e, t);
+				}
+			}),
+			step: (e, t, n) => n._tag === "Failure" ? n : void 0
+		}) : void 0;
+		return y(function* (e, r) {
+			if (e._tag === "None") return e;
+			let c = e.value;
+			if (!(typeof c == "object" && c && !Array.isArray(c))) return yield* v(new w(t, e));
+			let l = {}, u = {
+				ast: t,
+				oinput: e,
+				input: c,
+				out: l,
+				issues: void 0,
+				options: r
+			}, f = r.errors === "all", p = r.onExcessProperty === "error", m = r.onExcessProperty === "preserve", h;
+			if (t.indexSignatures.length === 0 && (p || m)) {
+				h = Reflect.ownKeys(c);
+				for (let n = 0; n < h.length; n++) {
+					let r = h[n];
+					if (!i.has(r)) if (p) {
+						let n = new T([r], new pe(t, c[r]));
+						if (f) {
+							u.issues ? u.issues.push(n) : u.issues = [n];
+							continue;
+						} else return yield* v(new C(t, e, [n]));
+					} else S(l, r, c[r]);
+				}
+			}
+			let g = L(r?.concurrency), _ = Ye(u, a, g);
+			if (_ && (yield* _), s) {
+				let e = ee();
+				for (let n = 0; n < o; n++) {
+					let r = t.indexSignatures[n], i = Ke(c, r.parameter);
+					for (let t = 0; t < i.length; t++) {
+						let n = i[t];
+						e.push([n, r]);
+					}
+				}
+				let n = s(u, e, g);
+				n && (yield* n);
+			}
+			if (u.issues) return yield* v(new C(t, e, u.issues));
+			if (r.propertyOrder === "original") {
+				let e = (h ?? Reflect.ownKeys(c)).concat(n), t = {};
+				for (let n of e) Object.hasOwn(l, n) && S(t, n, l[n]);
+				return d(t);
+			}
+			return d(l);
+		});
+	}
+	rebuild(t, n) {
+		let r = q(this.propertySignatures, (e) => {
+			let n = t(e.type);
+			return n === e.type ? e : new B(e.name, n);
+		}), i = q(this.indexSignatures, (e) => {
+			let r = t(e.parameter), i = t(e.type), a = n ? e.merge?.flip() : e.merge;
+			return r === e.parameter && i === e.type && a === e.merge ? e : new qe(r, i, a);
+		});
+		return r === this.propertySignatures && i === this.indexSignatures ? this : new e(r, i, this.annotations, this.checks, void 0, this.context);
+	}
+	flip(e) {
+		return this.rebuild(e, !0);
+	}
+	recur(e) {
+		return this.rebuild(e, !1);
+	}
+	getExpected() {
+		return this.propertySignatures.length === 0 && this.indexSignatures.length === 0 ? "object | array" : "object";
+	}
+}, Ye = /* @__PURE__ */ h()({
+	onItem(e, t) {
+		let n = Object.hasOwn(e.input, t.name) ? d(e.input[t.name]) : u();
+		return t.parser(n, e.options);
+	},
+	step(e, t, n) {
+		if (n._tag === "Failure") return R(e, e.ast, t.name, n);
+		if (n.value._tag === "Some") S(e.out, t.name, n.value.value);
+		else if (!J(t.type)) {
+			let n = new T([t.name], new de(t.type.context?.annotations));
+			if (e.options.errors === "all") {
+				e.issues ? e.issues.push(n) : e.issues = [n];
+				return;
+			} else return _(new C(e.ast, e.oinput, [n]));
+		}
+	}
+});
+function Xe(e, t, n) {
+	return new Je(Reflect.ownKeys(e).map((t) => new B(t, e[t].ast)), [], n, t);
+}
+function Ze(e) {
+	return e.ast;
+}
+function Qe(e, t = void 0) {
+	return new He(!1, e.map((e) => e.ast), [], void 0, t);
+}
+function $e(e, t, n) {
+	return new H(e.map(Ze), t, void 0, n);
+}
+function et(e) {
+	switch (e._tag) {
+		case "Null": return ["null"];
+		case "Undefined":
+		case "Void": 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(et)));
+		default: return [
+			"null",
+			"undefined",
+			"string",
+			"number",
+			"boolean",
+			"symbol",
+			"bigint",
+			"object",
+			"array",
+			"function"
+		];
+	}
+}
+function tt(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 (!J(t)) {
+				if (k(t)) return [{
+					key: e.name,
+					literal: t.literal
+				}];
+				if (De(t)) return [{
+					key: e.name,
+					literal: t.symbol
+				}];
+			}
+			return [];
+		});
+		case "Arrays": return e.elements.flatMap((e, t) => k(e) && !J(e) ? [{
+			key: t,
+			literal: e.literal
+		}] : []);
+		case "Suspend": return tt(e.thunk());
+	}
+}
+var nt = /* @__PURE__ */ new WeakMap();
+function rt(e) {
+	let t = nt.get(e);
+	if (t) return t;
+	t = {};
+	for (let n of e) {
+		let e = X(n);
+		if (Ce(e)) continue;
+		let r = et(e), i = tt(e);
+		t.byType ??= {};
+		for (let e of r) (t.byType[e] ??= []).push(n);
+		if (i.length > 0) {
+			t.bySentinel ??= /* @__PURE__ */ new Map();
+			for (let { key: e, literal: r } of i) {
+				let i = t.bySentinel.get(e);
+				i || t.bySentinel.set(e, i = /* @__PURE__ */ new Map());
+				let a = i.get(r);
+				a || i.set(r, a = []), a.push(n);
+			}
+		} else {
+			t.otherwise ??= {};
+			for (let e of r) (t.otherwise[e] ??= []).push(n);
+		}
+	}
+	return nt.set(e, t), t;
+}
+function V(e) {
+	return (t) => {
+		let n = X(t);
+		return n._tag === "Literal" ? n.literal === e : n._tag === "UniqueSymbol" ? n.symbol === e : !0;
+	};
+}
+function it(e, t) {
+	let n = rt(t), r = e === null ? "null" : Array.isArray(e) ? "array" : typeof e;
+	if (n.bySentinel) {
+		let t = n.otherwise?.[r] ?? [];
+		if (r === "object" || r === "array") {
+			for (let [r, i] of n.bySentinel) if (Object.hasOwn(e, r)) {
+				let n = i.get(e[r]);
+				if (n) return [...n, ...t].filter(V(e));
+			}
+		}
+		return t;
+	}
+	return (n.byType?.[r] ?? []).filter(V(e));
+}
+var H = class e extends M {
+	_tag = "Union";
+	types;
+	mode;
+	constructor(e, t, n, r, i, a) {
+		super(n, r, i, a), this.types = e, this.mode = t;
+	}
+	getParser(e) {
+		let t = this;
+		return (n, r) => {
+			if (n._tag === "None") return b(n);
+			let i = n.value, a = it(i, t.types), o = {
+				ast: t,
+				recur: e,
+				oinput: n,
+				input: i,
+				out: void 0,
+				successes: [],
+				issues: void 0,
+				options: r
+			}, s = at(o, a, L(r?.concurrency));
+			return s ? re(s, (e) => o.out ? b(o.out) : v(new ce(t, i, o.issues ?? []))) : o.out ? b(o.out) : v(new ce(t, i, o.issues ?? []));
+		};
+	}
+	recur(t) {
+		let n = q(this.types, t);
+		return n === this.types ? this : new e(n, this.mode, this.annotations, this.checks, void 0, this.context);
+	}
+	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 = X(t);
+			switch (n._tag) {
+				case "Arrays": {
+					let t = n.elements.filter(k);
+					if (t.length > 0) return `${ct(n.isMutable)}[ ${t.map((t) => e(t) + lt(t.context?.isOptional)).join(", ")}, ... ]`;
+					break;
+				}
+				case "Objects": {
+					let t = n.propertySignatures.filter((e) => k(e.type));
+					if (t.length > 0) return `{ ${t.map((t) => `${ct(t.type.context?.isMutable)}${c(t.name)}${lt(t.type.context?.isOptional)}: ${e(t.type)}`).join(", ")}, ... }`;
+					break;
+				}
+			}
+			return e(n);
+		});
+		return Array.from(new Set(n)).join(" | ");
+	}
+}, at = /* @__PURE__ */ h()({
+	onItem(e, t) {
+		return e.recur(t)(e.oinput, e.options);
+	},
+	step(e, t, n) {
+		if (n._tag === "Failure") {
+			let t = g(n.cause);
+			if (f(t)) return n;
+			e.issues ? e.issues.push(t.success) : e.issues = [t.success];
+		} else {
+			if (e.out && e.ast.mode === "oneOf") return e.successes.push(t), _(new fe(e.ast, e.input, e.successes));
+			if (e.out = n.value, e.successes.push(t), e.ast.mode === "anyOf") return te;
+		}
+	}
+}), ot = /* @__PURE__ */ new H([
+	/* @__PURE__ */ new N("Infinity"),
+	/* @__PURE__ */ new N("-Infinity"),
+	/* @__PURE__ */ new N("NaN")
+], "anyOf"), st = /* @__PURE__ */ new A(/* @__PURE__ */ new H([Be, ot], "anyOf"), /* @__PURE__ */ new D(/* @__PURE__ */ he(), /* @__PURE__ */ E((e) => globalThis.Number.isFinite(e) ? e : globalThis.String(e))));
+function ct(e) {
+	return e ? "" : "readonly ";
+}
+function lt(e) {
+	return e ? "?" : "";
+}
+var ut = class t extends e {
+	_tag = "Filter";
+	run;
+	annotations;
+	aborted;
+	constructor(e, t = void 0, n = !1) {
+		super(), this.run = e, this.annotations = t, this.aborted = n;
+	}
+	annotate(e) {
+		return new t(this.run, {
+			...this.annotations,
+			...e
+		}, this.aborted);
+	}
+	abort() {
+		return new t(this.run, this.annotations, !0);
+	}
+	and(e, t) {
+		return new dt([this, e], t);
+	}
+}, dt = class t extends e {
+	_tag = "FilterGroup";
+	checks;
+	annotations;
+	constructor(e, t = void 0) {
+		super(), this.checks = e, this.annotations = t;
+	}
+	annotate(e) {
+		return new t(this.checks, {
+			...this.annotations,
+			...e
+		});
+	}
+	and(e, n) {
+		return new t([this, e], n);
+	}
+};
+function ft(e, t, n = !1) {
+	return new ut((t, n, r) => me(t, n, e(t, n, r)), t, n);
+}
+function pt(e, t) {
+	return new ut((t) => e(t) ? void 0 : new ue(d(t)), t, !0);
+}
+function mt(e, t) {
+	let n = e.source;
+	return ft((t) => e.test(t), {
+		expected: `a string matching the RegExp ${n}`,
+		meta: {
+			_tag: "isPattern",
+			regExp: e
+		},
+		toArbitraryConstraint: { string: { patterns: [e.source] } },
+		...t
+	});
+}
+function U(e, t) {
+	let n = Object.getOwnPropertyDescriptors(e);
+	return t(n), Object.create(Object.getPrototypeOf(e), n);
+}
+function W(e, t) {
+	return e.encoding === t ? e : U(e, (e) => {
+		e.encoding.value = t;
+	});
+}
+function G(e, t) {
+	return e.context === t ? e : U(e, (e) => {
+		e.context.value = t;
+	});
+}
+function ht(e, t) {
+	if (e.checks) {
+		let n = e.checks[e.checks.length - 1];
+		return gt(e, p(e.checks.slice(0, -1), n.annotate(t)));
+	}
+	return U(e, (e) => {
+		e.annotations.value = {
+			...e.annotations.value,
+			...t
+		};
+	});
+}
+function gt(e, t) {
+	return e.checks === t ? e : U(e, (e) => {
+		e.checks.value = t;
+	});
+}
+function _t(e, t) {
+	return gt(e, e.checks ? [...e.checks, ...t] : t);
+}
+function vt(e, t) {
+	let n = e, r = n[n.length - 1], i = t(r.to);
+	return i === r.to ? e : p(e.slice(0, e.length - 1), new A(i, r.transformation));
+}
+function yt(e) {
+	return (t) => t.encoding ? W(t, vt(t.encoding, e)) : t;
+}
+function bt(e, t) {
+	return K(e, t, Y(e));
+}
+function xt(e, t) {
+	return K(X(e), t, e);
+}
+function K(e, t, n) {
+	let r = new A(e, t);
+	return W(n, n.encoding ? [...n.encoding, r] : [r]);
+}
+function q(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 St(e, t) {
+	return G(e, e.context ? new j(e.context.isOptional, e.context.isMutable, e.context.defaultValue, {
+		...e.context.annotations,
+		...t
+	}) : new j(!1, !1, void 0, t));
+}
+var Ct = /* @__PURE__ */ yt(wt);
+function wt(e) {
+	return Ct(G(e, e.context ? e.context.isOptional === !1 ? new j(!0, e.context.isMutable, e.context.defaultValue, e.context.annotations) : e.context : new j(!0, !1)));
+}
+function Tt(e, t) {
+	let n = [new A(Re, new D(_e(t), ge()))];
+	return G(e, e.context ? new j(e.context.isOptional, e.context.isMutable, n, e.context.annotations) : new j(!1, !1, n));
+}
+function Et(e, t, n) {
+	return K(e, n, t);
+}
+function J(e) {
+	return e.context?.isOptional ?? !1;
+}
+var Y = /* @__PURE__ */ t((e) => {
+	if (e.encoding) return Y(W(e, void 0));
+	let t = e;
+	return t.recur?.(Y) ?? t;
+}), X = /* @__PURE__ */ t((e) => Y(Z(e)));
+function Dt(e, t) {
+	let n = t, r = n.length, i = n[r - 1], a = [new A(Z(W(e, void 0)), n[0].transformation.flip())];
+	for (let e = 1; e < r; e++) a.unshift(new A(Z(n[e - 1].to), n[e].transformation.flip()));
+	let o = Z(i.to);
+	return o.encoding ? W(o, [...o.encoding, ...a]) : W(o, a);
+}
+var Z = /* @__PURE__ */ t((e) => {
+	if (e.encoding) return Dt(e, e.encoding);
+	let t = e;
+	return t.flip?.(Z) ?? t.recur?.(Z) ?? t;
+});
+function Ot(e) {
+	switch (e._tag) {
+		case "Undefined": return !0;
+		case "Union": return e.types.some(Ot);
+		default: return !1;
+	}
+}
+function kt(e, t) {
+	return e.encodedParts.map((e) => Mt(e, jt(e), t)).join("");
+}
+var At = /* @__PURE__ */ t((e) => new globalThis.RegExp(`^${kt(e, !0)}$`));
+function jt(e) {
+	switch (e._tag) {
+		case "Literal": return se(globalThis.String(e.literal));
+		case "String": return Ft;
+		case "Number": return z;
+		case "BigInt": return Vt;
+		case "TemplateLiteral": return kt(e, !1);
+		case "Union": return e.types.map(jt).join("|");
+	}
+}
+function Mt(e, t, n) {
+	if (Ae(e)) {
+		if (!n) return `(?:${t})`;
+	} else if (!n) return t;
+	return `(${t})`;
+}
+function Q(e, t) {
+	let n = ae(t);
+	return (r) => r._tag === "None" ? x : r.value === t ? n : v(new w(e, r));
+}
+function $(e, t) {
+	return (n) => n._tag === "None" ? x : t(n.value) ? b(n) : v(new w(e, n));
+}
+function Nt(e) {
+	function n(t) {
+		return t.encoding ? W(t, vt(t.encoding, n)) : e(t);
+	}
+	return t(n);
+}
+var Pt = /* @__PURE__ */ Nt((e) => {
+	switch (e._tag) {
+		default: return e;
+		case "Number": return e.toCodecStringTree();
+		case "Union": return e.recur(Pt);
+	}
+}), Ft = "[\\s\\S]*?", It = /* @__PURE__ */ new globalThis.RegExp(`^${z}$`);
+function Lt(e) {
+	return mt(It, {
+		expected: "a string representing a finite number",
+		meta: {
+			_tag: "isStringFinite",
+			regExp: It
+		},
+		...e
+	});
+}
+var Rt = /* @__PURE__ */ _t(F, [/* @__PURE__ */ Lt()]), zt = /* @__PURE__ */ new A(Rt, ve), Bt = /* @__PURE__ */ new A(/* @__PURE__ */ new H([Rt, ot], "anyOf"), ve), Vt = "-?\\d+";
+`${Vt}`;
+function Ht(e, t, n, r, i) {
+	for (let a = 0; a < e.length; a++) {
+		let o = e[a];
+		if (o._tag === "FilterGroup") Ht(o.checks, t, n, r, i);
+		else {
+			let e = o.run(t, r, i);
+			if (e && (n.push(new le(t, o, e)), o.aborted || i?.errors !== "all")) return;
+		}
+	}
+}
+var Ut = "~effect/Schema/Class", Wt = "~structural", Gt = oe;
+function Kt(e) {
+	let t = /* @__PURE__ */ new Set();
+	return n(e);
+	function n(e) {
+		return e === void 0 || typeof e == "string" ? !0 : typeof e != "object" || !e || t.has(e) ? !1 : (t.add(e), Array.isArray(e) ? e.every(n) : Object.keys(e).every((t) => n(e[t])));
+	}
+}
+var qt = /* @__PURE__ */ new A(/* @__PURE__ */ new Ne([], () => (e, t) => Kt(e) ? b(e) : v(new w(t, d(e))), {
+	expected: "StringTree",
+	toCodecStringTree: () => new A(Re, ye())
+}), /* @__PURE__ */ ye());
+//#endregion
+export { He as Arrays, Ut as ClassTypeId, Ne as Declaration, A as Link, N as Literal, Je as Objects, B as PropertySignature, Wt as STRUCTURAL_ANNOTATION_KEY, H as Union, ht as annotate, St as annotateKey, _t as appendChecks, Ve as boolean, Ht as collectIssues, Et as decodeTo, je as defaultParseOptions, Ze as getAST, Oe as isArrays, Ee as isBoolean, be as isDeclaration, k as isLiteral, xe as isNull, Te as isNumber, ke as isObjects, J as isOptional, mt as isPattern, we as isString, Se as isUndefined, Ae as isUnion, ft as makeFilter, pt as makeFilterByGuard, bt as middlewareDecoding, xt as middlewareEncoding, Pe as null_, Be as number, wt as optionalKey, Ct as optionalKeyLastLink, W as replaceEncoding, Gt as resolveDescription, F as string, Xe as struct, Nt as toCodec, X as toEncoded, Y as toType, Qe as tuple, Le as undefined_, $e as union, qt as unknownToStringTree, Tt as withConstructorDefault };