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

Effector composable forms core

import { createNode as me, withRegion as he, combine as Ee, createStore as I, createEvent as l, sample as e, withFactory as A, createEffect as D, clearNode as fe, attach as z } from "effector";
import { spread as B, combineEvents as De } from "patronum";
const ge = Symbol("primitive-field"), Ke = {
  error: null,
  meta: {},
  copyOnCreateForm: !0
};
function Se(r, t, n) {
  return n ? I(t, {
    and: {
      name: r,
      sid: n
    },
    sid: "4gtja8"
  }) : I(t, {
    and: {
      name: r
    },
    sid: "4hdbvl"
  });
}
function Be(r, t) {
  const n = {
    ...Ke,
    ...t
  }, d = me({
    regional: !0
  });
  return he(d, () => {
    const s = Se("<field value>", r, n.sid ? `${n.sid}|value` : void 0), o = Se("<inner field error>", null, n.sid ? `${n.sid}|innerError` : void 0), f = Se("<outer field error>", null, n.sid ? `${n.sid}|outerError` : void 0), v = Ee({
      and: [{
        innerError: o,
        outerError: f
      }],
      or: {
        name: "$error",
        sid: "x443mo"
      }
    }).map((O) => {
      let {
        innerError: T,
        outerError: L
      } = O;
      return L || T;
    }), i = v.map((O) => O === null), a = I(!1, {
      name: "$isFocused",
      sid: "br0swh"
    }), p = I(n.meta, {
      name: "$meta",
      sid: "-lr5ubb"
    }), E = l({
      name: "changeMeta",
      sid: "-4y05nr"
    }), F = l({
      name: "metaChanged",
      sid: "u4vik1"
    });
    e({
      and: [{
        clock: E,
        target: p
      }],
      or: {
        sid: "6gasdg"
      }
    }), e({
      and: [{
        clock: p,
        target: F
      }],
      or: {
        sid: "6ulfsu"
      }
    });
    const V = l("<field change>", {
      name: "change",
      sid: "bg0ikr"
    }), $ = l("<field changed>", {
      name: "changed",
      sid: "eo440o"
    }), S = l({
      name: "blur",
      sid: "g1ac6k"
    }), b = l({
      name: "blurred",
      sid: "-uym97u"
    }), k = l({
      name: "focus",
      sid: "-6rr7l3"
    }), h = l({
      name: "focused",
      sid: "t24mn4"
    }), g = l("<field setError>", {
      name: "changeError",
      sid: "1lkwgr"
    }), C = l("<field error changed>", {
      name: "errorChanged",
      sid: "c9ed7x"
    }), P = l({
      name: "setInnerError",
      sid: "bthbqe"
    }), Y = l({
      name: "setOuterError",
      sid: "3y6iga"
    }), R = l("<field reset>", {
      name: "reset",
      sid: "-7s3qsb"
    }), Z = l("<field reset completed>", {
      name: "resetCompleted",
      sid: "-boc9bb"
    }), K = l({
      name: "batchedSetInnerError",
      sid: "e5jvuj"
    }), N = l({
      name: "batchedSetOuterError",
      sid: "6a92kf"
    }), q = l({
      name: "batchedSetValue",
      sid: "-czmawf"
    }), _ = l({
      name: "batchedReset",
      sid: "-6yidbv"
    });
    return e({
      and: [{
        clock: S,
        fn: () => !1,
        target: a
      }],
      or: {
        sid: "-xaky7q"
      }
    }), e({
      and: [{
        clock: k,
        fn: () => !0,
        target: a
      }],
      or: {
        sid: "-xa15md"
      }
    }), e({
      and: [{
        clock: a,
        filter: (O) => O,
        target: h
      }],
      or: {
        sid: "-x8xkfn"
      }
    }), e({
      and: [{
        clock: a,
        filter: (O) => !O,
        target: b
      }],
      or: {
        sid: "-wumx09"
      }
    }), e({
      and: [{
        clock: P,
        target: o
      }],
      or: {
        sid: "-wrc5g3"
      }
    }), e({
      and: [{
        clock: g,
        target: f
      }],
      or: {
        sid: "-wd1i0p"
      }
    }), e({
      and: [{
        clock: V,
        target: s
      }],
      or: {
        sid: "-waaj1w"
      }
    }), e({
      and: [{
        clock: q,
        fn: (O) => O.value,
        target: s
      }],
      or: {
        sid: "-w96xv6"
      }
    }), e({
      and: [{
        clock: K,
        fn: (O) => O.value,
        target: o
      }],
      or: {
        sid: "-vuchuf"
      }
    }), e({
      and: [{
        clock: N,
        fn: (O) => O.value,
        target: f
      }],
      or: {
        sid: "-vfi1to"
      }
    }), e({
      and: [{
        clock: s,
        target: $
      }],
      or: {
        sid: "-vc7a9i"
      }
    }), e({
      and: [{
        clock: g,
        target: f
      }],
      or: {
        sid: "-vbnho5"
      }
    }), e({
      and: [{
        clock: v,
        target: C
      }],
      or: {
        sid: "-uz080u"
      }
    }), e({
      and: [{
        clock: P,
        target: o
      }],
      or: {
        sid: "-uygffh"
      }
    }), e({
      and: [{
        clock: [R, _],
        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: A({
          sid: "qok46o",
          fn: () => B({
            value: s,
            completed: Z,
            outerError: f,
            innerError: o
          }),
          name: "target",
          method: "spread"
        })
      }],
      or: {
        sid: "-uxcu8r"
      }
    }), {
      "@@type": ge,
      region: d,
      batchedSetInnerError: K,
      batchedSetOuterError: N,
      batchedSetValue: q,
      batchedReset: _,
      $meta: p,
      $value: s,
      $outerError: f,
      $innerError: o,
      $error: v,
      $isValid: i,
      $isFocused: a,
      changeMeta: E,
      metaChanged: F,
      blur: S,
      blurred: b,
      focus: k,
      focused: h,
      change: V,
      changed: $,
      changeError: g,
      errorChanged: C,
      reset: R,
      resetCompleted: Z,
      setInnerError: P,
      setOuterError: Y,
      copyOnCreateForm: n.copyOnCreateForm,
      sid: n.sid,
      "@@unitShape": () => ({
        value: s,
        error: v,
        meta: p,
        isValid: i,
        isFocused: a,
        changeMeta: E,
        blur: S,
        blurred: b,
        focus: k,
        focused: h,
        changeError: g,
        change: V,
        reset: R
      })
    };
  });
}
function Le(r) {
  return "@@type" in r && r["@@type"] === ge;
}
function Ve(r) {
  return typeof r == "boolean" || typeof r == "string" || typeof r == "number" || r === null;
}
function de(r) {
  const t = typeof File < "u" ? r instanceof File : !1, n = typeof Buffer < "u" ? r instanceof Buffer : !1, d = typeof FileList < "u" ? r instanceof FileList : !1;
  return Ve(r) || typeof r == "bigint" || n || t || d || r instanceof Date || r instanceof Blob || r instanceof ArrayBuffer || r instanceof Int8Array || r instanceof Int16Array || r instanceof Int32Array || r instanceof BigInt64Array;
}
const pe = Symbol("array-field");
function We(r, t) {
  return r.reduce((n, d, s) => (t.includes(d) || (n.nodes.push(d), n.indexes.push(s)), n), {
    nodes: [],
    indexes: []
  });
}
function Ge(r) {
  return "@@type" in r && r["@@type"] === pe;
}
function Je() {
  const r = l("<schema updated>", {
    name: "schemaUpdated",
    sid: "ogwkmf"
  }), t = l("<blurred>", {
    name: "blurred",
    sid: "-vtbsm2"
  }), n = l("<focused>", {
    name: "focused",
    sid: "r8rv7c"
  }), d = l({
    name: "metaChanged",
    sid: "p0ft9i"
  });
  return {
    blurred: t,
    focused: n,
    schemaUpdated: r,
    metaChanged: d
  };
}
function xe(r, t) {
  return {
    id: Math.random().toString(),
    type: t,
    fields: r
  };
}
function we(r) {
  return Object.values(r).reduce((t, n) => (n.fields.length > 0 || (t.tasks.push(n), n.type === "values" && t.updateType !== "all" ? t.updateType = t.updateType === "error" ? "all" : "value" : n.type === "errors" && t.updateType !== "all" ? t.updateType = t.updateType === "value" ? "all" : "error" : (n.type === "reset" || n.type === "all") && (t.updateType = "all")), t), {
    tasks: [],
    updateType: "none"
  });
}
function He(r) {
  const t = I({}, {
    and: {
      name: "<batch info>"
    },
    name: "$tasks",
    sid: "-c2xgvr"
  }), n = l({
    name: "batchedSchemaUpdated",
    sid: "-o4wxhp"
  }), d = l("<add batch task>", {
    name: "addBatchTask",
    sid: "bogptp"
  });
  return e({
    and: [{
      clock: d,
      source: t,
      fn: (s, o) => ({
        ...s,
        [o.id]: o
      }),
      target: t
    }],
    or: {
      sid: "-44ej8y"
    }
  }), e({
    and: [{
      clock: n,
      source: t,
      filter: (s, o) => {
        let {
          "@@batchInfo": f
        } = o;
        return !!s[f.id];
      },
      fn: (s, o) => {
        let {
          fieldPath: f,
          "@@batchInfo": v
        } = o;
        const i = s[v.id];
        return i.fields = i.fields.filter((a) => a !== f), {
          ...s
        };
      },
      target: t
    }],
    or: {
      sid: "-40jz3f"
    }
  }), e({
    and: [{
      clock: t,
      filter: (s) => we(s).tasks.length > 0,
      fn: (s) => {
        const {
          tasks: o,
          updateType: f
        } = we(s);
        return {
          fieldPath: o.map((v) => v.fields).join(" "),
          type: f
        };
      },
      target: r
    }],
    or: {
      sid: "-35rhv7"
    }
  }), e({
    and: [{
      clock: t,
      fn: (s) => {
        const {
          tasks: o
        } = we(s);
        if (o.length === 0)
          return s;
        const f = {
          ...s
        };
        for (const v of o)
          delete f[v.id];
        return f;
      },
      target: t
    }],
    or: {
      sid: "-2mip3k"
    }
  }), {
    addBatchTask: d,
    batchedSchemaUpdated: n
  };
}
function w(r) {
  const t = [], n = I(-1, {
    name: "$lastIndex",
    sid: "-8wc724"
  }), d = I([...t], {
    name: "$payloads",
    sid: "i6kdoz"
  }), s = l({
    name: "reset",
    sid: "1ok3o"
  }), o = l({
    name: "target",
    sid: "-ppag00"
  }), f = r;
  e({
    and: [{
      clock: o,
      target: s
    }],
    or: {
      sid: "2gntpx"
    }
  }), e({
    and: [{
      clock: s,
      fn: () => ({
        lastIndex: -1,
        payloads: [...t]
      }),
      target: A({
        sid: "-a2sx3w",
        fn: () => B({
          lastIndex: n,
          payloads: d
        }),
        name: "target",
        method: "spread"
      })
    }],
    or: {
      sid: "2uyh5b"
    }
  });
  for (let v = 0; v < f.length; v++) {
    const i = f[v];
    e({
      and: [{
        clock: i,
        source: n,
        filter: (a) => v - a !== 1,
        target: s
      }],
      or: {
        sid: "3d3ory"
      }
    }), v === f.length - 1 ? e({
      and: [{
        clock: i,
        source: [n, d],
        filter: (a) => {
          let [p] = a;
          return v - p === 1;
        },
        fn: (a, p) => {
          let [, E] = a;
          return [...E, p];
        },
        target: o
      }],
      or: {
        sid: "3t1q15"
      }
    }) : e({
      and: [{
        clock: i,
        source: [n, d],
        filter: (a) => {
          let [p] = a;
          return v - p === 1;
        },
        fn: (a, p) => {
          let [, E] = a;
          return {
            lastIndex: v,
            payloads: [...E, p]
          };
        },
        target: A({
          sid: "zdisu8",
          fn: () => B({
            lastIndex: n,
            payloads: d
          }),
          name: "target",
          method: "spread"
        })
      }],
      or: {
        sid: "48zr8m"
      }
    });
  }
  return o;
}
function $e(r, t) {
  const n = r[t];
  if (!n)
    throw new Error(`unknown field with path ${t}`);
  if (n.type !== "array-field")
    throw new Error(`expected field type "array-field", received "${n.type}"`);
  return n;
}
function Qe(r) {
  var t = this;
  let {
    field: n,
    path: d,
    key: s,
    resultErrorsNode: o,
    resultValuesNode: f,
    map: v
  } = r;
  const i = me({
    regional: !0
  }), a = n, p = a.$values.getState(), E = [...d, s].join(".");
  f[s] = [], o[s] = {
    error: a.$error.getState(),
    errors: []
  };
  const F = {
    value: [],
    error: a.$error.getState(),
    type: "array-field",
    isValid: !o[s].error,
    reset: a.reset,
    batchedSetValue: a.batchedSetValue,
    batchedSetOuterError: a.batchedSetOuterError,
    batchedSetInnerError: a.batchedSetInnerError,
    batchedReset: a.batchedReset,
    batchedClear: a.batchedClear,
    clearMemory: function() {
      (arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : !1) && fe(a.region), fe(i), delete t.api[E];
    },
    clearValuesMemory: () => {
      const $ = Object.keys(this.api).filter((S) => S.startsWith(E)).filter((S) => S !== E);
      for (const S of $)
        this.api[S].clearMemory(!0);
    },
    clearInnerError: a.setInnerError.prepend(() => null),
    clearOuterError: a.changeError.prepend(() => null),
    setInnerError: a.setInnerError,
    setOuterError: a.changeError,
    setValue: a.change
  };
  this.api[E] = F, o[s].error && (this.isValid = !1);
  const V = ($) => {
    $.map((S, b) => {
      de(S) ? f[s].push(S) : (f[s].push({}), o[s].errors.push({}), v.call(this, S, f[s][b], o[s].errors[b], [...d, s, b.toString()]));
    }), F.value = $;
  };
  V(p), he(i, () => {
    const $ = D((h) => {
      let {
        values: g
      } = h;
      $e(this.api, E).clearValuesMemory(), f[s] = [], o[s].errors = [], V(g);
    }, {
      name: "changeValuesFx",
      sid: "-l1elns"
    }), S = D((h) => {
      let {
        error: g
      } = h;
      o[s].error = g, F.error = g, F.isValid = !o[s].error, o[s].error && (this.isValid = !1);
    }, {
      name: "changeErrorFx",
      sid: "cgsc7z"
    }), b = D(() => {
      $e(this.api, E).clearValuesMemory(), f[s] = [], o[s] = {
        error: null,
        errors: []
      }, F.value = [], F.error = null, F.isValid = !o[s].error;
    }, {
      name: "clearFx",
      sid: "fd3omb"
    }), k = D((h) => {
      let {
        error: g,
        values: C
      } = h;
      $e(this.api, E).clearValuesMemory(), f[s] = [], o[s] = {
        error: g,
        errors: []
      }, F.isValid = !o[s].error, F.value = [], F.error = g, V(C);
    }, {
      name: "resetFx",
      sid: "-s6wf27"
    });
    e({
      and: [{
        clock: [w([a.setInnerError, a.errorChanged]), w([a.changeError, a.errorChanged])],
        source: a.$error,
        fn: (h) => ({
          error: h
        }),
        target: S
      }],
      or: {
        sid: "-jkoegu"
      }
    }), e({
      and: [{
        clock: [w([a.change, a.changed]), w([a.pushed, a.changed]), w([a.swapped, a.changed]), w([a.moved, a.changed]), w([a.inserted, a.changed]), w([a.unshifted, a.changed]), w([a.removed, a.changed]), w([a.popped, a.changed]), w([a.replaced, a.changed])],
        fn: (h) => {
          let [, g] = h;
          return {
            values: g
          };
        },
        target: $
      }],
      or: {
        sid: "-95opsk"
      }
    }), e({
      and: [{
        clock: w([a.reset, a.resetCompleted]),
        fn: (h) => {
          let [, {
            values: g,
            error: C
          }] = h;
          return {
            values: g,
            error: C
          };
        },
        target: k
      }],
      or: {
        sid: "-8lcbu7"
      }
    }), e({
      and: [{
        clock: w([a.clear, a.cleared]),
        fn: () => ({}),
        target: b
      }],
      or: {
        sid: "-84ui1d"
      }
    }), e({
      and: [{
        clock: a.batchedSetValue,
        filter: (h) => {
          let {
            value: g
          } = h;
          return f[s] === g;
        },
        fn: (h) => {
          let {
            "@@batchInfo": g
          } = h;
          return {
            fieldPath: E,
            "@@batchInfo": g
          };
        },
        target: this.batchedSchemaUpdated
      }],
      or: {
        sid: "-7pg9f9"
      }
    }), e({
      and: [{
        clock: w([a.batchedClear, a.cleared]),
        fn: (h) => {
          let [{
            "@@batchInfo": g
          }] = h;
          return {
            batchInfo: g
          };
        },
        target: b
      }],
      or: {
        sid: "-77uufp"
      }
    }), e({
      and: [{
        clock: w([a.batchedReset, a.resetCompleted]),
        fn: (h) => {
          let [{
            "@@batchInfo": g
          }, {
            values: C,
            error: P
          }] = h;
          return {
            values: C,
            error: P,
            batchInfo: g
          };
        },
        target: k
      }],
      or: {
        sid: "-6t0eey"
      }
    }), e({
      and: [{
        clock: w([a.batchedSetValue, a.changed]),
        source: a.$values,
        fn: (h, g) => {
          let [{
            "@@batchInfo": C
          }] = g;
          return {
            values: h,
            batchInfo: C
          };
        },
        target: $
      }],
      or: {
        sid: "-6bys0r"
      }
    }), e({
      and: [{
        clock: a.batchedSetInnerError,
        source: a.$outerError,
        fn: (h, g) => {
          let {
            value: C,
            "@@batchInfo": P
          } = g;
          return {
            error: h ?? C,
            batchInfo: P
          };
        },
        target: S
      }],
      or: {
        sid: "-6847v8"
      }
    }), e({
      and: [{
        clock: a.batchedSetOuterError,
        fn: (h) => {
          let {
            value: g,
            "@@batchInfo": C
          } = h;
          return {
            error: g,
            batchInfo: C
          };
        },
        target: S
      }],
      or: {
        sid: "-5r2lh1"
      }
    }), e({
      and: [{
        clock: S.done,
        filter: (h) => {
          let {
            params: g
          } = h;
          return !g.batchInfo;
        },
        fn: () => ({
          fieldPath: E,
          type: "error"
        }),
        target: this.schemaUpdated
      }],
      or: {
        sid: "-5akro7"
      }
    }), e({
      and: [{
        clock: [$.done, S.done, k.done, b.done],
        filter: (h) => {
          let {
            params: g
          } = h;
          return !!g.batchInfo;
        },
        fn: (h) => {
          let {
            params: g
          } = h;
          return {
            fieldPath: E,
            "@@batchInfo": g.batchInfo
          };
        },
        target: this.batchedSchemaUpdated
      }],
      or: {
        sid: "-4tj5a0"
      }
    }), e({
      and: [{
        clock: $.done,
        filter: (h) => {
          let {
            params: g
          } = h;
          return !g.batchInfo;
        },
        fn: () => ({
          fieldPath: E,
          type: "value"
        }),
        target: this.schemaUpdated
      }],
      or: {
        sid: "5zr6to"
      }
    }), e({
      and: [{
        clock: a.metaChanged,
        fn: (h) => ({
          fieldPath: E,
          meta: h
        }),
        target: this.metaChanged
      }],
      or: {
        sid: "6gst7v"
      }
    });
  });
}
function Xe(r) {
  var t = this;
  let {
    resultValuesNode: n,
    resultErrorsNode: d,
    field: s,
    key: o,
    path: f
  } = r;
  const v = me({
    regional: !0
  }), i = s, a = i.$value.getState(), p = i.$error.getState();
  n[o] = a, d[o] = p;
  const E = [...f, o].join("."), F = {
    type: "primitive-field",
    isValid: !d[o],
    value: a,
    error: p,
    reset: i.reset,
    clearMemory: function() {
      (arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : !1) && fe(i.region), fe(v), delete t.api[E];
    },
    batchedSetValue: i.batchedSetValue,
    batchedSetOuterError: i.batchedSetOuterError,
    batchedSetInnerError: i.batchedSetInnerError,
    batchedReset: i.batchedReset,
    clearInnerError: i.setInnerError.prepend(() => null),
    clearOuterError: i.changeError.prepend(() => null),
    setInnerError: i.setInnerError,
    setOuterError: i.changeError,
    setValue: i.change
  };
  this.api[E] = F, d[o] && (this.isValid = !1), he(v, () => {
    const V = D((b) => {
      let {
        value: k
      } = b;
      n[o] = k, F.value = k;
    }, {
      name: "changeValueFx",
      sid: "nnt5oa"
    }), $ = D((b) => {
      let {
        error: k
      } = b;
      d[o] = k, F.value = k, F.isValid = !d[o], d[o] && (this.isValid = !1);
    }, {
      name: "changeErrorFx",
      sid: "-u9gntl"
    }), S = D((b) => {
      let {
        value: k,
        error: h
      } = b;
      n[o] = k, d[o] = h, F.value = k, F.value = h, F.isValid = !d[o], d[o] && (this.isValid = !1);
    }, {
      name: "resetFx",
      sid: "-gaw5gs"
    });
    e({
      and: [{
        clock: w([i.changeError, i.errorChanged]),
        fn: (b) => {
          let [k] = b;
          return {
            error: k
          };
        },
        target: $
      }],
      or: {
        sid: "-4mqc23"
      }
    }), e({
      and: [{
        clock: w([i.change, i.changed]),
        fn: (b) => {
          let [k] = b;
          return {
            value: k
          };
        },
        target: V
      }],
      or: {
        sid: "-4jfkhx"
      }
    }), e({
      and: [{
        clock: w([i.reset, i.resetCompleted]),
        fn: (b) => {
          let [, {
            value: k,
            error: h
          }] = b;
          return {
            value: k,
            error: h
          };
        },
        target: S
      }],
      or: {
        sid: "-44l4h6"
      }
    }), e({
      and: [{
        clock: V.done,
        filter: (b) => {
          let {
            params: k
          } = b;
          return !k.batchInfo;
        },
        fn: () => ({
          fieldPath: E,
          type: "value"
        }),
        target: this.schemaUpdated
      }],
      or: {
        sid: "-3o3aoc"
      }
    }), e({
      and: [{
        clock: $.done,
        filter: (b) => {
          let {
            params: k
          } = b;
          return !k.batchInfo;
        },
        fn: () => ({
          fieldPath: E,
          type: "error"
        }),
        target: this.schemaUpdated
      }],
      or: {
        sid: "-371oa5"
      }
    }), e({
      and: [{
        clock: S.done,
        filter: (b) => {
          let {
            params: k
          } = b;
          return !k.batchInfo;
        },
        fn: () => ({
          fieldPath: E,
          type: "all"
        }),
        target: this.schemaUpdated
      }],
      or: {
        sid: "-2q01vy"
      }
    }), e({
      and: [{
        clock: i.batchedSetValue,
        filter: (b) => {
          let {
            value: k
          } = b;
          return k === n[o];
        },
        fn: (b) => {
          let {
            "@@batchInfo": k
          } = b;
          return {
            fieldPath: E,
            "@@batchInfo": k
          };
        },
        target: this.batchedSchemaUpdated
      }],
      or: {
        sid: "-28emwe"
      }
    }), e({
      and: [{
        clock: i.batchedSetInnerError,
        source: i.$outerError,
        fn: (b, k) => {
          let {
            value: h,
            "@@batchInfo": g
          } = k;
          return {
            error: b ?? h,
            batchInfo: g
          };
        },
        target: $
      }],
      or: {
        sid: "-1qt7wu"
      }
    }), e({
      and: [{
        clock: i.batchedSetOuterError,
        source: i.$innerError,
        fn: (b, k) => {
          let {
            value: h,
            "@@batchInfo": g
          } = k;
          return {
            error: h ?? b,
            batchInfo: g
          };
        },
        target: $
      }],
      or: {
        sid: "-19rlin"
      }
    }), e({
      and: [{
        clock: w([i.batchedSetValue, i.changed]),
        source: i.$value,
        fn: (b, k) => {
          let [{
            "@@batchInfo": h
          }] = k;
          return {
            value: b,
            batchInfo: h
          };
        },
        target: V
      }],
      or: {
        sid: "95835n"
      }
    }), e({
      and: [{
        clock: w([i.batchedReset, i.resetCompleted]),
        fn: (b) => {
          let [{
            "@@batchInfo": k
          }, {
            value: h,
            error: g
          }] = b;
          return {
            value: h,
            error: g,
            batchInfo: k
          };
        },
        target: S
      }],
      or: {
        sid: "9m9pju"
      }
    }), e({
      and: [{
        clock: [V.done, $.done, S.done],
        filter: (b) => {
          let {
            params: k
          } = b;
          return !!k.batchInfo;
        },
        fn: (b) => {
          let {
            params: k
          } = b;
          return {
            fieldPath: E,
            "@@batchInfo": k.batchInfo
          };
        },
        target: this.batchedSchemaUpdated
      }],
      or: {
        sid: "a3bby1"
      }
    }), e({
      and: [{
        clock: i.focused,
        fn: () => ({
          fieldPath: E
        }),
        target: this.focused
      }],
      or: {
        sid: "akcyc8"
      }
    }), e({
      and: [{
        clock: i.blurred,
        fn: () => ({
          fieldPath: E
        }),
        target: this.blurred
      }],
      or: {
        sid: "az7ecz"
      }
    }), e({
      and: [{
        clock: i.metaChanged,
        fn: (b) => ({
          fieldPath: E,
          meta: b
        }),
        target: this.metaChanged
      }],
      or: {
        sid: "b2i5x5"
      }
    });
  });
}
function Oe(r, t, n) {
  let d = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : [];
  for (const s in r) {
    const o = r[s];
    switch (o["@@type"]) {
      case ge: {
        Xe.call(this, {
          field: o,
          resultValuesNode: t,
          resultErrorsNode: n,
          key: s,
          path: d
        });
        break;
      }
      case pe: {
        Qe.call(this, {
          field: o,
          resultValuesNode: t,
          resultErrorsNode: n,
          key: s,
          path: d,
          map: Oe
        });
        break;
      }
      default: {
        t[s] = {}, n[s] = {}, Oe.call(this, o, t[s], n[s], [...d, s]);
        break;
      }
    }
  }
}
function Ye(r, t, n, d, s, o) {
  const f = {}, v = {}, i = {}, a = {}, p = {
    api: a,
    plainErrors: i,
    isValid: !0,
    metaChanged: t,
    schemaUpdated: n,
    batchedSchemaUpdated: d,
    focused: s,
    blurred: o
  };
  return Oe.call(p, r, f, v), {
    api: a,
    values: f,
    errors: v,
    isValid: p.isValid
  };
}
function qe(r, t, n) {
  const d = Object.keys(r), s = xe(d, "errors");
  t(s);
  for (const o of d) {
    const f = r[o];
    n === "inner" ? f.batchedSetInnerError({
      value: null,
      "@@batchInfo": {
        fieldPath: o,
        id: s.id
      }
    }) : n === "outer" && f.batchedSetOuterError({
      value: null,
      "@@batchInfo": {
        fieldPath: o,
        id: s.id
      }
    });
  }
}
function Ce(r, t, n, d) {
  let s = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : !1;
  const o = Object.keys(t), f = s ? o : Object.keys(r);
  if (Object.keys(f).length === 0)
    return;
  const v = xe(f, "errors");
  n(v);
  for (const i of f) {
    const a = t[i];
    if (!a) {
      console.error(`Unknown field with path: ${i}`);
      continue;
    }
    switch (d) {
      case "inner": {
        a.batchedSetInnerError({
          value: r[i] ?? null,
          "@@batchInfo": {
            id: v.id,
            fieldPath: i
          }
        });
        break;
      }
      case "outer": {
        a.batchedSetOuterError({
          value: r[i] ?? null,
          "@@batchInfo": {
            id: v.id,
            fieldPath: i
          }
        });
        break;
      }
    }
  }
}
function Ze(r, t, n) {
  const d = {};
  function s(f) {
    let v = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
    for (const i in f) {
      const a = f[i], p = [...v, i].join(".");
      if (de(a) || Array.isArray(a)) {
        const E = t[p];
        if (!E) {
          console.error(`Unknown field with path: ${p}`);
          continue;
        }
        d[p] = {
          setValue: E.batchedSetValue,
          value: a
        };
        continue;
      }
      typeof a == "object" && s(a, [...v, i]);
    }
  }
  if (s(r), Object.keys(d).length === 0)
    return;
  const o = xe(Object.keys(d), "values");
  n(o);
  for (const f in d)
    d[f].setValue({
      value: d[f].value,
      "@@batchInfo": {
        id: o.id,
        fieldPath: f
      }
    });
}
function Ne(r) {
  const t = r.match(/[\w\s:]+expected/);
  if (!t)
    throw new Error();
  return t[0].replace(" expected", "").replace(/:/g, "").split(" ").join(".");
}
function er(r) {
  return r !== null && typeof r == "object" && "isData" in r && "getErrorMessages" in r;
}
function rr(r) {
  return (t) => r.isData(t) ? null : r.getErrorMessages(t).reduce((n, d) => (n[Ne(d)] = d, n), {});
}
function ze(r) {
  let t = !0;
  for (const n in r)
    if (!r[n].isValid) {
      t = !1;
      break;
    }
  return t;
}
function je(r, t) {
  const {
    schemaUpdated: n,
    focused: d,
    blurred: s,
    metaChanged: o
  } = Je(), {
    batchedSchemaUpdated: f,
    addBatchTask: v
  } = He(n), i = Ye(r, o, n, f, d, s), a = I(i.api, {
    and: {
      serialize: "ignore"
    },
    name: "$api",
    sid: "6pgzrr"
  }), p = t ? I(i.values, {
    and: {
      sid: `${t}|form|values`
    },
    name: "$values",
    sid: "-b8aqxw"
  }) : I(i.values, {
    name: "$values",
    sid: "-b7qycj"
  }), E = t ? I(i.errors, {
    and: {
      sid: `${t}|form|errors`
    },
    name: "$errors",
    sid: "a17hry"
  }) : I(i.errors, {
    name: "$errors",
    sid: "a1radb"
  }), F = t ? I(i.isValid, {
    and: {
      sid: `${t}|form|isValid`
    },
    name: "$isValid",
    sid: "-n061j3"
  }) : I(i.isValid, {
    name: "$isValid",
    sid: "-mzm8xq"
  });
  return e({
    and: [{
      clock: n,
      fn: (V) => {
        switch (V.type) {
          case "value":
            return {
              values: {
                ...i.values
              },
              api: {
                ...i.api
              }
            };
          case "error":
            return {
              errors: {
                ...i.errors
              },
              isValid: ze(i.api)
            };
          case "all":
            return {
              values: {
                ...i.values
              },
              api: {
                ...i.api
              },
              errors: {
                ...i.errors
              },
              isValid: ze(i.api)
            };
          case "none":
            return {};
        }
      },
      target: A({
        sid: "-x3vhi8",
        fn: () => B({
          api: a,
          values: p,
          errors: E,
          isValid: F
        }),
        name: "target",
        method: "spread"
      })
    }],
    or: {
      sid: "p9z1mi"
    }
  }), {
    $api: a,
    $values: p,
    $errors: E,
    $isValid: F,
    addBatchTask: v,
    focused: d,
    blurred: s,
    metaChanged: o
  };
}
const tr = {
  error: null,
  meta: {},
  copyOnCreateForm: !0
};
function Ue(r, t) {
  const n = me({
    regional: !0
  });
  return he(n, () => {
    const {
      sid: d
    } = I(null, {
      sid: "d32c18"
    });
    function s() {
      return r.map((u) => ue(u));
    }
    function o(u) {
      return Array.isArray(u) ? u.map((y) => ue(y, {
        path: [],
        baseSid: d
      })) : [ue(u, {
        path: [],
        baseSid: d
      })];
    }
    const f = {
      ...tr,
      ...t
    }, v = D((u) => {
      let {
        nodes: y
      } = u;
      for (const m of y) {
        if (de(m))
          break;
        if ("region" in m)
          fe(m.region);
        else
          throw new Error('no "region" in node');
      }
    }, {
      name: "clearNodesFx",
      sid: "-yc94je"
    }), i = s(), a = {
      read(u) {
        if (!u)
          throw new Error();
        if (!Array.isArray(u))
          throw new Error();
        return u.map((y) => {
          const m = ue(y.values, {
            path: [],
            baseSid: d
          }), Fe = y.errors, {
            $api: Te,
            addBatchTask: Re
          } = je(m), _e = Te.getState();
          return Ce(Fe, _e, Re, "outer"), m;
        });
      },
      write(u) {
        return u.map((m) => Ve(m) ? m : je(m)).map((m) => Ve(m) ? m : de(m) ? null : {
          values: m.$values.getState(),
          errors: m.$errors.getState()
        }).filter(Boolean);
      }
    }, p = f.sid ? I(i, {
      and: {
        name: "<array field values>",
        serialize: a,
        sid: `${f.sid}|values`
      },
      name: "$values",
      sid: "-2z0880"
    }) : I(i, {
      and: {
        name: "<array field values>",
        serialize: a
      },
      name: "$values",
      sid: "-2kpksm"
    }), E = I(null, {
      and: {
        name: "<inner field error>"
      },
      name: "$innerError",
      sid: "9hcb69"
    }), F = I((t == null ? void 0 : t.error) ?? null, {
      and: {
        name: "<outer field error>"
      },
      name: "$outerError",
      sid: "vqmtdp"
    }), V = Ee({
      and: [{
        innerError: E,
        outerError: F
      }],
      or: {
        name: "$error",
        sid: "21ch4w"
      }
    }).map((u) => {
      let {
        innerError: y,
        outerError: m
      } = u;
      return m || y;
    }), $ = V.map((u) => u === null), S = I(f.meta, {
      name: "$meta",
      sid: "-24ucww"
    }), b = l({
      name: "changeMeta",
      sid: "wmbl94"
    }), k = l({
      name: "metaChanged",
      sid: "ayiksc"
    });
    e({
      and: [{
        clock: b,
        target: S
      }],
      or: {
        sid: "6bq41n"
      }
    }), e({
      and: [{
        clock: S,
        target: k
      }],
      or: {
        sid: "6q0rh1"
      }
    });
    const h = l({
      name: "batchedSetInnerError",
      sid: "hn98lt"
    }), g = l({
      name: "batchedSetOuterError",
      sid: "sjgtcl"
    }), C = l({
      name: "batchedSetValue",
      sid: "-al8r4p"
    }), P = l({
      name: "batchedClear",
      sid: "tmlrx9"
    }), Y = l({
      name: "batchedReset",
      sid: "-mrwgzq"
    }), R = l("<field change>", {
      name: "change",
      sid: "-gerfyf"
    }), Z = l("<field changed>", {
      name: "changed",
      sid: "-us1br6"
    }), K = l("<field reset>", {
      name: "reset",
      sid: "-7cile0"
    }), N = l("<field resetCompleted>", {
      name: "resetCompleted",
      sid: "a2i4fg"
    }), q = l("<field clear>", {
      name: "clear",
      sid: "awz4z9"
    }), _ = l("<field cleared>", {
      name: "cleared",
      sid: "-31z6q"
    }), O = l("<field setInnerError>", {
      name: "setInnerError",
      sid: "-b9ve36"
    }), T = l("<field changeError>", {
      name: "changeError",
      sid: "-3lo6qd"
    }), L = l("<field errorChanged>", {
      name: "errorChanged",
      sid: "-lhabzf"
    }), ne = l("<field push>", {
      name: "push",
      sid: "-wwx03i"
    }), ee = l({
      name: "pushed",
      sid: "ouzxrf"
    }), W = l("<field swap>", {
      name: "swap",
      sid: "-gybw9e"
    }), U = l("<field swap>", {
      name: "swapped",
      sid: "-baop4k"
    }), G = l("<field move>", {
      name: "move",
      sid: "-lq5vxm"
    }), ce = l("<field moved>", {
      name: "moved",
      sid: "iy9ewi"
    }), J = l("<field insert>", {
      name: "insert",
      sid: "-88znuh"
    }), M = l("<field inserted>", {
      name: "inserted",
      sid: "-h9ltxs"
    }), H = l("<field unshift>", {
      name: "unshift",
      sid: "gjdkbq"
    }), le = l("<field unshifted>", {
      name: "unshifted",
      sid: "oiyhqc"
    }), Q = l("<field remove>", {
      name: "remove",
      sid: "-wj2qhx"
    }), se = l("<field removed>", {
      name: "removed",
      sid: "-3c1faw"
    }), oe = l("<field pop>", {
      name: "pop",
      sid: "-1wnbgp"
    }), ve = l("<field popped>", {
      name: "popped",
      sid: "3vktom"
    }), X = l("<field replace>", {
      name: "replace",
      sid: "-fnp9uw"
    }), ie = l("<field replaced>", {
      name: "replaced",
      sid: "-yavuqu"
    }), j = z({
      and: {
        source: p,
        effect: async (u, y) => (await v(We(u, y)), [...y]),
        name: "syncFx"
      },
      or: {
        name: "syncFx",
        sid: "-nldznq"
      }
    });
    e({
      and: [{
        clock: j.doneData,
        target: p
      }],
      or: {
        sid: "kf87py"
      }
    }), e({
      and: [{
        clock: [q, P],
        fn: () => ({
          values: [],
          error: null
        }),
        target: A({
          sid: "-72ua15",
          fn: () => B({
            values: j,
            error: F
          }),
          name: "target",
          method: "spread"
        })
      }],
      or: {
        sid: "kgbswo"
      }
    }), e({
      and: [{
        clock: [K, Y],
        fn: () => {
          const u = s(), y = (t == null ? void 0 : t.error) ?? null;
          return {
            sync: u,
            completed: {
              values: u,
              error: y
            },
            outerError: y,
            innerError: null
          };
        },
        target: A({
          sid: "lswo0q",
          fn: () => B({
            sync: j,
            completed: N,
            error: F,
            innerError: E
          }),
          name: "target",
          method: "spread"
        })
      }],
      or: {
        sid: "kwtmpi"
      }
    }), e({
      and: [{
        clock: [q, P],
        target: _
      }],
      or: {
        sid: "lvgo39"
      }
    });
    const re = z({
      and: {
        source: p,
        effect: (u, y) => u.concat(o(y)),
        name: "pushFx"
      },
      or: {
        name: "pushFx",
        sid: "-v88eiw"
      }
    }), be = z({
      and: {
        source: p,
        effect: (u, y) => {
          const m = [...u], Fe = m[y.indexA];
          return m[y.indexA] = m[y.indexB], m[y.indexB] = Fe, m;
        },
        name: "swapFx"
      },
      or: {
        name: "swapFx",
        sid: "4ue4ig"
      }
    }), ke = z({
      and: {
        source: p,
        effect: (u, y) => {
          const m = [...u];
          return m.splice(y.to, 0, ...m.splice(y.from, 1)), m;
        },
        name: "moveFx"
      },
      or: {
        name: "moveFx",
        sid: "mrl3y9"
      }
    }), ye = z({
      and: {
        source: p,
        effect: (u, y) => {
          const m = [...u];
          return m.splice(y.index, 0, ...o(y.value)), m;
        },
        name: "insertFx"
      },
      or: {
        name: "insertFx",
        sid: "-bdcnwe"
      }
    }), c = z({
      and: {
        source: p,
        effect: (u, y) => {
          const m = [...u];
          return m.unshift(...o(y)), m;
        },
        name: "unshiftFx"
      },
      or: {
        name: "unshiftFx",
        sid: "wsfrqp"
      }
    }), x = z({
      and: {
        source: p,
        effect: async (u, y) => {
          const m = [...u];
          return m.splice(y.index, 1)[0], m;
        },
        name: "removeFx"
      },
      or: {
        name: "removeFx",
        sid: "r4ei1j"
      }
    }), te = z({
      and: {
        source: p,
        effect: (u) => {
          const y = [...u];
          return y.pop(), y;
        },
        name: "popFx"
      },
      or: {
        name: "popFx",
        sid: "p3q52a"
      }
    }), ae = z({
      and: {
        source: p,
        effect: (u, y) => {
          const m = [...u];
          return m.splice(y.index, 1, ...o(y.value)), m;
        },
        name: "replaceFx"
      },
      or: {
        name: "replaceFx",
        sid: "lcpsw6"
      }
    });
    return e({
      and: [{
        clock: p,
        target: Z
      }],
      or: {
        sid: "-ywnc9y"
      }
    }), e({
      and: [{
        clock: C,
        fn: (u) => o(u.value),
        target: j
      }],
      or: {
        sid: "-yicouk"
      }
    }), e({
      and: [{
        clock: R,
        fn: (u) => o(u),
        target: j
      }],
      or: {
        sid: "-yf1xae"
      }
    }), e({
      and: [{
        clock: ne,
        target: re
      }],
      or: {
        sid: "-o29ezk"
      }
    }), e({
      and: [{
        clock: re.done,
        fn: (u) => {
          let {
            params: y,
            result: m
          } = u;
          return {
            pushed: {
              params: y,
              result: m
            },
            values: m
          };
        },
        target: A({
          sid: "-p6suzv",
          fn: () => B({
            pushed: ee,
            values: j
          }),
          name: "target",
          method: "spread"
        })
      }],
      or: {
        sid: "-o15tsu"
      }
    }), e({
      and: [{
        clock: W,
        target: be
      }],
      or: {
        sid: "-nj0m7x"
      }
    }), e({
      and: [{
        clock: be.done,
        fn: (u) => {
          let {
            params: y,
            result: m
          } = u;
          return {
            swapped: {
              params: y,
              result: m
            },
            values: m
          };
        },
        target: A({
          sid: "-8m8372",
          fn: () => B({
            swapped: U,
            values: j
          }),
          name: "target",
          method: "spread"
        })
      }],
      or: {
        sid: "-nhx117"
      }
    }), e({
      and: [{
        clock: G,
        target: ke
      }],
      or: {
        sid: "-mo84zp"
      }
    }), e({
      and: [{
        clock: ke.done,
        fn: (u) => {
          let {
            params: y,
            result: m
          } = u;
          return {
            moved: {
              params: y,
              result: m
            },
            values: m
          };
        },
        target: A({
          sid: "7ycolr",
          fn: () => B({
            moved: ce,
            values: j
          }),
          name: "target",
          method: "spread"
        })
      }],
      or: {
        sid: "-mn4jsz"
      }
    }), e({
      and: [{
        clock: J,
        target: ye
      }],
      or: {
        sid: "-m4zc82"
      }
    }), e({
      and: [{
        clock: ye.done,
        fn: (u) => {
          let {
            params: y,
            result: m
          } = u;
          return {
            inserted: {
              params: y,
              result: m
            },
            values: m
          };
        },
        target: A({
          sid: "ygvion",
          fn: () => B({
            inserted: M,
            values: j
          }),
          name: "target",
          method: "spread"
        })
      }],
      or: {
        sid: "-m3vr1c"
      }
    }), e({
      and: [{
        clock: H,
        target: c
      }],
      or: {
        sid: "-llqjgf"
      }
    }), e({
      and: [{
        clock: c.done,
        fn: (u) => {
          let {
            params: y,
            result: m
          } = u;
          return {
            unshifted: {
              params: y,
              result: m
            },
            values: m
          };
        },
        target: A({
          sid: "-jznrho",
          fn: () => B({
            unshifted: le,
            values: j
          }),
          name: "target",
          method: "spread"
        })
      }],
      or: {
        sid: "-l939t4"
      }
    }), e({
      and: [{
        clock: Q,
        target: x
      }],
      or: {
        sid: "-kqy287"
      }
    }), e({
      and: [{
        clock: x.done,
        fn: (u) => {
          let {
            params: y,
            result: m
          } = u;
          return {
            removed: {
              params: y,
              result: m
            },
            values: m
          };
        },
        target: A({
          sid: "7xzxrt",
          fn: () => B({
            removed: se,
            values: j
          }),
          name: "target",
          method: "spread"
        })
      }],
      or: {
        sid: "-ko739e"
      }
    }), e({
      and: [{
        clock: oe,
        target: te
      }],
      or: {
        sid: "-jui77w"
      }
    }), e({
      and: [{
        clock: te.doneData,
        fn: (u) => u,
        target: [j, ve]
      }],
      or: {
        sid: "-jrr893"
      }
    }), e({
      and: [{
        clock: X,
        target: ae
      }],
      or: {
        sid: "-9eypy9"
      }
    }), e({
      and: [{
        clock: ae.done,
        fn: (u) => {
          let {
            params: y,
            result: m
          } = u;
          return {
            replaced: {
              params: y,
              result: m
            },
            values: m
          };
        },
        target: A({
          sid: "43v8gj",
          fn: () => B({
            replaced: ie,
            values: j
          }),
          name: "target",
          method: "spread"
        })
      }],
      or: {
        sid: "-9c7qzg"
      }
    }), e({
      and: [{
        clock: T,
        target: F
      }],
      or: {
        sid: "-8u2jej"
      }
    }), e({
      and: [{
        clock: O,
        target: E
      }],
      or: {
        sid: "-8frvz5"
      }
    }), e({
      and: [{
        clock: T,
        target: F
      }],
      or: {
        sid: "-8d0x0c"
      }
    }), e({
      and: [{
        clock: O,
        target: E
      }],
      or: {
        sid: "-7yq9ky"
      }
    }), e({
      and: [{
        clock: h,
        fn: (u) => u.value,
        target: E
      }],
      or: {
        sid: "-7vzam5"
      }
    }), e({
      and: [{
        clock: g,
        fn: (u) => u.value,
        target: F
      }],
      or: {
        sid: "-7h4ule"
      }
    }), e({
      and: [{
        clock: h,
        fn: (u) => u.value,
        target: E
      }],
      or: {
        sid: "-72aekn"
      }
    }), e({
      and: [{
        clock: g,
        fn: (u) => u.value,
        target: F
      }],
      or: {
        sid: "-6yzn0h"
      }
    }), e({
      and: [{
        clock: V,
        target: L
      }],
      or: {
        sid: "-6k56zq"
      }
    }), {
      "@@type": pe,
      region: n,
      batchedSetInnerError: h,
      batchedSetOuterError: g,
      batchedSetValue: C,
      batchedClear: P,
      batchedReset: Y,
      $meta: S,
      $values: p,
      $error: V,
      $outerError: F,
      $innerError: E,
      $isValid: $,
      changeMeta: b,
      metaChanged: k,
      setInnerError: O,
      changeError: T,
      errorChanged: L,
      change: R,
      changed: Z,
      push: ne,
      pushed: ee,
      swap: W,
      swapped: U,
      move: G,
      moved: ce,
      clear: q,
      cleared: _,
      insert: J,
      inserted: M,
      unshift: H,
      unshifted: le,
      remove: Q,
      removed: se,
      pop: oe,
      popped: ve,
      replace: X,
      replaced: ie,
      reset: K,
      resetCompleted: N,
      copyOnCreateForm: f.copyOnCreateForm,
      sid: f.sid,
      "@@unitShape": () => ({
        values: p,
        error: V,
        meta: S,
        isValid: $,
        changeMeta: b,
        change: R,
        changeError: T,
        clear: q,
        reset: K,
        push: ne,
        move: G,
        swap: W,
        insert: J,
        unshift: H,
        remove: Q,
        pop: oe,
        replace: X
      })
    };
  });
}
function Ae(r) {
  switch (r["@@type"]) {
    case pe:
      return Ue(r.$values.getState(), {
        error: r.$error.getState(),
        meta: r.$meta.getState(),
        copyOnCreateForm: r.copyOnCreateForm,
        sid: r.sid ? `${r.sid}|copy` : null
      });
    case ge:
      return Be(r.$value.getState(), {
        error: r.$error.getState(),
        meta: r.$meta.getState(),
        copyOnCreateForm: r.copyOnCreateForm,
        sid: r.sid ? `${r.sid}|copy` : null
      });
  }
}
function ue(r) {
  let t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {
    path: []
  };
  const n = me({
    regional: !0
  }), d = {};
  Object.defineProperty(d, "region", {
    enumerable: !1,
    value: n
  });
  function s(o, f) {
    let v = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {
      path: []
    };
    if (de(o))
      return o;
    for (const i in o) {
      const a = o[i], p = [...v.path, i];
      if (de(a)) {
        f[i] = Be(a, v.baseSid ? {
          sid: `${v.baseSid}|${p.join(".")}`
        } : void 0);
        continue;
      }
      if (Le(a) || Ge(a)) {
        f[i] = a;
        continue;
      }
      if (Array.isArray(a)) {
        f[i] = Ue(a, v.baseSid ? {
          sid: `${v.baseSid}|${p.join(".")}`
        } : void 0);
        continue;
      }
      typeof a == "object" && (f[i] = s(a, {}, {
        path: p,
        baseSid: v.baseSid
      }));
    }
    return f;
  }
  return he(n, () => s(r, d, t));
}
function Me(r) {
  const t = {};
  for (const n in r) {
    const d = r[n];
    switch (d["@@type"]) {
      case pe: {
        t[n] = d.copyOnCreateForm ? Ae(d) : d;
        break;
      }
      case ge: {
        t[n] = d.copyOnCreateForm ? Ae(d) : d;
        break;
      }
      case void 0: {
        t[n] = Me(d);
        break;
      }
    }
  }
  return t;
}
function ar(r, t) {
  const n = Object.keys(r).filter((s) => !/\.[0-9]\./.test(s)), d = xe(n, "reset");
  t(d);
  for (const s of n)
    r[s].batchedReset({
      "@@batchInfo": {
        fieldPath: s,
        id: d.id
      }
    });
}
function nr(r) {
  return r && r.__esModule && Object.prototype.hasOwnProperty.call(r, "default") ? r.default : r;
}
var Ie, Pe;
function sr() {
  return Pe || (Pe = 1, Ie = function r(t, n) {
    if (t === n) return !0;
    if (t && n && typeof t == "object" && typeof n == "object") {
      if (t.constructor !== n.constructor) return !1;
      var d, s, o;
      if (Array.isArray(t)) {
        if (d = t.length, d != n.length) return !1;
        for