@effector-reform/core/dist/index.js

Effector composable forms core

import { combine as ve, createStore as w, createEvent as c, sample as a, withFactory as q, clearNode as Ke, createEffect as _, attach as O } from "effector";
import { spread as P, combineEvents as Le } from "patronum";
const ce = Symbol("primitive-field"), Ne = {
  error: null,
  meta: {},
  copyOnCreateForm: !0
};
function Ee(r, t, e) {
  return e ? w(t, {
    and: {
      name: r,
      sid: e
    },
    sid: "40vi2r"
  }) : w(t, {
    and: {
      name: r
    },
    sid: "41fao4"
  });
}
function Pe(r, t) {
  const e = {
    ...Ne,
    ...t
  }, o = Ee("<field value>", r, e.sid ? `${e.sid}|value` : void 0), n = Ee("<inner field error>", null, e.sid ? `${e.sid}|innerError` : void 0), d = Ee("<outer field error>", null, e.sid ? `${e.sid}|outerError` : void 0), v = ve({
    and: [{
      innerError: n,
      outerError: d
    }],
    or: {
      name: "$error",
      sid: "ifptcx"
    }
  }).map((j) => {
    let {
      innerError: M,
      outerError: K
    } = j;
    return K || M;
  }), l = v.map((j) => j === null), s = w(!1, {
    name: "$isFocused",
    sid: "-2xdhda"
  }), b = w(e.meta, {
    name: "$meta",
    sid: "yljxe2"
  }), h = c({
    name: "changeMeta",
    sid: "-jmefxi"
  }), x = c({
    name: "metaChanged",
    sid: "fgh8aa"
  });
  a({
    and: [{
      clock: h,
      target: b
    }],
    or: {
      sid: "5z95xj"
    }
  }), a({
    and: [{
      clock: b,
      target: x
    }],
    or: {
      sid: "6djtcx"
    }
  });
  const F = c("<field change>", {
    name: "change",
    sid: "-38drp0"
  }), V = c("<field changed>", {
    name: "changed",
    sid: "-a6r6"
  }), I = c({
    name: "blur",
    sid: "1cw1wt"
  }), g = c({
    name: "blurred",
    sid: "pe3hzg"
  }), y = c({
    name: "focus",
    sid: "-lg5huu"
  }), f = c({
    name: "focused",
    sid: "edqbva"
  }), m = c("<field setError>", {
    name: "changeError",
    sid: "-d2tdt0"
  }), S = c("<field error changed>", {
    name: "errorChanged",
    sid: "-2ezx1u"
  }), A = c({
    name: "setInnerError",
    sid: "-hg9joi"
  }), oe = c({
    name: "setOuterError",
    sid: "-xabkaw"
  }), T = c("<field reset>", {
    name: "reset",
    sid: "vep2yb"
  }), W = c("<field reset completed>", {
    name: "resetCompleted",
    sid: "-e32xgf"
  }), D = c({
    name: "batchedSetInnerError",
    sid: "tto6e9"
  }), G = c({
    name: "batchedSetOuterError",
    sid: "dzm5rv"
  }), R = c({
    name: "batchedSetValue",
    sid: "-ro0l66"
  }), z = c({
    name: "batchedReset",
    sid: "-lmwnlm"
  });
  return a({
    and: [{
      clock: I,
      fn: () => !1,
      target: s
    }],
    or: {
      sid: "-xrmknn"
    }
  }), a({
    and: [{
      clock: y,
      fn: () => !0,
      target: s
    }],
    or: {
      sid: "-xr2s2a"
    }
  }), a({
    and: [{
      clock: s,
      filter: (j) => j,
      target: f
    }],
    or: {
      sid: "-xpz6vk"
    }
  }), a({
    and: [{
      clock: s,
      filter: (j) => !j,
      target: g
    }],
    or: {
      sid: "-xpfea7"
    }
  }), a({
    and: [{
      clock: A,
      target: n
    }],
    or: {
      sid: "-xobt3h"
    }
  }), a({
    and: [{
      clock: m,
      target: d
    }],
    or: {
      sid: "-xa15o3"
    }
  }), a({
    and: [{
      clock: F,
      target: o
    }],
    or: {
      sid: "-x7a6pa"
    }
  }), a({
    and: [{
      clock: R,
      fn: (j) => j.value,
      target: o
    }],
    or: {
      sid: "-wumx1z"
    }
  }), a({
    and: [{
      clock: D,
      fn: (j) => j.value,
      target: n
    }],
    or: {
      sid: "-wrc5ht"
    }
  }), a({
    and: [{
      clock: G,
      fn: (j) => j.value,
      target: d
    }],
    or: {
      sid: "-wchph2"
    }
  }), a({
    and: [{
      clock: o,
      target: V
    }],
    or: {
      sid: "-w96xww"
    }
  }), a({
    and: [{
      clock: m,
      target: d
    }],
    or: {
      sid: "-vx3guy"
    }
  }), a({
    and: [{
      clock: v,
      target: S
    }],
    or: {
      sid: "-vvzvo8"
    }
  }), a({
    and: [{
      clock: A,
      target: n
    }],
    or: {
      sid: "-vvg32v"
    }
  }), a({
    and: [{
      clock: [T, z],
      fn: () => ({
        value: r,
        outerError: (t == null ? void 0 : t.error) ?? null,
        completed: {
          value: r,
          error: (t == null ? void 0 : t.error) ?? null
        },
        innerError: null
      }),
      target: q({
        sid: "-1q57iq",
        fn: () => P({
          value: o,
          completed: W,
          outerError: d,
          innerError: n
        }),
        name: "target",
        method: "spread"
      })
    }],
    or: {
      sid: "-vuchw5"
    }
  }), {
    "@@type": ce,
    batchedSetInnerError: D,
    batchedSetOuterError: G,
    batchedSetValue: R,
    batchedReset: z,
    $meta: b,
    $value: o,
    $outerError: d,
    $innerError: n,
    $error: v,
    $isValid: l,
    $isFocused: s,
    changeMeta: h,
    metaChanged: x,
    blur: I,
    blurred: g,
    focus: y,
    focused: f,
    change: F,
    changed: V,
    changeError: m,
    errorChanged: S,
    reset: T,
    resetCompleted: W,
    setInnerError: A,
    setOuterError: oe,
    copyOnCreateForm: e.copyOnCreateForm,
    sid: e.sid,
    "@@unitShape": () => ({
      value: o,
      error: v,
      meta: b,
      isValid: l,
      isFocused: s,
      changeMeta: h,
      blur: I,
      blurred: g,
      focus: y,
      focused: f,
      changeError: m,
      change: F,
      reset: T
    })
  };
}
function be(r) {
  let t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1;
  for (const e of r)
    Ke(e, t ? {
      deep: t
    } : void 0);
}
function $(r) {
  const t = [], e = w(-1, {
    name: "$lastIndex",
    sid: "-8wc724"
  }), o = w([...t], {
    name: "$payloads",
    sid: "i6kdoz"
  }), n = c({
    name: "reset",
    sid: "1ok3o"
  }), d = c({
    name: "target",
    sid: "-ppag00"
  }), v = r;
  a({
    and: [{
      clock: d,
      target: n
    }],
    or: {
      sid: "2gntpx"
    }
  }), a({
    and: [{
      clock: n,
      fn: () => ({
        lastIndex: -1,
        payloads: [...t]
      }),
      target: q({
        sid: "-a2sx3w",
        fn: () => P({
          lastIndex: e,
          payloads: o
        }),
        name: "target",
        method: "spread"
      })
    }],
    or: {
      sid: "2uyh5b"
    }
  });
  for (let l = 0; l < v.length; l++) {
    const s = v[l];
    a({
      and: [{
        clock: s,
        source: e,
        filter: (b) => l - b !== 1,
        target: n
      }],
      or: {
        sid: "3d3ory"
      }
    }), l === v.length - 1 ? a({
      and: [{
        clock: s,
        source: [e, o],
        filter: (b) => {
          let [h] = b;
          return l - h === 1;
        },
        fn: (b, h) => {
          let [, x] = b;
          return [...x, h];
        },
        target: d
      }],
      or: {
        sid: "3t1q15"
      }
    }) : a({
      and: [{
        clock: s,
        source: [e, o],
        filter: (b) => {
          let [h] = b;
          return l - h === 1;
        },
        fn: (b, h) => {
          let [, x] = b;
          return {
            lastIndex: l,
            payloads: [...x, h]
          };
        },
        target: q({
          sid: "zdisu8",
          fn: () => P({
            lastIndex: e,
            payloads: o
          }),
          name: "target",
          method: "spread"
        })
      }],
      or: {
        sid: "48zr8m"
      }
    });
  }
  return d;
}
function We(r) {
  return "@@type" in r && r["@@type"] === ce;
}
function $e(r) {
  return typeof r == "boolean" || typeof r == "string" || typeof r == "number" || r === null;
}
function N(r) {
  const t = typeof File < "u" ? r instanceof File : !1, e = typeof Buffer < "u" ? r instanceof Buffer : !1, o = typeof FileList < "u" ? r instanceof FileList : !1;
  return $e(r) || typeof r == "bigint" || e || t || o || r instanceof Date || r instanceof Blob || r instanceof ArrayBuffer || r instanceof Int8Array || r instanceof Int16Array || r instanceof Int32Array || r instanceof BigInt64Array;
}
function Be(r) {
  let t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1;
  const e = r;
  be([r.$value, r.$error, r.$meta, r.change, r.changeError, r.errorChanged, r.changed, r.reset, r.resetCompleted, r.metaChanged, e.$outerError, e.$innerError, e.setInnerError, e.batchedSetValue, e.batchedSetOuterError, e.batchedSetInnerError, e.batchedReset], t);
}
const le = Symbol("array-field");
function Ge(r, t) {
  return r.reduce((e, o, n) => (t.includes(o) || (e.nodes.push(o), e.indexes.push(n)), e), {
    nodes: [],
    indexes: []
  });
}
function Ue(r) {
  let t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1;
  const e = r;
  be([e.$values, e.$error, e.$meta, e.change, e.changed, e.changeError, e.errorChanged, e.insert, e.inserted, e.move, e.moved, e.pop, e.popped, e.push, e.pushed, e.remove, e.removed, e.replace, e.replaced, e.swap, e.swapped, e.unshift, e.unshifted, e.clear, e.cleared, e.reset, e.resetCompleted, e.setInnerError, e.batchedSetValue, e.batchedSetOuterError, e.batchedSetInnerError, e.batchedClear, e.batchedReset, e.metaChanged], t);
}
function we(r) {
  if (!N(r))
    for (const t in r) {
      const e = r[t];
      switch (e["@@type"]) {
        case le: {
          const o = e.$values.getState();
          for (const n of o) {
            if (N(n))
              break;
            we(n);
          }
          Ue(e);
          break;
        }
        case ce: {
          Be(e);
          break;
        }
        default: {
          we(e);
          break;
        }
      }
    }
}
function Je(r) {
  return "@@type" in r && r["@@type"] === le;
}
function He() {
  const r = c("<schema updated>", {
    name: "schemaUpdated",
    sid: "ogwkmf"
  }), t = c("<blurred>", {
    name: "blurred",
    sid: "-vtbsm2"
  }), e = c("<focused>", {
    name: "focused",
    sid: "r8rv7c"
  }), o = c({
    name: "metaChanged",
    sid: "p0ft9i"
  });
  return {
    blurred: t,
    focused: e,
    schemaUpdated: r,
    metaChanged: o
  };
}
function ke(r, t) {
  return {
    id: Math.random().toString(),
    type: t,
    fields: r
  };
}
function xe(r) {
  return Object.values(r).reduce((t, e) => (e.fields.length > 0 || (t.tasks.push(e), e.type === "values" && t.updateType !== "all" ? t.updateType = t.updateType === "error" ? "all" : "value" : e.type === "errors" && t.updateType !== "all" ? t.updateType = t.updateType === "value" ? "all" : "error" : (e.type === "reset" || e.type === "all") && (t.updateType = "all")), t), {
    tasks: [],
    updateType: "none"
  });
}
function Qe(r) {
  const t = w({}, {
    and: {
      name: "<batch info>"
    },
    name: "$tasks",
    sid: "-c2xgvr"
  }), e = c({
    name: "batchedSchemaUpdated",
    sid: "-o4wxhp"
  }), o = c("<add batch task>", {
    name: "addBatchTask",
    sid: "bogptp"
  });
  return a({
    and: [{
      clock: o,
      source: t,
      fn: (n, d) => ({
        ...n,
        [d.id]: d
      }),
      target: t
    }],
    or: {
      sid: "-44ej8y"
    }
  }), a({
    and: [{
      clock: e,
      source: t,
      filter: (n, d) => {
        let {
          "@@batchInfo": v
        } = d;
        return !!n[v.id];
      },
      fn: (n, d) => {
        let {
          fieldPath: v,
          "@@batchInfo": l
        } = d;
        const s = n[l.id];
        return s.fields = s.fields.filter((b) => b !== v), {
          ...n
        };
      },
      target: t
    }],
    or: {
      sid: "-40jz3f"
    }
  }), a({
    and: [{
      clock: t,
      filter: (n) => xe(n).tasks.length > 0,
      fn: (n) => {
        const {
          tasks: d,
          updateType: v
        } = xe(n);
        return {
          fieldPath: d.map((l) => l.fields).join(" "),
          type: v
        };
      },
      target: r
    }],
    or: {
      sid: "-35rhv7"
    }
  }), a({
    and: [{
      clock: t,
      fn: (n) => {
        const {
          tasks: d
        } = xe(n);
        if (d.length === 0)
          return n;
        const v = {
          ...n
        };
        for (const l of d)
          delete v[l.id];
        return v;
      },
      target: t
    }],
    or: {
      sid: "-2mip3k"
    }
  }), {
    addBatchTask: o,
    batchedSchemaUpdated: e
  };
}
function Fe(r, t) {
  const e = r[t];
  if (!e)
    throw new Error(`unknown field with path ${t}`);
  if (e.type !== "array-field")
    throw new Error(`expected field type "array-field", received "${e.type}"`);
  return e;
}
function Xe(r) {
  var t = this;
  let {
    field: e,
    path: o,
    key: n,
    resultErrorsNode: d,
    resultValuesNode: v,
    map: l
  } = r;
  const s = e, b = s.$values.getState(), h = [...o, n].join(".");
  v[n] = [], d[n] = {
    error: s.$error.getState(),
    errors: []
  };
  const x = {
    value: [],
    error: s.$error.getState(),
    type: "array-field",
    isValid: !d[n].error,
    reset: s.reset,
    batchedSetValue: s.batchedSetValue,
    batchedSetOuterError: s.batchedSetOuterError,
    batchedSetInnerError: s.batchedSetInnerError,
    batchedReset: s.batchedReset,
    batchedClear: s.batchedClear,
    clearMemory: function() {
      (arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : !1) && Ue(s), be([I, V, g, y]), delete t.api[h];
    },
    clearValuesMemory: () => {
      const f = Object.keys(this.api).filter((m) => m.startsWith(h)).filter((m) => m !== h);
      for (const m of f)
        this.api[m].clearMemory();
    },
    clearInnerError: s.setInnerError.prepend(() => null),
    clearOuterError: s.changeError.prepend(() => null),
    setInnerError: s.setInnerError,
    setOuterError: s.changeError,
    setValue: s.change
  };
  this.api[h] = x, d[n].error && (this.isValid = !1);
  const F = (f) => {
    f.map((m, S) => {
      N(m) ? v[n].push(m) : (v[n].push({}), d[n].errors.push({}), l.call(this, m, v[n][S], d[n].errors[S], [...o, n, S.toString()]));
    }), x.value = f;
  };
  F(b);
  const V = _((f) => {
    let {
      values: m
    } = f;
    Fe(this.api, h).clearValuesMemory(), v[n] = [], d[n].errors = [], F(m);
  }, {
    name: "changeValuesFx",
    sid: "-ocpygv"
  }), I = _((f) => {
    let {
      error: m
    } = f;
    d[n].error = m, x.error = m, x.isValid = !d[n].error, d[n].error && (this.isValid = !1);
  }, {
    name: "changeErrorFx",
    sid: "95gzew"
  }), g = _(() => {
    Fe(this.api, h).clearValuesMemory(), v[n] = [], d[n] = {
      error: null,
      errors: []
    }, x.value = [], x.error = null, x.isValid = !d[n].error;
  }, {
    name: "clearFx",
    sid: "23u912"
  }), y = _((f) => {
    let {
      error: m,
      values: S
    } = f;
    Fe(this.api, h).clearValuesMemory(), v[n] = [], d[n] = {
      error: m,
      errors: []
    }, x.isValid = !d[n].error, x.value = [], x.error = m, F(S);
  }, {
    name: "resetFx",
    sid: "tky7bo"
  });
  a({
    and: [{
      clock: [$([s.setInnerError, s.errorChanged]), $([s.changeError, s.errorChanged])],
      source: s.$error,
      fn: (f) => ({
        error: f
      }),
      target: I
    }],
    or: {
      sid: "-k02n4o"
    }
  }), a({
    and: [{
      clock: [$([s.change, s.changed]), $([s.pushed, s.changed]), $([s.swapped, s.changed]), $([s.moved, s.changed]), $([s.inserted, s.changed]), $([s.unshifted, s.changed]), $([s.removed, s.changed]), $([s.popped, s.changed]), $([s.replaced, s.changed])],
      fn: (f) => {
        let [, m] = f;
        return {
          values: m
        };
      },
      target: V
    }],
    or: {
      sid: "-jj10qh"
    }
  }), a({
    and: [{
      clock: $([s.reset, s.resetCompleted]),
      fn: (f) => {
        let [, {
          values: m,
          error: S
        }] = f;
        return {
          values: m,
          error: S
        };
      },
      target: y
    }],
    or: {
      sid: "-8p6w1g"
    }
  }), a({
    and: [{
      clock: $([s.clear, s.cleared]),
      fn: () => ({}),
      target: g
    }],
    or: {
      sid: "-88p28m"
    }
  }), a({
    and: [{
      clock: s.batchedSetValue,
      filter: (f) => {
        let {
          value: m
        } = f;
        return v[n] === m;
      },
      fn: (f) => {
        let {
          "@@batchInfo": m
        } = f;
        return {
          fieldPath: h,
          "@@batchInfo": m
        };
      },
      target: this.batchedSchemaUpdated
    }],
    or: {
      sid: "-84ui33"
    }
  }), a({
    and: [{
      clock: $([s.batchedClear, s.cleared]),
      fn: (f) => {
        let [{
          "@@batchInfo": m
        }] = f;
        return {
          batchInfo: m
        };
      },
      target: g
    }],
    or: {
      sid: "-7n933j"
    }
  }), a({
    and: [{
      clock: $([s.batchedReset, s.resetCompleted]),
      fn: (f) => {
        let [{
          "@@batchInfo": m
        }, {
          values: S,
          error: A
        }] = f;
        return {
          values: S,
          error: A,
          batchInfo: m
        };
      },
      target: y
    }],
    or: {
      sid: "-78en2s"
    }
  }), a({
    and: [{
      clock: $([s.batchedSetValue, s.changed]),
      source: s.$values,
      fn: (f, m) => {
        let [{
          "@@batchInfo": S
        }] = m;
        return {
          values: f,
          batchInfo: S
        };
      },
      target: V
    }],
    or: {
      sid: "-6rd0ol"
    }
  }), a({
    and: [{
      clock: s.batchedSetInnerError,
      source: s.$outerError,
      fn: (f, m) => {
        let {
          value: S,
          "@@batchInfo": A
        } = m;
        return {
          error: f ?? S,
          batchInfo: A
        };
      },
      target: I
    }],
    or: {
      sid: "-6bys2h"
    }
  }), a({
    and: [{
      clock: s.batchedSetOuterError,
      fn: (f) => {
        let {
          value: m,
          "@@batchInfo": S
        } = f;
        return {
          error: m,
          batchInfo: S
        };
      },
      target: I
    }],
    or: {
      sid: "-5ux5oa"
    }
  }), a({
    and: [{
      clock: I.done,
      filter: (f) => {
        let {
          params: m
        } = f;
        return !m.batchInfo;
      },
      fn: () => ({
        fieldPath: h,
        type: "error"
      }),
      target: this.schemaUpdated
    }],
    or: {
      sid: "-5rme44"
    }
  }), a({
    and: [{
      clock: [V.done, I.done, y.done, g.done],
      filter: (f) => {
        let {
          params: m
        } = f;
        return !!m.batchInfo;
      },
      fn: (f) => {
        let {
          params: m
        } = f;
        return {
          fieldPath: h,
          "@@batchInfo": m.batchInfo
        };
      },
      target: this.batchedSchemaUpdated
    }],
    or: {
      sid: "-5akrpx"
    }
  }), a({
    and: [{
      clock: V.done,
      filter: (f) => {
        let {
          params: m
        } = f;
        return !m.batchInfo;
      },
      fn: () => ({
        fieldPath: h,
        type: "value"
      }),
      target: this.schemaUpdated
    }],
    or: {
      sid: "5ipkdr"
    }
  }), a({
    and: [{
      clock: s.metaChanged,
      fn: (f) => ({
        fieldPath: h,
        meta: f
      }),
      target: this.metaChanged
    }],
    or: {
      sid: "5zr6ry"
    }
  });
}
function Ye(r) {
  var t = this;
  let {
    resultValuesNode: e,
    resultErrorsNode: o,
    field: n,
    key: d,
    path: v
  } = r;
  const l = n, s = l.$value.getState(), b = l.$error.getState();
  e[d] = s, o[d] = b;
  const h = [...v, d].join("."), x = {
    type: "primitive-field",
    isValid: !o[d],
    value: s,
    error: b,
    reset: l.reset,
    clearMemory: function() {
      (arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : !1) && Be(l), be([F, V, I]), delete t.api[h];
    },
    batchedSetValue: l.batchedSetValue,
    batchedSetOuterError: l.batchedSetOuterError,
    batchedSetInnerError: l.batchedSetInnerError,
    batchedReset: l.batchedReset,
    clearInnerError: l.setInnerError.prepend(() => null),
    clearOuterError: l.changeError.prepend(() => null),
    setInnerError: l.setInnerError,
    setOuterError: l.changeError,
    setValue: l.change
  };
  this.api[h] = x, o[d] && (this.isValid = !1);
  const F = _((g) => {
    let {
      value: y
    } = g;
    e[d] = y, x.value = y;
  }, {
    name: "changeValueFx",
    sid: "kchsv7"
  }), V = _((g) => {
    let {
      error: y
    } = g;
    o[d] = y, x.value = y, x.isValid = !o[d], o[d] && (this.isValid = !1);
  }, {
    name: "changeErrorFx",
    sid: "ridz2d"
  }), I = _((g) => {
    let {
      value: y,
      error: f
    } = g;
    e[d] = y, o[d] = f, x.value = y, x.value = f, x.isValid = !o[d], o[d] && (this.isValid = !1);
  }, {
    name: "resetFx",
    sid: "-jm7iry"
  });
  a({
    and: [{
      clock: $([l.changeError, l.errorChanged]),
      fn: (g) => {
        let [y] = g;
        return {
          error: y
        };
      },
      target: V
    }],
    or: {
      sid: "-524kpx"
    }
  }), a({
    and: [{
      clock: $([l.change, l.changed]),
      fn: (g) => {
        let [y] = g;
        return {
          value: y
        };
      },
      target: F
    }],
    or: {
      sid: "-4na4p6"
    }
  }), a({
    and: [{
      clock: $([l.reset, l.resetCompleted]),
      fn: (g) => {
        let [, {
          value: y,
          error: f
        }] = g;
        return {
          value: y,
          error: f
        };
      },
      target: I
    }],
    or: {
      sid: "-4jzd50"
    }
  }), a({
    and: [{
      clock: F.done,
      filter: (g) => {
        let {
          params: y
        } = g;
        return !y.batchInfo;
      },
      fn: () => ({
        fieldPath: h,
        type: "value"
      }),
      target: this.schemaUpdated
    }],
    or: {
      sid: "-43hjc6"
    }
  }), a({
    and: [{
      clock: V.done,
      filter: (g) => {
        let {
          params: y
        } = g;
        return !y.batchInfo;
      },
      fn: () => ({
        fieldPath: h,
        type: "error"
      }),
      target: this.schemaUpdated
    }],
    or: {
      sid: "-3mfwxz"
    }
  }), a({
    and: [{
      clock: I.done,
      filter: (g) => {
        let {
          params: y
        } = g;
        return !y.batchInfo;
      },
      fn: () => ({
        fieldPath: h,
        type: "all"
      }),
      target: this.schemaUpdated
    }],
    or: {
      sid: "-35eajs"
    }
  }), a({
    and: [{
      clock: l.batchedSetValue,
      filter: (g) => {
        let {
          value: y
        } = g;
        return y === e[d];
      },
      fn: (g) => {
        let {
          "@@batchInfo": y
        } = g;
        return {
          fieldPath: h,
          "@@batchInfo": y
        };
      },
      target: this.batchedSchemaUpdated
    }],
    or: {
      sid: "-2nsvk8"
    }
  }), a({
    and: [{
      clock: l.batchedSetInnerError,
      source: l.$outerError,
      fn: (g, y) => {
        let {
          value: f,
          "@@batchInfo": m
        } = y;
        return {
          error: g ?? f,
          batchInfo: m
        };
      },
      target: V
    }],
    or: {
      sid: "-267gko"
    }
  }), a({
    and: [{
      clock: l.batchedSetOuterError,
      source: l.$innerError,
      fn: (g, y) => {
        let {
          value: f,
          "@@batchInfo": m
        } = y;
        return {
          error: f ?? g,
          batchInfo: m
        };
      },
      target: V
    }],
    or: {
      sid: "-1p5u6h"
    }
  }), a({
    and: [{
      clock: $([l.batchedSetValue, l.changed]),
      source: l.$value,
      fn: (g, y) => {
        let [{
          "@@batchInfo": f
        }] = y;
        return {
          value: g,
          batchInfo: f
        };
      },
      target: F
    }],
    or: {
      sid: "-1847sa"
    }
  }), a({
    and: [{
      clock: $([l.batchedReset, l.resetCompleted]),
      fn: (g) => {
        let [{
          "@@batchInfo": y
        }, {
          value: f,
          error: m
        }] = g;
        return {
          value: f,
          error: m,
          batchInfo: y
        };
      },
      target: I
    }],
    or: {
      sid: "96vgw0"
    }
  }), a({
    and: [{
      clock: [F.done, V.done, I.done],
      filter: (g) => {
        let {
          params: y
        } = g;
        return !!y.batchInfo;
      },
      fn: (g) => {
        let {
          params: y
        } = g;
        return {
          fieldPath: h,
          "@@batchInfo": y.batchInfo
        };
      },
      target: this.batchedSchemaUpdated
    }],
    or: {
      sid: "9nx3a7"
    }
  }), a({
    and: [{
      clock: l.focused,
      fn: () => ({
        fieldPath: h
      }),
      target: this.focused
    }],
    or: {
      sid: "a4ypoe"
    }
  }), a({
    and: [{
      clock: l.blurred,
      fn: () => ({
        fieldPath: h
      }),
      target: this.blurred
    }],
    or: {
      sid: "ajt5p5"
    }
  }), a({
    and: [{
      clock: l.metaChanged,
      fn: (g) => ({
        fieldPath: h,
        meta: g
      }),
      target: this.metaChanged
    }],
    or: {
      sid: "an3x9b"
    }
  });
}
function Ie(r, t, e) {
  let o = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : [];
  for (const n in r) {
    const d = r[n];
    switch (d["@@type"]) {
      case ce: {
        Ye.call(this, {
          field: d,
          resultValuesNode: t,
          resultErrorsNode: e,
          key: n,
          path: o
        });
        break;
      }
      case le: {
        Xe.call(this, {
          field: d,
          resultValuesNode: t,
          resultErrorsNode: e,
          key: n,
          path: o,
          map: Ie
        });
        break;
      }
      default: {
        t[n] = {}, e[n] = {}, Ie.call(this, d, t[n], e[n], [...o, n]);
        break;
      }
    }
  }
}
function Ze(r, t, e, o, n, d) {
  const v = {}, l = {}, s = {}, b = {}, h = {
    api: b,
    plainErrors: s,
    isValid: !0,
    metaChanged: t,
    schemaUpdated: e,
    batchedSchemaUpdated: o,
    focused: n,
    blurred: d
  };
  return Ie.call(h, r, v, l), {
    api: b,
    values: v,
    errors: l,
    isValid: h.isValid
  };
}
function Oe(r, t, e) {
  const o = Object.keys(r), n = ke(o, "errors");
  t(n);
  for (const d of o) {
    const v = r[d];
    e === "inner" ? v.batchedSetInnerError({
      value: null,
      "@@batchInfo": {
        fieldPath: d,
        id: n.id
      }
    }) : e === "outer" && v.batchedSetOuterError({
      value: null,
      "@@batchInfo": {
        fieldPath: d,
        id: n.id
      }
    });
  }
}
function Ve(r, t, e, o) {
  let n = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : !1;
  const d = Object.keys(t), v = n ? d : Object.keys(r);
  if (Object.keys(v).length === 0)
    return;
  const l = ke(v, "errors");
  e(l);
  for (const s of v) {
    const b = t[s];
    if (!b) {
      console.error(`Unknown field with path: ${s}`);
      continue;
    }
    switch (o) {
      case "inner": {
        b.batchedSetInnerError({
          value: r[s] ?? null,
          "@@batchInfo": {
            id: l.id,
            fieldPath: s
          }
        });
        break;
      }
      case "outer": {
        b.batchedSetOuterError({
          value: r[s] ?? null,
          "@@batchInfo": {
            id: l.id,
            fieldPath: s
          }
        });
        break;
      }
    }
  }
}
function er(r, t, e) {
  const o = {};
  function n(v) {
    let l = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
    for (const s in v) {
      const b = v[s], h = [...l, s].join(".");
      if (N(b) || Array.isArray(b)) {
        const x = t[h];
        if (!x) {
          console.error(`Unknown field with path: ${h}`);
          continue;
        }
        o[h] = {
          setValue: x.batchedSetValue,
          value: b
        };
        continue;
      }
      typeof b == "object" && n(b, [...l, s]);
    }
  }
  if (n(r), Object.keys(o).length === 0)
    return;
  const d = ke(Object.keys(o), "values");
  e(d);
  for (const v in o)
    o[v].setValue({
      value: o[v].value,
      "@@batchInfo": {
        id: d.id,
        fieldPath: v
      }
    });
}
function rr(r) {
  const t = r.match(/[\w\s:]+expected/);
  if (!t)
    throw new Error();
  return t[0].replace(" expected", "").replace(/:/g, "").split(" ").join(".");
}
function tr(r) {
  return r !== null && typeof r == "object" && "isData" in r && "getErrorMessages" in r;
}
function ar(r) {
  return (t) => r.isData(t) ? null : r.getErrorMessages(t).reduce((e, o) => (e[rr(o)] = o, e), {});
}
function ze(r) {
  let t = !0;
  for (const e in r)
    if (!r[e].isValid) {
      t = !1;
      break;
    }
  return t;
}
function je(r, t) {
  const {
    schemaUpdated: e,
    focused: o,
    blurred: n,
    metaChanged: d
  } = He(), {
    batchedSchemaUpdated: v,
    addBatchTask: l
  } = Qe(e), s = Ze(r, d, e, v, o, n), b = w(s.api, {
    and: {
      serialize: "ignore"
    },
    name: "$api",
    sid: "6pgzrr"
  }), h = t ? w(s.values, {
    and: {
      sid: `${t}|form|values`
    },
    name: "$values",
    sid: "-b8aqxw"
  }) : w(s.values, {
    name: "$values",
    sid: "-b7qycj"
  }), x = t ? w(s.errors, {
    and: {
      sid: `${t}|form|errors`
    },
    name: "$errors",
    sid: "a17hry"
  }) : w(s.errors, {
    name: "$errors",
    sid: "a1radb"
  }), F = t ? w(s.isValid, {
    and: {
      sid: `${t}|form|isValid`
    },
    name: "$isValid",
    sid: "-n061j3"
  }) : w(s.isValid, {
    name: "$isValid",
    sid: "-mzm8xq"
  });
  return a({
    and: [{
      clock: e,
      fn: (V) => {
        switch (V.type) {
          case "value":
            return {
              values: {
                ...s.values
              },
              api: {
                ...s.api
              }
            };
          case "error":
            return {
              errors: {
                ...s.errors
              },
              isValid: ze(s.api)
            };
          case "all":
            return {
              values: {
                ...s.values
              },
              api: {
                ...s.api
              },
              errors: {
                ...s.errors
              },
              isValid: ze(s.api)
            };
          case "none":
            return {};
        }
      },
      target: q({
        sid: "-x3vhi8",
        fn: () => P({
          api: b,
          values: h,
          errors: x,
          isValid: F
        }),
        name: "target",
        method: "spread"
      })
    }],
    or: {
      sid: "p9z1mi"
    }
  }), {
    $api: b,
    $values: h,
    $errors: x,
    $isValid: F,
    addBatchTask: l,
    focused: o,
    blurred: n,
    metaChanged: d
  };
}
const nr = {
  error: null,
  meta: {},
  copyOnCreateForm: !0
};
function Me(r, t) {
  const {
    sid: e
  } = w(null, {
    sid: "rw58d"
  });
  function o() {
    return r.map((u) => se(u));
  }
  function n(u) {
    return Array.isArray(u) ? u.map((k) => se(k, {
      path: [],
      baseSid: e
    })) : [se(u, {
      path: [],
      baseSid: e
    })];
  }
  const d = {
    ...nr,
    ...t
  }, v = _((u) => {
    let {
      nodes: k
    } = u;
    for (const p of k) {
      if (N(p))
        break;
      we(p);
    }
  }, {
    name: "clearNodesFx",
    sid: "ybmtf1"
  }), l = o(), s = {
    read(u) {
      if (!u)
        throw new Error();
      if (!Array.isArray(u))
        throw new Error();
      return u.map((k) => {
        const p = se(k.values, {
          path: [],
          baseSid: e
        }), ye = k.errors, Ce = se(p, {
          path: [],
          baseSid: e
        }), {
          $api: Re,
          addBatchTask: _e
        } = je(Ce), De = Re.getState();
        return Ve(ye, De, _e, "outer"), Ce;
      });
    },
    write(u) {
      return u.map((p) => $e(p) ? p : je(p)).map((p) => $e(p) ? p : N(p) ? null : {
        values: p.$values.getState(),
        errors: p.$errors.getState()
      }).filter(Boolean);
    }
  }, b = d.sid ? w(l, {
    and: {
      name: "<array field values>",
      serialize: s,
      sid: `${d.sid}|values`
    },
    name: "$values",
    sid: "-2z089q"
  }) : w(l, {
    and: {
      name: "<array field values>",
      serialize: s
    },
    name: "$values",
    sid: "-2kpkuc"
  }), h = w(null, {
    and: {
      name: "<inner field error>"
    },
    name: "$innerError",
    sid: "9hcb4j"
  }), x = w((t == null ? void 0 : t.error) ?? null, {
    and: {
      name: "<outer field error>"
    },
    name: "$outerError",
    sid: "vqmtbz"
  }), F = ve({
    and: [{
      innerError: h,
      outerError: x
    }],
    or: {
      name: "$error",
      sid: "21ch36"
    }
  }).map((u) => {
    let {
      innerError: k,
      outerError: p
    } = u;
    return p || k;
  }), V = F.map((u) => u === null), I = w(d.meta, {
    name: "$meta",
    sid: "-24ucym"
  }), g = c({
    name: "changeMeta",
    sid: "wmbl7e"
  }), y = c({
    name: "metaChanged",
    sid: "ayikqm"
  });
  a({
    and: [{
      clock: g,
      target: I
    }],
    or: {
      sid: "6bq3zx"
    }
  }), a({
    and: [{
      clock: I,
      target: y
    }],
    or: {
      sid: "6q0rfb"
    }
  });
  const f = c({
    name: "batchedSetInnerError",
    sid: "hn98k3"
  }), m = c({
    name: "batchedSetOuterError",
    sid: "sjgtav"
  }), S = c({
    name: "batchedSetValue",
    sid: "-al8r6f"
  }), A = c({
    name: "batchedClear",
    sid: "tmlrvj"
  }), oe = c({
    name: "batchedReset",
    sid: "-mrwh1g"
  }), T = c("<field change>", {
    name: "change",
    sid: "-gerg05"
  }), W = c("<field changed>", {
    name: "changed",
    sid: "-us1caz"
  }), D = c("<field reset>", {
    name: "reset",
    sid: "-7cilfq"
  }), G = c("<field resetCompleted>", {
    name: "resetCompleted",
    sid: "a2i4dq"
  }), R = c("<field clear>", {
    name: "clear",
    sid: "awz4xj"
  }), z = c("<field cleared>", {
    name: "cleared",
    sid: "-31zqj"
  }), j = c("<field setInnerError>", {
    name: "setInnerError",
    sid: "-b9ve4w"
  }), M = c("<field changeError>", {
    name: "changeError",
    sid: "-3lo6s3"
  }), K = c("<field errorChanged>", {
    name: "errorChanged",
    sid: "-lhac15"
  }), J = c("<field push>", {
    name: "push",
    sid: "-wwx058"
  }), ue = c({
    name: "pushed",
    sid: "ouzxpp"
  }), L = c("<field swap>", {
    name: "swap",
    sid: "-gybwb4"
  }), H = c("<field swap>", {
    name: "swapped",
    sid: "-baopod"
  }), B = c("<field move>", {
    name: "move",
    sid: "-lq5vzc"
  }), Q = c("<field moved>", {
    name: "moved",
    sid: "iy9eus"
  }), de = c("<field insert>", {
    name: "insert",
    sid: "-88znw7"
  }), X = c("<field inserted>", {
    name: "inserted",
    sid: "-h9luhl"
  }), U = c("<field unshift>", {
    name: "unshift",
    sid: "gjdjrx"
  }), Y = c("<field unshifted>", {
    name: "unshifted",
    sid: "oiyhom"
  }), ie = c("<field remove>", {
    name: "remove",
    sid: "-wj2qjn"
  }), Z = c("<field removed>", {
    name: "removed",
    sid: "-3c1fup"
  }), ee = c("<field pop>", {
    name: "pop",
    sid: "-1wnbif"
  }), fe = c("<field popped>", {
    name: "popped",
    sid: "3vktmw"
  }), he = c("<field replace>", {
    name: "replace",
    sid: "-fnpaep"
  }), re = c("<field replaced>", {
    name: "replaced",
    sid: "-yavvan"
  }), C = O({
    and: {
      source: b,
      effect: async (u, k) => (await v(Ge(u, k)), [...k]),
      name: "syncFx"
    },
    or: {
      name: "syncFx",
      sid: "-nldzpg"
    }
  });
  a({
    and: [{
      clock: C.doneData,
      target: b
    }],
    or: {
      sid: "kf87o8"
    }
  }), a({
    and: [{
      clock: [R, A],
      fn: () => ({
        values: [],
        error: null
      }),
      target: q({
        sid: "-72ua2v",
        fn: () => P({
          values: C,
          error: x
        }),
        name: "target",
        method: "spread"
      })
    }],
    or: {
      sid: "kgbsuy"
    }
  }), a({
    and: [{
      clock: [D, oe],
      fn: () => {
        const u = o(), k = (t == null ? void 0 : t.error) ?? null;
        return {
          sync: u,
          completed: {
            values: u,
            error: k
          },
          outerError: k,
          innerError: null
        };
      },
      target: q({
        sid: "lswnz0",
        fn: () => P({
          sync: C,
          completed: G,
          error: x,
          innerError: h
        }),
        name: "target",
        method: "spread"
      })
    }],
    or: {
      sid: "kwtmns"
    }
  }), a({
    and: [{
      clock: [R, A],
      target: z
    }],
    or: {
      sid: "lvgo1j"
    }
  });
  const te = O({
    and: {
      source: b,
      effect: (u, k) => u.concat(n(k)),
      name: "pushFx"
    },
    or: {
      name: "pushFx",
      sid: "-v88ekm"
    }
  }), ae = O({
    and: {
      source: b,
      effect: (u, k) => {
        const p = [...u], ye = p[k.indexA];
        return p[k.indexA] = p[k.indexB], p[k.indexB] = ye, p;
      },
      name: "swapFx"
    },
    or: {
      name: "swapFx",
      sid: "4ue4gq"
    }
  }), me = O({
    and: {
      source: b,
      effect: (u, k) => {
        const p = [...u];
        return p.splice(k.to, 0, ...p.splice(k.from, 1)), p;
      },
      name: "moveFx"
    },
    or: {
      name: "moveFx",
      sid: "mrl3wj"
    }
  }), pe = O({
    and: {
      source: b,
      effect: (u, k) => {
        const p = [...u];
        return p.splice(k.index, 0, ...n(k.value)), p;
      },
      name: "insertFx"
    },
    or: {
      name: "insertFx",
      sid: "-bdcog7"
    }
  }), ge = O({
    and: {
      source: b,
      effect: (u, k) => {
        const p = [...u];
        return p.unshift(...n(k)), p;
      },
      name: "unshiftFx"
    },
    or: {
      name: "unshiftFx",
      sid: "wsfroz"
    }
  }), i = O({
    and: {
      source: b,
      effect: async (u, k) => {
        const p = [...u];
        return p.splice(k.index, 1)[0], p;
      },
      name: "removeFx"
    },
    or: {
      name: "removeFx",
      sid: "r4ehhq"
    }
  }), E = O({
    and: {
      source: b,
      effect: (u) => {
        const k = [...u];
        return k.pop(), k;
      },
      name: "popFx"
    },
    or: {
      name: "popFx",
      sid: "p3q50k"
    }
  }), ne = O({
    and: {
      source: b,
      effect: (u, k) => {
        const p = [...u];
        return p.splice(k.index, 1, ...n(k.value)), p;
      },
      name: "replaceFx"
    },
    or: {
      name: "replaceFx",
      sid: "lcpsug"
    }
  });
  return a({
    and: [{
      clock: b,
      target: W
    }],
    or: {
      sid: "-ywncbo"
    }
  }), a({
    and: [{
      clock: S,
      fn: (u) => n(u.value),
      target: C
    }],
    or: {
      sid: "-yicowa"
    }
  }), a({
    and: [{
      clock: T,
      fn: (u) => n(u),
      target: C
    }],
    or: {
      sid: "-yf1xc4"
    }
  }), a({
    and: [{
      clock: J,
      target: te
    }],
    or: {
      sid: "-o29f1a"
    }
  }), a({
    and: [{
      clock: te.done,
      fn: (u) => {
        let {
          params: k,
          result: p
        } = u;
        return {
          pushed: {
            params: k,
            result: p
          },
          values: p
        };
      },
      target: q({
        sid: "-p6sv1l",
        fn: () => P({
          pushed: ue,
          values: C
        }),
        name: "target",
        method: "spread"
      })
    }],
    or: {
      sid: "-o15tuk"
    }
  }), a({
    and: [{
      clock: L,
      target: ae
    }],
    or: {
      sid: "-nj0m9n"
    }
  }), a({
    and: [{
      clock: ae.done,
      fn: (u) => {
        let {
          params: k,
          result: p
        } = u;
        return {
          swapped: {
            params: k,
            result: p
          },
          values: p
        };
      },
      target: q({
        sid: "-8m838s",
        fn: () => P({
          swapped: H,
          values: C
        }),
        name: "target",
        method: "spread"
      })
    }],
    or: {
      sid: "-nhx12x"
    }
  }), a({
    and: [{
      clock: B,
      target: me
    }],
    or: {
      sid: "-mo851f"
    }
  }), a({
    and: [{
      clock: me.done,
      fn: (u) => {
        let {
          params: k,
          result: p
        } = u;
        return {
          moved: {
            params: k,
            result: p
          },
          values: p
        };
      },
      target: q({
        sid: "7ycok1",
        fn: () => P({
          moved: Q,
          values: C
        }),
        name: "target",
        method: "spread"
      })
    }],
    or: {
      sid: "-mn4jup"
    }
  }), a({
    and: [{
      clock: de,
      target: pe
    }],
    or: {
      sid: "-m4zc9s"
    }
  }), a({
    and: [{
      clock: pe.done,
      fn: (u) => {
        let {
          params: k,
          result: p
        } = u;
        return {
          inserted: {
            params: k,
            result: p
          },
          values: p
        };
      },
      target: q({
        sid: "ygvimx",
        fn: () => P({
          inserted: X,
          values: C
        }),
        name: "target",
        method: "spread"
      })
    }],
    or: {
      sid: "-m3vr32"
    }
  }), a({
    and: [{
      clock: U,
      target: ge
    }],
    or: {
      sid: "-llqji5"
    }
  }), a({
    and: [{
      clock: ge.done,
      fn: (u) => {
        let {
          params: k,
          result: p
        } = u;
        return {
          unshifted: {
            params: k,
            result: p
          },
          values: p
        };
      },
      target: q({
        sid: "-jznrje",
        fn: () => P({
          unshifted: Y,
          values: C
        }),
        name: "target",
        method: "spread"
      })
    }],
    or: {
      sid: "-l939uu"
    }
  }), a({
    and: [{
      clock: ie,
      target: i
    }],
    or: {
      sid: "-kqy29x"
    }
  }), a({
    and: [{
      clock: i.done,
      fn: (u) => {
        let {
          params: k,
          result: p
        } = u;
        return {
          removed: {
            params: k,
            result: p
          },
          values: p
        };
      },
      target: q({
        sid: "7xzxq3",
        fn: () => P({
          removed: Z,
          values: C
        }),
        name: "target",
        method: "spread"
      })
    }],
    or: {
      sid: "-ko73b4"
    }
  }), a({
    and: [{
      clock: ee,
      target: E
    }],
    or: {
      sid: "-jui79m"
    }
  }), a({
    and: [{
      clock: E.doneData,
      fn: (u) => u,
      target: [C, fe]
    }],
    or: {
      sid: "-jrr8at"
    }
  }), a({
    and: [{
      clock: he,
      target: ne
    }],
    or: {
      sid: "-9eypzz"
    }
  }), a({
    and: [{
      clock: ne.done,
      fn: (u) => {
        let {
          params: k,
          result: p
        } = u;
        return {
          replaced: {
            params: k,
            result: p
          },
          values: p
        };
      },
      target: q({
        sid: "43v8et",
        fn: () => P({
          replaced: re,
          values: C
        }),
        name: "target",
        method: "spread"
      })
    }],
    or: {
      sid: "-9c7r16"
    }
  }), a({
    and: [{
      clock: M,
      target: x
    }],
    or: {
      sid: "-8u2jg9"
    }
  }), a({
    and: [{
      clock: j,
      target: h
    }],
    or: {
      sid: "-8frw0v"
    }
  }), a({
    and: [{
      clock: M,
      target: x
    }],
    or: {
      sid: "-8d0x22"
    }
  }), a({
    and: [{
      clock: j,
      target: h
    }],
    or: {
      sid: "-7yq9mo"
    }
  }), a({
    and: [{
      clock: f,
      fn: (u) => u.value,
      target: h
    }],
    or: {
      sid: "-7vzanv"
    }
  }), a({
    and: [{
      clock: m,
      fn: (u) => u.value,
      target: x
    }],
    or: {
      sid: "-7h4un4"
    }
  }), a({
    and: [{
      clock: f,
      fn: (u) => u.value,
      target: h
    }],
    or: {
      sid: "-72aemd"
    }
  }), a({
    and: [{
      clock: m,
      fn: (u) => u.value,
      target: x
    }],
    or: {
      sid: "-6yzn27"
    }
  }), a({
    and: [{
      clock: F,
      target: K
    }],
    or: {
      sid: "-6k571g"
    }
  }), {
    "@@type": le,
    batchedSetInnerError: f,
    batchedSetOuterError: m,
    batchedSetValue: S,
    batchedClear: A,
    batchedReset: oe,
    $meta: I,
    $values: b,
    $error: F,
    $outerError: x,
    $innerError: h,
    $isValid: V,
    changeMeta: g,
    metaChanged: y,
    setInnerError: j,
    changeError: M,
    errorChanged: K,
    change: T,
    changed: W,
    push: J,
    pushed: ue,
    swap: L,
    swapped: H,
    move: B,
    moved: Q,
    clear: R,
    cleared: z,
    insert: de,
    inserted: X,
    unshift: U,
    unshifted: Y,
    remove: ie,
    removed: Z,
    pop: ee,
    popped: fe,
    replace: he,
    replaced: re,
    reset: D,
    resetCompleted: G,
    copyOnCreateForm: d.copyOnCreateForm,
    sid: d.sid,
    "@@unitShape": () => ({
      values: b,
      error: F,
      meta: I,
      isValid: V,
      changeMeta: g,
      change: T,
      changeError: M,
      clear: R,
      reset: D,
      push: J,
      move: B,
      swap: L,
      insert: de,
      unshift: U,
      remove: ie,
      pop: ee,
      replace: he
    })
  };
}
function qe(r) {
  switch (r["@@type"]) {
    case le:
      return Me(r.$values.getState(), {
        error: r.$error.getState(),
        meta: r.$meta.getState(),
        copyOnCreateForm: r.copyOnCreateForm,
        sid: r.sid ? `${r.sid}|copy` : null
      });
    case ce:
      return Pe(r.$value.getState(), {
        error: r.$error.getState(),
        meta: r.$meta.getState(),
        copyOnCreateForm: r.copyOnCreateForm,
        sid: r.sid ? `${r.sid}|copy` : null
      });
  }
}
function se(r) {
  let t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {
    path: []
  };
  const e = {};
  if (N(r))
    return r;
  for (const o in r) {
    const n = r[o], d = [...t.path, o];
    if (N(n)) {
      e[o] = Pe(n, t.baseSid ? {
        sid: `${t.baseSid}|${d.join(".")}`
      } : void 0);
      continue;
    }
    if (We(n) || Je(n)) {
      e[o] = n;
      continue;
    }
    if (Array.isArray(n)) {
      e[o] = Me(n, t.baseSid ? {
        sid: `${t.baseSid}|${d.join(".")}`
      } : void 0);
      continue;
    }
    typeof n == "object" && (e[o] = se(n, {
      path: d,
      baseSid: t.baseSid
    }));
  }
  return e;
}
function Te(r) {
  const t = {};
  for (const e in r) {
    const o = r[e];
    switch (o["@@type"]) {
      case le: {
        t[e] = o.copyOnCreateForm ? qe(o) : o;
        break;
      }
      case ce: {
        t[e] = o.copyOnCreateForm ? qe(o) : o;
        break;
      }
      case void 0: {
        t[e] = Te(o);
        break;
      }
    }
  }
  return t;
}
function sr(r, t) {
  const e = Object.keys(r).filter((n) => !/\.[0-9]\./.test(n)), o = ke(e, "reset");
  t(o);
  for (const n of e)
    r[n].batchedReset({
      "@@batchInfo": {
        fieldPath: n,
        id: o.id
      }
    });
}
function or(r) {
  return r && r.__esModule && Object.prototype.hasOwnProperty.call(r, "default") ? r.default : r;
}
var Se, Ae;
function dr() {
  return Ae || (Ae = 1, Se = function r(t, e) {
    if (t === e) return !0;
    if (t && e && typeof t == "object" && typeof e == "object") {
      if (t.constructor !== e.constructor) return !1;
      var o, n, d;
      if (Array.isArray(t)) {
        if (o = t.length, o != e.length) return !1;
        for (n = o; n-- !== 0; ) if (!r(t[n], e[n])) return !1;
        return !0;
      }
      if (t.constructor === RegExp) return t.source === e.source && t.flags === e.flags;
      if (t.valueOf !== Object.prototype.valueOf) return t.valueOf() === e.valueOf();
      if (t.toString !== Object.prototype.toString) return t.toString() === e.toString();
      if (d = Object.keys(t), o = d.length, o !== Object.keys(e).length) return !1;
      for (n = o; n-- !== 0; ) if (!Object.prototype.hasOwnProperty.call(e, d[n])) return !1;
      for (n = o; n-- !== 0; ) {
        var v = d[n];
        if (!r(t[v], e[v])) return !1;
      }
      return !0;
    }
    return t !== t && e !== e;
  }), Se;
}
var ir = dr();
const cr = /* @__PURE__ */ or(ir);
function lr(r) {
  return (Array.isArray(r) ? w(r, {
    name: "$strategies",
    sid: "-n78zsx"
  }) : r).map((e) => [...new Set(e)]);
}
function hr(r) {
  const {
    schema: t,
    validation: e = () => null,
    validationStrategies: o = ["submit", "change", "blur", "focus"],
    clearOuterErrorsOnSubmit: n
  } = r, {
    sid: d
  } = w(null, {
    sid: "rxexku"
  }), v = Te(se(t, {
    baseSid: d,
    path: []
  })), l = lr(o), s = l.map((i) => n ?? i.includes("submit")), {
    $errors: b,
    $values: h,
    $isValid: x,
    $api: F,
    focused: V,
    blurred: I,
    addBatchTask: g,
    metaChanged: y
  } = je(v, d), f = w(structuredClone(h.getState()), {
    name: "$snapshot",
    sid: "s8sgib"
  }), m = ve({
    and: [h, f, (i, E) => !cr(i, E)],
    or: {
      name: "$isChanged",
      sid: "4sp5e6"
    }
  }), S = w({
    needSav: !1,
    skipValidation: !1,
    ignoreChanges: !1
  }, {
    name: "$innerMeta",
    sid: "-t6udbb"
  }), A = ve({
    and: [h, F, (i, E) => {
      const ne = {};
      for (const u in E) {
        const k = E[u];
        ne[u] = k.error;
      }
      return {
        values: i,
        errors: ne
      };
    }],
    or: {
      name: "$persistInfo",
      sid: "-frri9p"
    }
  }), oe = O({
    and: {
      source: F,
      effect: (i) => Oe(i, g, "outer")
    },
    or: {
      name: "clearOuterErrorsFx",
      sid: "-5t2dw2"
    }
  }), T = O({
    and: {
      source: F,
      effect: (i) => Oe(i, g, "inner")
    },
    or: {
      name: "clearInnerErrorsFx",
      sid: "-v2o4t8"
    }
  }), W = O({
    and: {
      source: F,
      effect: (i) => sr(i, g)
    },
    or: {
      name: "resetFx",
      sid: "pjs5r9"
    }
  }), D = O({
    and: {
      source: F,