@effect-app/vue-components 4.0.0-beta.2 → 4.0.0-beta.4

package/dist/vue-components.es17.js

@@ -1,143 +1,725 @@
-import { pretty as b } from "./vue-components.es41.js";
-import { mapErrorEager as E, runFork as w, match as U } from "./vue-components.es21.js";
-import { isSuccess as v } from "./vue-components.es42.js";
-import { make as $ } from "./vue-components.es43.js";
-import { MixedScheduler as y } from "./vue-components.es44.js";
-import { makeFilter as F, Arrays as I, Literal as O, union as h, null as T, decodeTo as _, string as A, unknown as L, boolean as N, number as j, undefined as x } from "./vue-components.es16.js";
-import { transform as f } from "./vue-components.es45.js";
-import { makeFormatterStandardSchemaV1 as C } from "./vue-components.es46.js";
-import { decodeUnknownEffect as k } from "./vue-components.es47.js";
-import { make as M, passthrough as P } from "./vue-components.es48.js";
-import { lambda as V } from "./vue-components.es49.js";
-const p = "~effect/Schema/SchemaError";
-class B {
-  [p] = p;
-  _tag = "SchemaError";
-  name = "SchemaError";
-  issue;
-  constructor(r) {
-    this.issue = r;
-  }
-  get message() {
-    return this.issue.toString();
+import { append as xe } from "./vue-components.es39.js";
+import { findError as P } from "./vue-components.es40.js";
+import { fnUntracedEager as le, succeedSome as Se, succeedNone as fe, fail as p, exit as M, succeed as ke } from "./vue-components.es22.js";
+import { format as Oe, formatPropertyKey as Te } from "./vue-components.es41.js";
+import { memoize as Q } from "./vue-components.es42.js";
+import { effectIsExit as L } from "./vue-components.es43.js";
+import { some as I, none as Ne } from "./vue-components.es24.js";
+import { Class as de } from "./vue-components.es44.js";
+import { isUnknown as _e, isBoolean as Ae, isNumber as Ee, isString as ve } from "./vue-components.es45.js";
+import { isFailure as R } from "./vue-components.es46.js";
+import { transform as C, Number as Fe } from "./vue-components.es47.js";
+import { make as $e, InvalidType as X, OneOf as je, AnyOf as Ue, Pointer as N, Composite as k, MissingKey as W, UnexpectedKey as Ce, Filter as Ie } from "./vue-components.es48.js";
+import { Transformation as Z, numberFromString as he } from "./vue-components.es49.js";
+function w(e) {
+  return (t) => t._tag === e;
+}
+const kt = /* @__PURE__ */ w("Declaration"), Ot = /* @__PURE__ */ w("Null"), Tt = /* @__PURE__ */ w("Undefined"), Pe = /* @__PURE__ */ w("Never"), Nt = /* @__PURE__ */ w("String"), _t = /* @__PURE__ */ w("Number"), At = /* @__PURE__ */ w("Boolean"), K = /* @__PURE__ */ w("Literal"), Me = /* @__PURE__ */ w("UniqueSymbol"), Et = /* @__PURE__ */ w("Arrays"), vt = /* @__PURE__ */ w("Objects"), Ft = /* @__PURE__ */ w("Union");
+class O {
+  to;
+  transformation;
+  constructor(t, n) {
+    this.to = t, this.transformation = n;
+  }
+}
+const $t = {};
+class ne {
+  isOptional;
+  isMutable;
+  /** Used for constructor default values (e.g. `withConstructorDefault` API) */
+  defaultValue;
+  annotations;
+  constructor(t, n, r = void 0, o = void 0) {
+    this.isOptional = t, this.isMutable = n, this.defaultValue = r, this.annotations = o;
+  }
+}
+const re = "~effect/Schema";
+class S {
+  [re] = re;
+  annotations;
+  checks;
+  encoding;
+  context;
+  constructor(t = void 0, n = void 0, r = void 0, o = void 0) {
+    this.annotations = t, this.checks = n, this.encoding = r, this.context = o;
   }
   toString() {
-    return `SchemaError(${this.message})`;
+    return `<${this._tag}>`;
   }
 }
-function l(e) {
-  return v(e) ? e.value : {
-    issues: [{
-      message: b(e.cause)
-    }]
-  };
+class Le extends S {
+  _tag = "Null";
+  /** @internal */
+  getParser() {
+    return te(this, null);
+  }
+  /** @internal */
+  getExpected() {
+    return "null";
+  }
 }
-function oe(e, r) {
-  const n = k(e), a = {
-    errors: "all",
-    ...r?.parseOptions
-  }, o = C(), i = (s) => {
-    const m = new y(), u = w(U(n(s, a), {
-      onFailure: o,
-      onSuccess: (c) => ({
-        value: c
-      })
-    }), {
-      scheduler: m
+const Re = /* @__PURE__ */ new Le();
+class Be extends S {
+  _tag = "Undefined";
+  /** @internal */
+  getParser() {
+    return te(this, void 0);
+  }
+  /** @internal */
+  encodeToNull() {
+    return x(this, [Ke]);
+  }
+  /** @internal */
+  getExpected() {
+    return "undefined";
+  }
+}
+const Ke = /* @__PURE__ */ new O(Re, /* @__PURE__ */ new Z(/* @__PURE__ */ C(() => {
+}), /* @__PURE__ */ C(() => null))), jt = /* @__PURE__ */ new Be();
+class qe extends S {
+  _tag = "Unknown";
+  /** @internal */
+  getParser() {
+    return V(this, _e);
+  }
+  /** @internal */
+  getExpected() {
+    return "unknown";
+  }
+}
+const Ut = /* @__PURE__ */ new qe();
+class B extends S {
+  _tag = "Literal";
+  literal;
+  constructor(t, n, r, o, i) {
+    if (super(n, r, o, i), typeof t == "number" && !globalThis.Number.isFinite(t))
+      throw new Error(`A numeric literal must be finite, got ${Oe(t)}`);
+    this.literal = t;
+  }
+  /** @internal */
+  getParser() {
+    return te(this, this.literal);
+  }
+  /** @internal */
+  toCodecJson() {
+    return typeof this.literal == "bigint" ? se(this) : this;
+  }
+  /** @internal */
+  toCodecStringTree() {
+    return typeof this.literal == "string" ? this : se(this);
+  }
+  /** @internal */
+  getExpected() {
+    return typeof this.literal == "string" ? JSON.stringify(this.literal) : globalThis.String(this.literal);
+  }
+}
+function se(e) {
+  const t = globalThis.String(e.literal);
+  return x(e, [new O(new B(t), new Z(C(() => e.literal), C(() => t)))]);
+}
+class De extends S {
+  _tag = "String";
+  /** @internal */
+  getParser() {
+    return V(this, ve);
+  }
+  /** @internal */
+  getExpected() {
+    return "string";
+  }
+}
+const Je = /* @__PURE__ */ new De();
+class Ve extends S {
+  _tag = "Number";
+  /** @internal */
+  getParser() {
+    return V(this, Ee);
+  }
+  /** @internal */
+  toCodecJson() {
+    return this.checks && (U(this.checks, "isFinite") || U(this.checks, "isInt")) ? this : x(this, [Xe]);
+  }
+  /** @internal */
+  toCodecStringTree() {
+    return this.checks && (U(this.checks, "isFinite") || U(this.checks, "isInt")) ? x(this, [ot]) : x(this, [ct]);
+  }
+  /** @internal */
+  getExpected() {
+    return "number";
+  }
+}
+function U(e, t) {
+  return e.some((n) => {
+    switch (n._tag) {
+      case "Filter":
+        return n.annotations?.meta?._tag === t;
+      case "FilterGroup":
+        return U(n.checks, t);
+    }
+  });
+}
+const Ge = /* @__PURE__ */ new Ve();
+class ze extends S {
+  _tag = "Boolean";
+  /** @internal */
+  getParser() {
+    return V(this, Ae);
+  }
+  /** @internal */
+  getExpected() {
+    return "boolean";
+  }
+}
+const Ct = /* @__PURE__ */ new ze();
+class ge extends S {
+  _tag = "Arrays";
+  isMutable;
+  elements;
+  rest;
+  constructor(t, n, r, o, i, s, c) {
+    super(o, i, s, c), this.isMutable = t, this.elements = n, this.rest = r;
+    const u = n.findIndex(A);
+    if (u !== -1 && (n.slice(u + 1).some((l) => !A(l)) || r.length > 1))
+      throw new Error("A required element cannot follow an optional element. ts(1257)");
+    if (r.length > 1 && r.slice(1).some(A))
+      throw new Error("An optional element cannot follow a rest element. ts(1266)");
+  }
+  /** @internal */
+  getParser(t) {
+    const n = this, r = n.elements.map((s) => ({
+      ast: s,
+      parser: t(s)
+    })), o = n.rest.map((s) => ({
+      ast: s,
+      parser: t(s)
+    })), i = r.length;
+    return le(function* (s, c) {
+      if (s._tag === "None")
+        return s;
+      const u = s.value;
+      if (!Array.isArray(u))
+        return yield* p(new X(n, s));
+      const l = [];
+      let a;
+      const b = c.errors === "all";
+      let d = 0;
+      for (; d < i; d++) {
+        const h = r[d], m = d < u.length ? I(u[d]) : Ne(), F = h.parser(m, c), g = L(F) ? F : yield* M(F);
+        if (g._tag === "Failure") {
+          const f = P(g.cause);
+          if (R(f))
+            return yield* g;
+          const y = new N([d], f.success);
+          if (b)
+            a ? a.push(y) : a = [y];
+          else
+            return yield* p(new k(n, s, [y]));
+        } else if (g.value._tag === "Some")
+          l[d] = g.value.value;
+        else if (!A(h.ast)) {
+          const f = new N([d], new W(h.ast.context?.annotations));
+          if (b)
+            a ? a.push(f) : a = [f];
+          else
+            return yield* p(new k(n, s, [f]));
+        }
+      }
+      const T = u.length;
+      if (n.rest.length > 0) {
+        const [h, ...m] = o, F = h.ast.context?.annotations;
+        for (; d < T - m.length; d++) {
+          const g = h.parser(I(u[d]), c), f = L(g) ? g : yield* M(g);
+          if (f._tag === "Failure") {
+            const y = P(f.cause);
+            if (R(y))
+              return yield* f;
+            const $ = new N([d], y.success);
+            if (b)
+              a ? a.push($) : a = [$];
+            else
+              return yield* p(new k(n, s, [$]));
+          } else if (f.value._tag === "Some")
+            l[d] = f.value.value;
+          else {
+            const y = new N([d], new W(F));
+            if (b)
+              a ? a.push(y) : a = [y];
+            else
+              return yield* p(new k(n, s, [y]));
+          }
+        }
+        for (let g = 0; g < m.length; g++) {
+          const f = d + g;
+          if (!(T < f)) {
+            const y = m[g], $ = y.ast.context?.annotations, G = y.parser(I(u[f]), c), j = L(G) ? G : yield* M(G);
+            if (j._tag === "Failure") {
+              const _ = P(j.cause);
+              if (R(_))
+                return yield* j;
+              const z = new N([f], _.success);
+              if (b)
+                a ? a.push(z) : a = [z];
+              else
+                return yield* p(new k(n, s, [z]));
+            } else if (j.value._tag === "Some")
+              l[f] = j.value.value;
+            else {
+              const _ = new N([f], new W($));
+              if (b)
+                a ? a.push(_) : a = [_];
+              else
+                return yield* p(new k(n, s, [_]));
+            }
+          }
+        }
+      } else
+        for (let h = i; h <= T - 1; h++) {
+          const m = new N([h], new Ce(n, u[h]));
+          if (b)
+            a ? a.push(m) : a = [m];
+          else
+            return yield* p(new k(n, s, [m]));
+        }
+      return a ? yield* p(new k(n, s, a)) : I(l);
     });
-    m.flush();
-    const d = u.pollUnsafe();
-    return d ? l(d) : new Promise((c) => {
-      u.addObserver((g) => {
-        c(l(g));
+  }
+  /** @internal */
+  recur(t) {
+    const n = Y(this.elements, t), r = Y(this.rest, t);
+    return n === this.elements && r === this.rest ? this : new ge(this.isMutable, n, r, this.annotations, this.checks, void 0, this.context);
+  }
+  /** @internal */
+  getExpected() {
+    return "array";
+  }
+}
+const We = "[+-]?\\d*\\.?\\d+(?:[Ee][+-]?\\d+)?";
+function Ye(e) {
+  return e.ast;
+}
+function It(e, t, n) {
+  return new v(e.map(Ye), t, void 0, n);
+}
+function me(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(([, t]) => typeof t)));
+    case "Literal":
+      return [typeof e.literal];
+    case "Union":
+      return Array.from(new Set(e.types.flatMap(me)));
+    default:
+      return ["null", "undefined", "string", "number", "boolean", "symbol", "bigint", "object", "array", "function"];
+  }
+}
+function ye(e) {
+  switch (e._tag) {
+    default:
+      return [];
+    case "Declaration": {
+      const t = e.annotations?.["~sentinels"];
+      return Array.isArray(t) ? t : [];
+    }
+    case "Objects":
+      return e.propertySignatures.flatMap((t) => {
+        const n = t.type;
+        if (!A(n)) {
+          if (K(n))
+            return [{
+              key: t.name,
+              literal: n.literal
+            }];
+          if (Me(n))
+            return [{
+              key: t.name,
+              literal: n.symbol
+            }];
+        }
+        return [];
       });
-    });
+    case "Arrays":
+      return e.elements.flatMap((t, n) => K(t) && !A(t) ? [{
+        key: n,
+        literal: t.literal
+      }] : []);
+    case "Suspend":
+      return ye(e.thunk());
+  }
+}
+const ie = /* @__PURE__ */ new WeakMap();
+function He(e) {
+  let t = ie.get(e);
+  if (t) return t;
+  t = {};
+  for (const n of e) {
+    const r = ee(n);
+    if (Pe(r)) continue;
+    const o = me(r), i = ye(r);
+    t.byType ??= {};
+    for (const s of o) (t.byType[s] ??= []).push(n);
+    if (i.length > 0) {
+      t.bySentinel ??= /* @__PURE__ */ new Map();
+      for (const {
+        key: s,
+        literal: c
+      } of i) {
+        let u = t.bySentinel.get(s);
+        u || t.bySentinel.set(s, u = /* @__PURE__ */ new Map());
+        let l = u.get(c);
+        l || u.set(c, l = []), l.push(n);
+      }
+    } else {
+      t.otherwise ??= {};
+      for (const s of o) (t.otherwise[s] ??= []).push(n);
+    }
+  }
+  return ie.set(e, t), t;
+}
+function oe(e) {
+  return (t) => {
+    const n = ee(t);
+    return n._tag === "Literal" ? n.literal === e : n._tag === "UniqueSymbol" ? n.symbol === e : !0;
   };
-  if ("~standard" in e) {
-    const s = e;
-    return "validate" in s["~standard"] || Object.assign(s["~standard"], {
-      validate: i
-    }), s;
-  } else
-    return Object.assign(e, {
-      "~standard": {
-        version: 1,
-        vendor: "effect",
-        validate: i
+}
+function Qe(e, t) {
+  const n = He(t), r = e === null ? "null" : Array.isArray(e) ? "array" : typeof e;
+  if (n.bySentinel) {
+    const o = n.otherwise?.[r] ?? [];
+    if (r === "object" || r === "array") {
+      for (const [i, s] of n.bySentinel)
+        if (Object.hasOwn(e, i)) {
+          const c = s.get(e[i]);
+          if (c) return [...c, ...o].filter(oe(e));
+        }
+    }
+    return o;
+  }
+  return (n.byType?.[r] ?? []).filter(oe(e));
+}
+class v extends S {
+  _tag = "Union";
+  types;
+  mode;
+  constructor(t, n, r, o, i, s) {
+    super(r, o, i, s), this.types = t, this.mode = n;
+  }
+  /** @internal */
+  getParser(t) {
+    const n = this;
+    return le(function* (r, o) {
+      if (r._tag === "None")
+        return r;
+      const i = r.value, s = n.mode === "oneOf", c = Qe(i, n.types);
+      let u;
+      const l = {
+        out: void 0,
+        successes: []
+      };
+      for (let a = 0; a < c.length; a++) {
+        const b = c[a], T = t(b)(r, o), h = L(T) ? T : yield* M(T);
+        if (h._tag === "Failure") {
+          const m = P(h.cause);
+          if (R(m))
+            return yield* h;
+          u ? u.push(m.success) : u = [m.success];
+          continue;
+        } else {
+          if (l.out && s)
+            return l.successes.push(b), yield* p(new je(n, i, l.successes));
+          if (l.out = h.value, l.successes.push(b), !s)
+            break;
+        }
+      }
+      return l.out ? l.out : yield* p(new Ue(n, i, u ?? []));
+    });
+  }
+  /** @internal */
+  recur(t) {
+    const n = Y(this.types, t);
+    return n === this.types ? this : new v(n, this.mode, this.annotations, this.checks, void 0, this.context);
+  }
+  /** @internal */
+  getExpected(t) {
+    const n = this.annotations?.expected;
+    if (typeof n == "string") return n;
+    if (this.types.length === 0) return "never";
+    const r = this.types.map((o) => {
+      const i = ee(o);
+      switch (i._tag) {
+        case "Arrays": {
+          const s = i.elements.filter(K);
+          if (s.length > 0)
+            return `${ce(i.isMutable)}[ ${s.map((c) => t(c) + ae(c.context?.isOptional)).join(", ")}, ... ]`;
+          break;
+        }
+        case "Objects": {
+          const s = i.propertySignatures.filter((c) => K(c.type));
+          if (s.length > 0)
+            return `{ ${s.map((c) => `${ce(c.type.context?.isMutable)}${Te(c.name)}${ae(c.type.context?.isOptional)}: ${t(c.type)}`).join(", ")}, ... }`;
+          break;
+        }
       }
+      return t(i);
     });
+    return Array.from(new Set(r)).join(" | ");
+  }
 }
-function R(e) {
-  const r = k(e);
-  return (n, a) => E(r(n, a), (o) => new B(o));
-}
-const se = R, t = $;
-function q(e) {
-  const r = t(new O(e), {
-    literal: e,
-    transform(n) {
-      return r.pipe(D(q(n), {
-        decode: f(() => n),
-        encode: f(() => e)
-      }));
-    }
-  });
-  return r;
-}
-const ae = /* @__PURE__ */ t(L), ce = /* @__PURE__ */ t(T), ie = /* @__PURE__ */ t(x), me = /* @__PURE__ */ t(A), z = /* @__PURE__ */ t(j), ue = /* @__PURE__ */ t(N), de = /* @__PURE__ */ V((e) => t(new I(!1, [], [e.ast]), {
-  schema: e
-}));
-function S(e, r) {
-  return t(e, {
-    members: r,
-    mapMembers(n, a) {
-      const o = n(this.members);
-      return S(h(o, this.ast.mode, a?.unsafePreserveChecks ? this.ast.checks : void 0), o);
-    }
-  });
+const pe = /* @__PURE__ */ new v([/* @__PURE__ */ new B("Infinity"), /* @__PURE__ */ new B("-Infinity"), /* @__PURE__ */ new B("NaN")], "anyOf"), Xe = /* @__PURE__ */ new O(/* @__PURE__ */ new v([Ge, pe], "anyOf"), /* @__PURE__ */ new Z(/* @__PURE__ */ Fe(), /* @__PURE__ */ C((e) => globalThis.Number.isFinite(e) ? e : globalThis.String(e))));
+function ce(e) {
+  return e ? "" : "readonly ";
 }
-function fe(e, r) {
-  return S(h(e, "anyOf", void 0), e);
+function ae(e) {
+  return e ? "?" : "";
 }
-function D(e, r) {
-  return (n) => t(_(n.ast, e.ast, r ? M(r) : P()), {
-    from: n,
-    to: e
-  });
+class q extends de {
+  _tag = "Filter";
+  run;
+  annotations;
+  /**
+   * Whether the parsing process should be aborted after this check has failed.
+   */
+  aborted;
+  constructor(t, n = void 0, r = !1) {
+    super(), this.run = t, this.annotations = n, this.aborted = r;
+  }
+  annotate(t) {
+    return new q(this.run, {
+      ...this.annotations,
+      ...t
+    }, this.aborted);
+  }
+  abort() {
+    return new q(this.run, this.annotations, !0);
+  }
+  and(t, n) {
+    return new D([this, t], n);
+  }
 }
-const G = F;
-function H(e) {
-  return G((r) => globalThis.Number.isSafeInteger(r), {
-    expected: "an integer",
+class D extends de {
+  _tag = "FilterGroup";
+  checks;
+  annotations;
+  constructor(t, n = void 0) {
+    super(), this.checks = t, this.annotations = n;
+  }
+  annotate(t) {
+    return new D(this.checks, {
+      ...this.annotations,
+      ...t
+    });
+  }
+  and(t, n) {
+    return new D([this, t], n);
+  }
+}
+function Ze(e, t, n = !1) {
+  return new q((r, o, i) => $e(r, e(r, o, i)), t, n);
+}
+function et(e, t) {
+  const n = e.source;
+  return Ze((r) => e.test(r), {
+    expected: `a string matching the RegExp ${n}`,
     meta: {
-      _tag: "isInt"
+      _tag: "isPattern",
+      regExp: e
     },
     toArbitraryConstraint: {
-      number: {
-        isInteger: !0
+      string: {
+        patterns: [e.source]
       }
     },
+    ...t
+  });
+}
+function J(e, t) {
+  const n = Object.getOwnPropertyDescriptors(e);
+  return t(n), Object.create(Object.getPrototypeOf(e), n);
+}
+function x(e, t) {
+  return e.encoding === t ? e : J(e, (n) => {
+    n.encoding.value = t;
+  });
+}
+function tt(e, t) {
+  return e.context === t ? e : J(e, (n) => {
+    n.context.value = t;
+  });
+}
+function Pt(e, t) {
+  if (e.checks) {
+    const n = e.checks[e.checks.length - 1];
+    return we(e, xe(e.checks.slice(0, -1), n.annotate(t)));
+  }
+  return J(e, (n) => {
+    n.annotations.value = {
+      ...n.annotations.value,
+      ...t
+    };
+  });
+}
+function we(e, t) {
+  return e.checks === t ? e : J(e, (n) => {
+    n.checks.value = t;
+  });
+}
+function nt(e, t) {
+  return we(e, e.checks ? [...e.checks, ...t] : t);
+}
+function rt(e, t, n) {
+  const r = new O(e, t);
+  return x(n, n.encoding ? [...n.encoding, r] : [r]);
+}
+function Y(e, t) {
+  let n = !1;
+  const r = new Array(e.length);
+  for (let o = 0; o < e.length; o++) {
+    const i = e[o], s = t(i);
+    s !== i && (n = !0), r[o] = s;
+  }
+  return n ? r : e;
+}
+function Mt(e, t) {
+  const n = e.context ? new ne(e.context.isOptional, e.context.isMutable, e.context.defaultValue, {
+    ...e.context.annotations,
+    ...t
+  }) : new ne(!1, !1, void 0, t);
+  return tt(e, n);
+}
+function Lt(e, t, n) {
+  return rt(e, n, t);
+}
+function A(e) {
+  return e.context?.isOptional ?? !1;
+}
+const H = /* @__PURE__ */ Q((e) => {
+  if (e.encoding)
+    return H(x(e, void 0));
+  const t = e;
+  return t.recur?.(H) ?? t;
+}), ee = /* @__PURE__ */ Q((e) => H(E(e)));
+function st(e, t) {
+  const n = t, r = n.length, o = n[r - 1], i = [new O(E(x(e, void 0)), n[0].transformation.flip())];
+  for (let c = 1; c < r; c++)
+    i.unshift(new O(E(n[c - 1].to), n[c].transformation.flip()));
+  const s = E(o.to);
+  return s.encoding ? x(s, [...s.encoding, ...i]) : x(s, i);
+}
+const E = /* @__PURE__ */ Q((e) => {
+  if (e.encoding)
+    return st(e, e.encoding);
+  const t = e;
+  return t.flip?.(E) ?? t.recur?.(E) ?? t;
+});
+function te(e, t) {
+  const n = Se(t);
+  return (r) => r._tag === "None" ? fe : r.value === t ? n : p(new X(e, r));
+}
+function V(e, t) {
+  return (n) => n._tag === "None" ? fe : t(n.value) ? ke(n) : p(new X(e, n));
+}
+const ue = /* @__PURE__ */ new globalThis.RegExp(`^${We}$`);
+function it(e) {
+  return et(ue, {
+    expected: "a string representing a finite number",
+    meta: {
+      _tag: "isStringFinite",
+      regExp: ue
+    },
     ...e
   });
 }
-const pe = /* @__PURE__ */ z.check(/* @__PURE__ */ H());
+const be = /* @__PURE__ */ nt(Je, [/* @__PURE__ */ it()]), ot = /* @__PURE__ */ new O(be, he), ct = /* @__PURE__ */ new O(/* @__PURE__ */ new v([be, pe], "anyOf"), he);
+function at(e, t, n, r, o) {
+  for (let i = 0; i < e.length; i++) {
+    const s = e[i];
+    if (s._tag === "FilterGroup")
+      at(s.checks, t, n, r, o);
+    else {
+      const c = s.run(t, r, o);
+      if (c && (n.push(new Ie(t, s, c)), s.aborted || o?.errors !== "all"))
+        return;
+    }
+  }
+}
+const Rt = "~effect/Schema/Class", Bt = "~structural";
 export {
-  de as Array,
-  ue as Boolean,
-  pe as Int,
-  q as Literal,
-  ce as Null,
-  z as Number,
-  B as SchemaError,
-  me as String,
-  ie as Undefined,
-  fe as Union,
-  ae as Unknown,
-  se as decodeEffect,
-  D as decodeTo,
-  R as decodeUnknownEffect,
-  H as isInt,
-  t as make,
-  G as makeFilter,
-  oe as toStandardSchemaV1
+  ge as Arrays,
+  S as Base,
+  ze as Boolean,
+  Rt as ClassTypeId,
+  ne as Context,
+  We as FINITE_PATTERN,
+  q as Filter,
+  D as FilterGroup,
+  O as Link,
+  B as Literal,
+  Le as Null,
+  Ve as Number,
+  Bt as STRUCTURAL_ANNOTATION_KEY,
+  De as String,
+  Be as Undefined,
+  v as Union,
+  qe as Unknown,
+  Pt as annotate,
+  Mt as annotateKey,
+  nt as appendChecks,
+  Ct as boolean,
+  at as collectIssues,
+  ye as collectSentinels,
+  Lt as decodeTo,
+  $t as defaultParseOptions,
+  E as flip,
+  Ye as getAST,
+  Qe as getCandidates,
+  Et as isArrays,
+  At as isBoolean,
+  kt as isDeclaration,
+  K as isLiteral,
+  Pe as isNever,
+  Ot as isNull,
+  _t as isNumber,
+  vt as isObjects,
+  A as isOptional,
+  et as isPattern,
+  Nt as isString,
+  it as isStringFinite,
+  Tt as isUndefined,
+  Ft as isUnion,
+  Me as isUniqueSymbol,
+  Ze as makeFilter,
+  Y as mapOrSame,
+  Re as null,
+  Ge as number,
+  we as replaceChecks,
+  tt as replaceContext,
+  x as replaceEncoding,
+  Je as string,
+  ee as toEncoded,
+  H as toType,
+  jt as undefined,
+  It as union,
+  Ut as unknown
 };