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

Effector composable forms core

import { combine as Fe, createStore as P, createEvent as l, sample as o, withFactory as V, clearNode as er, createEffect as M, attach as I } from "effector";
import { spread as q, combineEvents as rr } from "patronum";
const se = Symbol("primitive-field");
function qe(e, t) {
  var r = Object.keys(e);
  if (Object.getOwnPropertySymbols) {
    var n = Object.getOwnPropertySymbols(e);
    t && (n = n.filter(function(a) {
      return Object.getOwnPropertyDescriptor(e, a).enumerable;
    })), r.push.apply(r, n);
  }
  return r;
}
function Ae(e) {
  for (var t = 1; t < arguments.length; t++) {
    var r = arguments[t] != null ? arguments[t] : {};
    t % 2 ? qe(Object(r), !0).forEach(function(n) {
      tr(e, n, r[n]);
    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(r)) : qe(Object(r)).forEach(function(n) {
      Object.defineProperty(e, n, Object.getOwnPropertyDescriptor(r, n));
    });
  }
  return e;
}
function tr(e, t, r) {
  return (t = nr(t)) in e ? Object.defineProperty(e, t, { value: r, enumerable: !0, configurable: !0, writable: !0 }) : e[t] = r, e;
}
function nr(e) {
  var t = ar(e, "string");
  return typeof t == "symbol" ? t : t + "";
}
function ar(e, t) {
  if (typeof e != "object" || !e) return e;
  var r = e[Symbol.toPrimitive];
  if (r !== void 0) {
    var n = r.call(e, t || "default");
    if (typeof n != "object") return n;
    throw new TypeError("@@toPrimitive must return a primitive value.");
  }
  return (t === "string" ? String : Number)(e);
}
const or = {
  error: null,
  meta: {},
  copyOnCreateForm: !0
};
function ve(e, t, r) {
  return r ? P(t, {
    and: {
      name: e,
      sid: r
    },
    sid: "40vi2r"
  }) : P(t, {
    and: {
      name: e
    },
    sid: "41fao4"
  });
}
function We(e, t) {
  const r = Ae(Ae({}, or), t), n = ve("<field value>", e, r.sid ? "".concat(r.sid, "|value") : void 0), a = ve("<inner field error>", null, r.sid ? "".concat(r.sid, "|innerError") : void 0), i = ve("<outer field error>", null, r.sid ? "".concat(r.sid, "|outerError") : void 0), p = Fe({
    and: [{
      innerError: a,
      outerError: i
    }],
    or: {
      name: "$error",
      sid: "ifptcx"
    }
  }).map((x) => {
    let {
      innerError: z,
      outerError: B
    } = x;
    return B || z;
  }), d = p.map((x) => x === null), s = P(!1, {
    name: "$isFocused",
    sid: "-2xdhda"
  }), k = P(r.meta, {
    name: "$meta",
    sid: "yljxe2"
  }), u = l({
    name: "changeMeta",
    sid: "-jmefxi"
  }), O = l({
    name: "metaChanged",
    sid: "fgh8aa"
  });
  o({
    and: [{
      clock: u,
      target: k
    }],
    or: {
      sid: "5z95xj"
    }
  }), o({
    and: [{
      clock: k,
      target: O
    }],
    or: {
      sid: "6djtcx"
    }
  });
  const E = l("<field change>", {
    name: "change",
    sid: "-38drp0"
  }), h = l("<field changed>", {
    name: "changed",
    sid: "-a6r6"
  }), y = l({
    name: "blur",
    sid: "1cw1wt"
  }), w = l({
    name: "blurred",
    sid: "pe3hzg"
  }), $ = l({
    name: "focus",
    sid: "-lg5huu"
  }), g = l({
    name: "focused",
    sid: "edqbva"
  }), b = l("<field setError>", {
    name: "changeError",
    sid: "-d2tdt0"
  }), S = l("<field error changed>", {
    name: "errorChanged",
    sid: "-2ezx1u"
  }), A = l({
    name: "setInnerError",
    sid: "-hg9joi"
  }), T = l({
    name: "setOuterError",
    sid: "-xabkaw"
  }), K = l("<field reset>", {
    name: "reset",
    sid: "vep2yb"
  }), R = l("<field reset completed>", {
    name: "resetCompleted",
    sid: "-e32xgf"
  }), G = l({
    name: "batchedSetInnerError",
    sid: "tto6e9"
  }), N = l({
    name: "batchedSetOuterError",
    sid: "dzm5rv"
  }), C = l({
    name: "batchedSetValue",
    sid: "-ro0l66"
  }), _ = l({
    name: "batchedReset",
    sid: "-lmwnlm"
  });
  return o({
    and: [{
      clock: y,
      fn: () => !1,
      target: s
    }],
    or: {
      sid: "-xrmknn"
    }
  }), o({
    and: [{
      clock: $,
      fn: () => !0,
      target: s
    }],
    or: {
      sid: "-xr2s2a"
    }
  }), o({
    and: [{
      clock: s,
      filter: (x) => x,
      target: g
    }],
    or: {
      sid: "-xpz6vk"
    }
  }), o({
    and: [{
      clock: s,
      filter: (x) => !x,
      target: w
    }],
    or: {
      sid: "-xpfea7"
    }
  }), o({
    and: [{
      clock: A,
      target: a
    }],
    or: {
      sid: "-xobt3h"
    }
  }), o({
    and: [{
      clock: b,
      target: i
    }],
    or: {
      sid: "-xa15o3"
    }
  }), o({
    and: [{
      clock: E,
      target: n
    }],
    or: {
      sid: "-x7a6pa"
    }
  }), o({
    and: [{
      clock: C,
      fn: (x) => x.value,
      target: n
    }],
    or: {
      sid: "-wumx1z"
    }
  }), o({
    and: [{
      clock: G,
      fn: (x) => x.value,
      target: a
    }],
    or: {
      sid: "-wrc5ht"
    }
  }), o({
    and: [{
      clock: N,
      fn: (x) => x.value,
      target: i
    }],
    or: {
      sid: "-wchph2"
    }
  }), o({
    and: [{
      clock: n,
      target: h
    }],
    or: {
      sid: "-w96xww"
    }
  }), o({
    and: [{
      clock: b,
      target: i
    }],
    or: {
      sid: "-vx3guy"
    }
  }), o({
    and: [{
      clock: p,
      target: S
    }],
    or: {
      sid: "-vvzvo8"
    }
  }), o({
    and: [{
      clock: A,
      target: a
    }],
    or: {
      sid: "-vvg32v"
    }
  }), o({
    and: [{
      clock: [K, _],
      fn: () => {
        var x, z;
        return {
          value: e,
          outerError: (x = t == null ? void 0 : t.error) !== null && x !== void 0 ? x : null,
          completed: {
            value: e,
            error: (z = t == null ? void 0 : t.error) !== null && z !== void 0 ? z : null
          },
          innerError: null
        };
      },
      target: V({
        sid: "-1q57iq",
        fn: () => q({
          value: n,
          completed: R,
          outerError: i,
          innerError: a
        }),
        name: "target",
        method: "spread"
      })
    }],
    or: {
      sid: "-vuchw5"
    }
  }), {
    "@@type": se,
    batchedSetInnerError: G,
    batchedSetOuterError: N,
    batchedSetValue: C,
    batchedReset: _,
    $meta: k,
    $value: n,
    $outerError: i,
    $innerError: a,
    $error: p,
    $isValid: d,
    $isFocused: s,
    changeMeta: u,
    metaChanged: O,
    blur: y,
    blurred: w,
    focus: $,
    focused: g,
    change: E,
    changed: h,
    changeError: b,
    errorChanged: S,
    reset: K,
    resetCompleted: R,
    setInnerError: A,
    setOuterError: T,
    copyOnCreateForm: r.copyOnCreateForm,
    sid: r.sid,
    "@@unitShape": () => ({
      value: n,
      error: p,
      meta: k,
      isValid: d,
      isFocused: s,
      changeMeta: u,
      blur: y,
      blurred: w,
      focus: $,
      focused: g,
      changeError: b,
      change: E,
      reset: K
    })
  };
}
function he(e) {
  let t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1;
  for (const r of e)
    er(r, t ? {
      deep: t
    } : void 0);
}
function F(e) {
  const t = [], r = P(-1, {
    name: "$lastIndex",
    sid: "-8wc724"
  }), n = P([...t], {
    name: "$payloads",
    sid: "i6kdoz"
  }), a = l({
    name: "reset",
    sid: "1ok3o"
  }), i = l({
    name: "target",
    sid: "-ppag00"
  }), p = e;
  o({
    and: [{
      clock: i,
      target: a
    }],
    or: {
      sid: "2gntpx"
    }
  }), o({
    and: [{
      clock: a,
      fn: () => ({
        lastIndex: -1,
        payloads: [...t]
      }),
      target: V({
        sid: "-a2sx3w",
        fn: () => q({
          lastIndex: r,
          payloads: n
        }),
        name: "target",
        method: "spread"
      })
    }],
    or: {
      sid: "2uyh5b"
    }
  });
  for (let d = 0; d < p.length; d++) {
    const s = p[d];
    o({
      and: [{
        clock: s,
        source: r,
        filter: (k) => d - k !== 1,
        target: a
      }],
      or: {
        sid: "3d3ory"
      }
    }), d === p.length - 1 ? o({
      and: [{
        clock: s,
        source: [r, n],
        filter: (k) => {
          let [u] = k;
          return d - u === 1;
        },
        fn: (k, u) => {
          let [, O] = k;
          return [...O, u];
        },
        target: i
      }],
      or: {
        sid: "3t1q15"
      }
    }) : o({
      and: [{
        clock: s,
        source: [r, n],
        filter: (k) => {
          let [u] = k;
          return d - u === 1;
        },
        fn: (k, u) => {
          let [, O] = k;
          return {
            lastIndex: d,
            payloads: [...O, u]
          };
        },
        target: V({
          sid: "zdisu8",
          fn: () => q({
            lastIndex: r,
            payloads: n
          }),
          name: "target",
          method: "spread"
        })
      }],
      or: {
        sid: "48zr8m"
      }
    });
  }
  return i;
}
function sr(e) {
  return "@@type" in e && e["@@type"] === se;
}
function je(e) {
  return typeof e == "boolean" || typeof e == "string" || typeof e == "number" || e === null;
}
function W(e) {
  const t = typeof File < "u" ? e instanceof File : !1, r = typeof Buffer < "u" ? e instanceof Buffer : !1, n = typeof FileList < "u" ? e instanceof FileList : !1;
  return je(e) || typeof e == "bigint" || r || t || n || e instanceof Date || e instanceof Blob || e instanceof ArrayBuffer || e instanceof Int8Array || e instanceof Int16Array || e instanceof Int32Array || e instanceof BigInt64Array;
}
function Ge(e) {
  let t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1;
  const r = e;
  he([e.$value, e.$error, e.$meta, e.change, e.changeError, e.errorChanged, e.changed, e.reset, e.resetCompleted, e.metaChanged, r.$outerError, r.$innerError, r.setInnerError, r.batchedSetValue, r.batchedSetOuterError, r.batchedSetInnerError, r.batchedReset], t);
}
const ie = Symbol("array-field");
function ir(e, t) {
  return e.reduce((r, n, a) => (t.includes(n) || (r.nodes.push(n), r.indexes.push(a)), r), {
    nodes: [],
    indexes: []
  });
}
function Je(e) {
  let t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !1;
  const r = e;
  he([r.$values, r.$error, r.$meta, r.change, r.changed, r.changeError, r.errorChanged, r.insert, r.inserted, r.move, r.moved, r.pop, r.popped, r.push, r.pushed, r.remove, r.removed, r.replace, r.replaced, r.swap, r.swapped, r.unshift, r.unshifted, r.clear, r.cleared, r.reset, r.resetCompleted, r.setInnerError, r.batchedSetValue, r.batchedSetOuterError, r.batchedSetInnerError, r.batchedClear, r.batchedReset, r.metaChanged], t);
}
function we(e) {
  if (!W(e))
    for (const t in e) {
      const r = e[t];
      switch (r["@@type"]) {
        case ie: {
          const n = r.$values.getState();
          for (const a of n) {
            if (W(a))
              break;
            we(a);
          }
          Je(r);
          break;
        }
        case se: {
          Ge(r);
          break;
        }
        default: {
          we(r);
          break;
        }
      }
    }
}
function cr(e) {
  return "@@type" in e && e["@@type"] === ie;
}
function dr() {
  const e = l("<schema updated>", {
    name: "schemaUpdated",
    sid: "ogwkmf"
  }), t = l("<blurred>", {
    name: "blurred",
    sid: "-vtbsm2"
  }), r = l("<focused>", {
    name: "focused",
    sid: "r8rv7c"
  }), n = l({
    name: "metaChanged",
    sid: "p0ft9i"
  });
  return {
    blurred: t,
    focused: r,
    schemaUpdated: e,
    metaChanged: n
  };
}
function ge(e, t) {
  return {
    id: Math.random().toString(),
    type: t,
    fields: e
  };
}
function ye(e) {
  return Object.values(e).reduce((t, r) => (r.fields.length > 0 || (t.tasks.push(r), r.type === "values" && t.updateType !== "all" ? t.updateType = t.updateType === "error" ? "all" : "value" : r.type === "errors" && t.updateType !== "all" ? t.updateType = t.updateType === "value" ? "all" : "error" : (r.type === "reset" || r.type === "all") && (t.updateType = "all")), t), {
    tasks: [],
    updateType: "none"
  });
}
function Be(e, t) {
  var r = Object.keys(e);
  if (Object.getOwnPropertySymbols) {
    var n = Object.getOwnPropertySymbols(e);
    t && (n = n.filter(function(a) {
      return Object.getOwnPropertyDescriptor(e, a).enumerable;
    })), r.push.apply(r, n);
  }
  return r;
}
function pe(e) {
  for (var t = 1; t < arguments.length; t++) {
    var r = arguments[t] != null ? arguments[t] : {};
    t % 2 ? Be(Object(r), !0).forEach(function(n) {
      lr(e, n, r[n]);
    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(r)) : Be(Object(r)).forEach(function(n) {
      Object.defineProperty(e, n, Object.getOwnPropertyDescriptor(r, n));
    });
  }
  return e;
}
function lr(e, t, r) {
  return (t = ur(t)) in e ? Object.defineProperty(e, t, { value: r, enumerable: !0, configurable: !0, writable: !0 }) : e[t] = r, e;
}
function ur(e) {
  var t = fr(e, "string");
  return typeof t == "symbol" ? t : t + "";
}
function fr(e, t) {
  if (typeof e != "object" || !e) return e;
  var r = e[Symbol.toPrimitive];
  if (r !== void 0) {
    var n = r.call(e, t || "default");
    if (typeof n != "object") return n;
    throw new TypeError("@@toPrimitive must return a primitive value.");
  }
  return (t === "string" ? String : Number)(e);
}
function mr(e) {
  const t = P({}, {
    and: {
      name: "<batch info>"
    },
    name: "$tasks",
    sid: "-c2xgvr"
  }), r = l({
    name: "batchedSchemaUpdated",
    sid: "-o4wxhp"
  }), n = l("<add batch task>", {
    name: "addBatchTask",
    sid: "bogptp"
  });
  return o({
    and: [{
      clock: n,
      source: t,
      fn: (a, i) => pe(pe({}, a), {}, {
        [i.id]: i
      }),
      target: t
    }],
    or: {
      sid: "-44ej8y"
    }
  }), o({
    and: [{
      clock: r,
      source: t,
      filter: (a, i) => {
        let {
          "@@batchInfo": p
        } = i;
        return !!a[p.id];
      },
      fn: (a, i) => {
        let {
          fieldPath: p,
          "@@batchInfo": d
        } = i;
        const s = a[d.id];
        return s.fields = s.fields.filter((k) => k !== p), pe({}, a);
      },
      target: t
    }],
    or: {
      sid: "-40jz3f"
    }
  }), o({
    and: [{
      clock: t,
      filter: (a) => ye(a).tasks.length > 0,
      fn: (a) => {
        const {
          tasks: i,
          updateType: p
        } = ye(a);
        return {
          fieldPath: i.map((d) => d.fields).join(" "),
          type: p
        };
      },
      target: e
    }],
    or: {
      sid: "-35rhv7"
    }
  }), o({
    and: [{
      clock: t,
      fn: (a) => {
        const {
          tasks: i
        } = ye(a);
        if (i.length === 0)
          return a;
        const p = pe({}, a);
        for (const d of i)
          delete p[d.id];
        return p;
      },
      target: t
    }],
    or: {
      sid: "-2mip3k"
    }
  }), {
    addBatchTask: n,
    batchedSchemaUpdated: r
  };
}
function ke(e, t) {
  const r = e[t];
  if (!r)
    throw new Error("unknown field with path ".concat(t));
  if (r.type !== "array-field")
    throw new Error('expected field type "array-field", received "'.concat(r.type, '"'));
  return r;
}
function pr(e) {
  var t = this;
  let {
    field: r,
    path: n,
    key: a,
    resultErrorsNode: i,
    resultValuesNode: p,
    map: d
  } = e;
  const s = r, k = s.$values.getState(), u = [...n, a].join(".");
  p[a] = [], i[a] = {
    error: s.$error.getState(),
    errors: []
  };
  const O = {
    type: "array-field",
    isValid: !i[a].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) && Je(s), he([y, h, w, $]), delete t.api[u];
    },
    clearValuesMemory: () => {
      const g = Object.keys(this.api).filter((b) => b.startsWith(u)).filter((b) => b !== u);
      for (const b of g)
        this.api[b].clearMemory();
    },
    clearInnerError: s.setInnerError.prepend(() => null),
    clearOuterError: s.changeError.prepend(() => null),
    setInnerError: s.setInnerError,
    setOuterError: s.changeError,
    setValue: s.change
  };
  this.api[u] = O, i[a].error && (this.isValid = !1);
  const E = (g) => {
    g.map((b, S) => {
      W(b) ? p[a].push(b) : (p[a].push({}), i[a].errors.push({}), d.call(this, b, p[a][S], i[a].errors[S], [...n, a, S.toString()]));
    });
  };
  E(k);
  const h = M((g) => {
    let {
      values: b
    } = g;
    ke(this.api, u).clearValuesMemory(), p[a] = [], i[a].errors = [], E(b);
  }, {
    name: "changeValuesFx",
    sid: "yd7x97"
  }), y = M((g) => {
    let {
      error: b
    } = g;
    i[a].error = b, O.isValid = !i[a].error, i[a].error && (this.isValid = !1);
  }, {
    name: "changeErrorFx",
    sid: "-35p6u6"
  }), w = M(() => {
    ke(this.api, u).clearValuesMemory(), p[a] = [], i[a] = {
      error: null,
      errors: []
    }, O.isValid = !i[a].error;
  }, {
    name: "clearFx",
    sid: "-aodjm7"
  }), $ = M((g) => {
    let {
      error: b,
      values: S
    } = g;
    ke(this.api, u).clearValuesMemory(), p[a] = [], i[a] = {
      error: b,
      errors: []
    }, O.isValid = !i[a].error, E(S);
  }, {
    name: "resetFx",
    sid: "pbjlrx"
  });
  o({
    and: [{
      clock: [F([s.setInnerError, s.errorChanged]), F([s.changeError, s.errorChanged])],
      source: s.$error,
      fn: (g) => ({
        error: g
      }),
      target: y
    }],
    or: {
      sid: "-ki7upl"
    }
  }), o({
    and: [{
      clock: [F([s.change, s.changed]), F([s.pushed, s.changed]), F([s.swapped, s.changed]), F([s.moved, s.changed]), F([s.inserted, s.changed]), F([s.unshifted, s.changed]), F([s.removed, s.changed]), F([s.popped, s.changed]), F([s.replaced, s.changed])],
      fn: (g) => {
        let [, b] = g;
        return {
          values: b
        };
      },
      target: h
    }],
    or: {
      sid: "-k168be"
    }
  }), o({
    and: [{
      clock: F([s.reset, s.resetCompleted]),
      fn: (g) => {
        let [, {
          values: b,
          error: S
        }] = g;
        return {
          values: b,
          error: S
        };
      },
      target: $
    }],
    or: {
      sid: "-97c3md"
    }
  }), o({
    and: [{
      clock: F([s.clear, s.cleared]),
      fn: () => ({}),
      target: w
    }],
    or: {
      sid: "-92dya4"
    }
  }), o({
    and: [{
      clock: s.batchedSetValue,
      filter: (g) => {
        let {
          value: b
        } = g;
        return p[a] === b;
      },
      fn: (g) => {
        let {
          "@@batchInfo": b
        } = g;
        return {
          fieldPath: u,
          "@@batchInfo": b
        };
      },
      target: this.batchedSchemaUpdated
    }],
    or: {
      sid: "-8mzpo0"
    }
  }), o({
    and: [{
      clock: F([s.batchedClear, s.cleared]),
      fn: (g) => {
        let [{
          "@@batchInfo": b
        }] = g;
        return {
          batchInfo: b
        };
      },
      target: w
    }],
    or: {
      sid: "-85eaog"
    }
  }), o({
    and: [{
      clock: F([s.batchedReset, s.resetCompleted]),
      fn: (g) => {
        let [{
          "@@batchInfo": b
        }, {
          values: S,
          error: A
        }] = g;
        return {
          values: S,
          error: A,
          batchInfo: b
        };
      },
      target: $
    }],
    or: {
      sid: "-7qjunp"
    }
  }), o({
    and: [{
      clock: F([s.batchedSetValue, s.changed]),
      source: s.$values,
      fn: (g, b) => {
        let [{
          "@@batchInfo": S
        }] = b;
        return {
          values: g,
          batchInfo: S
        };
      },
      target: h
    }],
    or: {
      sid: "-79i89i"
    }
  }), o({
    and: [{
      clock: s.batchedSetInnerError,
      source: s.$outerError,
      fn: (g, b) => {
        let {
          value: S,
          "@@batchInfo": A
        } = b;
        return {
          error: g ?? S,
          batchInfo: A
        };
      },
      target: y
    }],
    or: {
      sid: "-6u3zne"
    }
  }), o({
    and: [{
      clock: s.batchedSetOuterError,
      fn: (g) => {
        let {
          value: b,
          "@@batchInfo": S
        } = g;
        return {
          error: b,
          batchInfo: S
        };
      },
      target: y
    }],
    or: {
      sid: "-6d2d97"
    }
  }), o({
    and: [{
      clock: y.done,
      filter: (g) => {
        let {
          params: b
        } = g;
        return !b.batchInfo;
      },
      fn: () => ({
        fieldPath: u,
        type: "error"
      }),
      target: this.schemaUpdated
    }],
    or: {
      sid: "-69rlp1"
    }
  }), o({
    and: [{
      clock: [h.done, y.done, $.done, w.done],
      filter: (g) => {
        let {
          params: b
        } = g;
        return !!b.batchInfo;
      },
      fn: (g) => {
        let {
          params: b
        } = g;
        return {
          fieldPath: u,
          "@@batchInfo": b.batchInfo
        };
      },
      target: this.batchedSchemaUpdated
    }],
    or: {
      sid: "-5spzau"
    }
  }), o({
    and: [{
      clock: h.done,
      filter: (g) => {
        let {
          params: b
        } = g;
        return !b.batchInfo;
      },
      fn: () => ({
        fieldPath: u,
        type: "value"
      }),
      target: this.schemaUpdated
    }],
    or: {
      sid: "-4xdph9"
    }
  }), o({
    and: [{
      clock: s.metaChanged,
      fn: (g) => ({
        fieldPath: u,
        meta: g
      }),
      target: this.metaChanged
    }],
    or: {
      sid: "5hlz71"
    }
  });
}
function hr(e) {
  var t = this;
  let {
    resultValuesNode: r,
    resultErrorsNode: n,
    field: a,
    key: i,
    path: p
  } = e;
  const d = a;
  r[i] = d.$value.getState(), n[i] = d.$error.getState();
  const s = [...p, i].join("."), k = {
    type: "primitive-field",
    isValid: !n[i],
    reset: d.reset,
    clearMemory: function() {
      (arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : !1) && Ge(d), he([u, O, E]), delete t.api[s];
    },
    batchedSetValue: d.batchedSetValue,
    batchedSetOuterError: d.batchedSetOuterError,
    batchedSetInnerError: d.batchedSetInnerError,
    batchedReset: d.batchedReset,
    clearInnerError: d.setInnerError.prepend(() => null),
    clearOuterError: d.changeError.prepend(() => null),
    setInnerError: d.setInnerError,
    setOuterError: d.changeError,
    setValue: d.change
  };
  this.api[s] = k, n[i] && (this.isValid = !1);
  const u = M((h) => {
    let {
      value: y
    } = h;
    r[i] = y;
  }, {
    name: "changeValueFx",
    sid: "7ka07y"
  }), O = M((h) => {
    let {
      error: y
    } = h;
    n[i] = y, k.isValid = !n[i], n[i] && (this.isValid = !1);
  }, {
    name: "changeErrorFx",
    sid: "o72mb0"
  }), E = M((h) => {
    let {
      value: y,
      error: w
    } = h;
    r[i] = y, n[i] = w, k.isValid = !n[i], n[i] && (this.isValid = !1);
  }, {
    name: "resetFx",
    sid: "-xcik7l"
  });
  o({
    and: [{
      clock: F([d.changeError, d.errorChanged]),
      fn: (h) => {
        let [y] = h;
        return {
          error: y
        };
      },
      target: O
    }],
    or: {
      sid: "-5jpzph"
    }
  }), o({
    and: [{
      clock: F([d.change, d.changed]),
      fn: (h) => {
        let [y] = h;
        return {
          value: y
        };
      },
      target: u
    }],
    or: {
      sid: "-5gf85b"
    }
  }), o({
    and: [{
      clock: F([d.reset, d.resetCompleted]),
      fn: (h) => {
        let [, {
          value: y,
          error: w
        }] = h;
        return {
          value: y,
          error: w
        };
      },
      target: E
    }],
    or: {
      sid: "-51ks4k"
    }
  }), o({
    and: [{
      clock: u.done,
      filter: (h) => {
        let {
          params: y
        } = h;
        return !y.batchInfo;
      },
      fn: () => ({
        fieldPath: s,
        type: "value"
      }),
      target: this.schemaUpdated
    }],
    or: {
      sid: "-4l2ybq"
    }
  }), o({
    and: [{
      clock: O.done,
      filter: (h) => {
        let {
          params: y
        } = h;
        return !y.batchInfo;
      },
      fn: () => ({
        fieldPath: s,
        type: "error"
      }),
      target: this.schemaUpdated
    }],
    or: {
      sid: "-441bxj"
    }
  }), o({
    and: [{
      clock: E.done,
      filter: (h) => {
        let {
          params: y
        } = h;
        return !y.batchInfo;
      },
      fn: () => ({
        fieldPath: s,
        type: "all"
      }),
      target: this.schemaUpdated
    }],
    or: {
      sid: "-3mzpjc"
    }
  }), o({
    and: [{
      clock: d.batchedSetValue,
      filter: (h) => {
        let {
          value: y
        } = h;
        return y === r[i];
      },
      fn: (h) => {
        let {
          "@@batchInfo": y
        } = h;
        return {
          fieldPath: s,
          "@@batchInfo": y
        };
      },
      target: this.batchedSchemaUpdated
    }],
    or: {
      sid: "-35eajs"
    }
  }), o({
    and: [{
      clock: d.batchedSetInnerError,
      source: d.$outerError,
      fn: (h, y) => {
        let {
          value: w,
          "@@batchInfo": $
        } = y;
        return {
          error: h ?? w,
          batchInfo: $
        };
      },
      target: O
    }],
    or: {
      sid: "-2nsvk8"
    }
  }), o({
    and: [{
      clock: d.batchedSetOuterError,
      source: d.$innerError,
      fn: (h, y) => {
        let {
          value: w,
          "@@batchInfo": $
        } = y;
        return {
          error: w ?? h,
          batchInfo: $
        };
      },
      target: O
    }],
    or: {
      sid: "-26r961"
    }
  }), o({
    and: [{
      clock: F([d.batchedSetValue, d.changed]),
      source: d.$value,
      fn: (h, y) => {
        let [{
          "@@batchInfo": w
        }] = y;
        return {
          value: h,
          batchInfo: w
        };
      },
      target: u
    }],
    or: {
      sid: "-1ppmru"
    }
  }), o({
    and: [{
      clock: F([d.batchedReset, d.resetCompleted]),
      fn: (h) => {
        let [{
          "@@batchInfo": y
        }, {
          value: w,
          error: $
        }] = h;
        return {
          value: w,
          error: $,
          batchInfo: y
        };
      },
      target: E
    }],
    or: {
      sid: "-18o0dn"
    }
  }), o({
    and: [{
      clock: [u.done, O.done, E.done],
      filter: (h) => {
        let {
          params: y
        } = h;
        return !!y.batchInfo;
      },
      fn: (h) => {
        let {
          params: y
        } = h;
        return {
          fieldPath: s,
          "@@batchInfo": y.batchInfo
        };
      },
      target: this.batchedSchemaUpdated
    }],
    or: {
      sid: "96boan"
    }
  }), o({
    and: [{
      clock: d.focused,
      fn: () => ({
        fieldPath: s
      }),
      target: this.focused
    }],
    or: {
      sid: "9ndaou"
    }
  }), o({
    and: [{
      clock: d.blurred,
      fn: () => ({
        fieldPath: s
      }),
      target: this.blurred
    }],
    or: {
      sid: "a27qpl"
    }
  }), o({
    and: [{
      clock: d.metaChanged,
      fn: (h) => ({
        fieldPath: s,
        meta: h
      }),
      target: this.metaChanged
    }],
    or: {
      sid: "a5ii9r"
    }
  });
}
function Ee(e, t, r) {
  let n = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : [];
  for (const a in e) {
    const i = e[a];
    switch (i["@@type"]) {
      case se: {
        hr.call(this, {
          field: i,
          resultValuesNode: t,
          resultErrorsNode: r,
          key: a,
          path: n
        });
        break;
      }
      case ie: {
        pr.call(this, {
          field: i,
          resultValuesNode: t,
          resultErrorsNode: r,
          key: a,
          path: n,
          map: Ee
        });
        break;
      }
      default: {
        t[a] = {}, r[a] = {}, Ee.call(this, i, t[a], r[a], [...n, a]);
        break;
      }
    }
  }
}
function gr(e, t, r, n, a, i) {
  const p = {}, d = {}, s = {}, k = {
    api: s,
    isValid: !0,
    metaChanged: t,
    schemaUpdated: r,
    batchedSchemaUpdated: n,
    focused: a,
    blurred: i
  };
  return Ee.call(k, e, p, d), {
    api: s,
    values: p,
    errors: d,
    isValid: k.isValid
  };
}
function De(e, t, r) {
  const n = Object.keys(e), a = ge(n, "errors");
  t(a);
  for (const i of n) {
    const p = e[i];
    r === "inner" ? p.batchedSetInnerError({
      value: null,
      "@@batchInfo": {
        fieldPath: i,
        id: a.id
      }
    }) : r === "outer" && p.batchedSetOuterError({
      value: null,
      "@@batchInfo": {
        fieldPath: i,
        id: a.id
      }
    });
  }
}
function Se(e, t, r, n) {
  let a = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : !1;
  const i = Object.keys(t), p = a ? i : Object.keys(e);
  if (Object.keys(p).length === 0)
    return;
  const d = ge(p, "errors");
  r(d);
  for (const u of p) {
    const O = t[u];
    if (!O) {
      console.error("Unknown field with path: ".concat(u));
      continue;
    }
    switch (n) {
      case "inner": {
        var s;
        O.batchedSetInnerError({
          value: (s = e[u]) !== null && s !== void 0 ? s : null,
          "@@batchInfo": {
            id: d.id,
            fieldPath: u
          }
        });
        break;
      }
      case "outer": {
        var k;
        O.batchedSetOuterError({
          value: (k = e[u]) !== null && k !== void 0 ? k : null,
          "@@batchInfo": {
            id: d.id,
            fieldPath: u
          }
        });
        break;
      }
    }
  }
}
function br(e, t, r) {
  const n = {};
  function a(p) {
    let d = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
    for (const s in p) {
      const k = p[s], u = [...d, s].join(".");
      if (W(k) || Array.isArray(k)) {
        const O = t[u];
        if (!O) {
          console.error("Unknown field with path: ".concat(u));
          continue;
        }
        n[u] = {
          setValue: O.batchedSetValue,
          value: k
        };
        continue;
      }
      typeof k == "object" && a(k, [...d, s]);
    }
  }
  if (a(e), Object.keys(n).length === 0)
    return;
  const i = ge(Object.keys(n), "values");
  r(i);
  for (const p in n)
    n[p].setValue({
      value: n[p].value,
      "@@batchInfo": {
        id: i.id,
        fieldPath: p
      }
    });
}
function vr(e) {
  const t = e.match(/[\w\s:]+expected/);
  if (!t)
    throw new Error();
  return t[0].replace(" expected", "").replace(/:/g, "").split(" ").join(".");
}
function yr(e) {
  return e !== null && typeof e == "object" && "isData" in e && "getErrorMessages" in e;
}
function kr(e) {
  return (t) => e.isData(t) ? null : e.getErrorMessages(t).reduce((r, n) => (r[vr(n)] = n, r), {});
}
function _e(e) {
  let t = !0;
  for (const r in e)
    if (!e[r].isValid) {
      t = !1;
      break;
    }
  return t;
}
function Ue(e, t) {
  var r = Object.keys(e);
  if (Object.getOwnPropertySymbols) {
    var n = Object.getOwnPropertySymbols(e);
    t && (n = n.filter(function(a) {
      return Object.getOwnPropertyDescriptor(e, a).enumerable;
    })), r.push.apply(r, n);
  }
  return r;
}
function oe(e) {
  for (var t = 1; t < arguments.length; t++) {
    var r = arguments[t] != null ? arguments[t] : {};
    t % 2 ? Ue(Object(r), !0).forEach(function(n) {
      Or(e, n, r[n]);
    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(r)) : Ue(Object(r)).forEach(function(n) {
      Object.defineProperty(e, n, Object.getOwnPropertyDescriptor(r, n));
    });
  }
  return e;
}
function Or(e, t, r) {
  return (t = jr(t)) in e ? Object.defineProperty(e, t, { value: r, enumerable: !0, configurable: !0, writable: !0 }) : e[t] = r, e;
}
function jr(e) {
  var t = wr(e, "string");
  return typeof t == "symbol" ? t : t + "";
}
function wr(e, t) {
  if (typeof e != "object" || !e) return e;
  var r = e[Symbol.toPrimitive];
  if (r !== void 0) {
    var n = r.call(e, t || "default");
    if (typeof n != "object") return n;
    throw new TypeError("@@toPrimitive must return a primitive value.");
  }
  return (t === "string" ? String : Number)(e);
}
function xe(e, t) {
  const {
    schemaUpdated: r,
    focused: n,
    blurred: a,
    metaChanged: i
  } = dr(), {
    batchedSchemaUpdated: p,
    addBatchTask: d
  } = mr(r), s = gr(e, i, r, p, n, a), k = P(s.api, {
    and: {
      serialize: "ignore"
    },
    name: "$api",
    sid: "6pgzrr"
  }), u = t ? P(s.values, {
    and: {
      sid: "".concat(t, "|form|values")
    },
    name: "$values",
    sid: "-b8aqxw"
  }) : P(s.values, {
    name: "$values",
    sid: "-b7qycj"
  }), O = t ? P(s.errors, {
    and: {
      sid: "".concat(t, "|form|errors")
    },
    name: "$errors",
    sid: "a17hry"
  }) : P(s.errors, {
    name: "$errors",
    sid: "a1radb"
  }), E = t ? P(s.isValid, {
    and: {
      sid: "".concat(t, "|form|isValid")
    },
    name: "$isValid",
    sid: "-n061j3"
  }) : P(s.isValid, {
    name: "$isValid",
    sid: "-mzm8xq"
  });
  return o({
    and: [{
      clock: r,
      fn: (h) => {
        switch (h.type) {
          case "value":
            return {
              values: oe({}, s.values),
              api: oe({}, s.api)
            };
          case "error":
            return {
              errors: oe({}, s.errors),
              isValid: _e(s.api)
            };
          case "all":
            return {
              values: oe({}, s.values),
              api: oe({}, s.api),
              errors: oe({}, s.errors),
              isValid: _e(s.api)
            };
          case "none":
            return {};
        }
      },
      target: V({
        sid: "-x3vhi8",
        fn: () => q({
          api: k,
          values: u,
          errors: O,
          isValid: E
        }),
        name: "target",
        method: "spread"
      })
    }],
    or: {
      sid: "p9z1mi"
    }
  }), {
    $api: k,
    $values: u,
    $errors: O,
    $isValid: E,
    addBatchTask: d,
    focused: n,
    blurred: a,
    metaChanged: i
  };
}
function Me(e, t) {
  var r = Object.keys(e);
  if (Object.getOwnPropertySymbols) {
    var n = Object.getOwnPropertySymbols(e);
    t && (n = n.filter(function(a) {
      return Object.getOwnPropertyDescriptor(e, a).enumerable;
    })), r.push.apply(r, n);
  }
  return r;
}
function Te(e) {
  for (var t = 1; t < arguments.length; t++) {
    var r = arguments[t] != null ? arguments[t] : {};
    t % 2 ? Me(Object(r), !0).forEach(function(n) {
      Er(e, n, r[n]);
    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(r)) : Me(Object(r)).forEach(function(n) {
      Object.defineProperty(e, n, Object.getOwnPropertyDescriptor(r, n));
    });
  }
  return e;
}
function Er(e, t, r) {
  return (t = Sr(t)) in e ? Object.defineProperty(e, t, { value: r, enumerable: !0, configurable: !0, writable: !0 }) : e[t] = r, e;
}
function Sr(e) {
  var t = xr(e, "string");
  return typeof t == "symbol" ? t : t + "";
}
function xr(e, t) {
  if (typeof e != "object" || !e) return e;
  var r = e[Symbol.toPrimitive];
  if (r !== void 0) {
    var n = r.call(e, t || "default");
    if (typeof n != "object") return n;
    throw new TypeError("@@toPrimitive must return a primitive value.");
  }
  return (t === "string" ? String : Number)(e);
}
const Fr = {
  error: null,
  meta: {},
  copyOnCreateForm: !0
};
function He(e, t) {
  var r;
  const {
    sid: n
  } = P(null, {
    sid: "rw58d"
  });
  function a() {
    return e.map((f) => re(f));
  }
  function i(f) {
    return Array.isArray(f) ? f.map((v) => re(v, {
      path: [],
      baseSid: n
    })) : [re(f, {
      path: [],
      baseSid: n
    })];
  }
  const p = Te(Te({}, Fr), t), d = M((f) => {
    let {
      nodes: v
    } = f;
    for (const m of v) {
      if (W(m))
        break;
      we(m);
    }
  }, {
    name: "clearNodesFx",
    sid: "ybmtf1"
  }), s = a(), k = {
    read(f) {
      if (!f)
        throw new Error();
      if (!Array.isArray(f))
        throw new Error();
      return f.map((v) => {
        const m = re(v.values, {
          path: [],
          baseSid: n
        }), be = v.errors, ze = re(m, {
          path: [],
          baseSid: n
        }), {
          $api: Xe,
          addBatchTask: Ye
        } = xe(ze), Ze = Xe.getState();
        return Se(be, Ze, Ye, "outer"), ze;
      });
    },
    write(f) {
      return f.map((m) => je(m) ? m : xe(m)).map((m) => je(m) ? m : W(m) ? null : {
        values: m.$values.getState(),
        errors: m.$errors.getState()
      }).filter(Boolean);
    }
  }, u = p.sid ? P(s, {
    and: {
      name: "<array field values>",
      serialize: k,
      sid: "".concat(p.sid, "|values")
    },
    name: "$values",
    sid: "-2z089q"
  }) : P(s, {
    and: {
      name: "<array field values>",
      serialize: k
    },
    name: "$values",
    sid: "-2kpkuc"
  }), O = P(null, {
    and: {
      name: "<inner field error>"
    },
    name: "$innerError",
    sid: "9hcb4j"
  }), E = P((r = t == null ? void 0 : t.error) !== null && r !== void 0 ? r : null, {
    and: {
      name: "<outer field error>"
    },
    name: "$outerError",
    sid: "vqmtbz"
  }), h = Fe({
    and: [{
      innerError: O,
      outerError: E
    }],
    or: {
      name: "$error",
      sid: "21ch36"
    }
  }).map((f) => {
    let {
      innerError: v,
      outerError: m
    } = f;
    return m || v;
  }), y = h.map((f) => f === null), w = P(p.meta, {
    name: "$meta",
    sid: "-24ucym"
  }), $ = l({
    name: "changeMeta",
    sid: "wmbl7e"
  }), g = l({
    name: "metaChanged",
    sid: "ayikqm"
  });
  o({
    and: [{
      clock: $,
      target: w
    }],
    or: {
      sid: "6bq3zx"
    }
  }), o({
    and: [{
      clock: w,
      target: g
    }],
    or: {
      sid: "6q0rfb"
    }
  });
  const b = l({
    name: "batchedSetInnerError",
    sid: "hn98k3"
  }), S = l({
    name: "batchedSetOuterError",
    sid: "sjgtav"
  }), A = l({
    name: "batchedSetValue",
    sid: "-al8r6f"
  }), T = l({
    name: "batchedClear",
    sid: "tmlrvj"
  }), K = l({
    name: "batchedReset",
    sid: "-mrwh1g"
  }), R = l("<field change>", {
    name: "change",
    sid: "-gerg05"
  }), G = l("<field changed>", {
    name: "changed",
    sid: "-us1caz"
  }), N = l("<field reset>", {
    name: "reset",
    sid: "-7cilfq"
  }), C = l("<field resetCompleted>", {
    name: "resetCompleted",
    sid: "a2i4dq"
  }), _ = l("<field clear>", {
    name: "clear",
    sid: "awz4xj"
  }), x = l("<field cleared>", {
    name: "cleared",
    sid: "-31zqj"
  }), z = l("<field setInnerError>", {
    name: "setInnerError",
    sid: "-b9ve4w"
  }), B = l("<field changeError>", {
    name: "changeError",
    sid: "-3lo6s3"
  }), J = l("<field errorChanged>", {
    name: "errorChanged",
    sid: "-lhac15"
  }), L = l("<field push>", {
    name: "push",
    sid: "-wwx058"
  }), H = l({
    name: "pushed",
    sid: "ouzxpp"
  }), D = l("<field swap>", {
    name: "swap",
    sid: "-gybwb4"
  }), Q = l("<field swap>", {
    name: "swapped",
    sid: "-baopod"
  }), te = l("<field move>", {
    name: "move",
    sid: "-lq5vzc"
  }), X = l("<field moved>", {
    name: "moved",
    sid: "iy9eus"
  }), U = l("<field insert>", {
    name: "insert",
    sid: "-88znw7"
  }), ne = l("<field inserted>", {
    name: "inserted",
    sid: "-h9luhl"
  }), ae = l("<field unshift>", {
    name: "unshift",
    sid: "gjdjrx"
  }), Y = l("<field unshifted>", {
    name: "unshifted",
    sid: "oiyhom"
  }), ce = l("<field remove>", {
    name: "remove",
    sid: "-wj2qjn"
  }), Z = l("<field removed>", {
    name: "removed",
    sid: "-3c1fup"
  }), ee = l("<field pop>", {
    name: "pop",
    sid: "-1wnbif"
  }), le = l("<field popped>", {
    name: "popped",
    sid: "3vktmw"
  }), de = l("<field replace>", {
    name: "replace",
    sid: "-fnpaep"
  }), ue = l("<field replaced>", {
    name: "replaced",
    sid: "-yavvan"
  }), c = I({
    and: {
      source: u,
      effect: async (f, v) => (await d(ir(f, v)), [...v]),
      name: "syncFx"
    },
    or: {
      name: "syncFx",
      sid: "-nldzpg"
    }
  });
  o({
    and: [{
      clock: c.doneData,
      target: u
    }],
    or: {
      sid: "kf87o8"
    }
  }), o({
    and: [{
      clock: [_, T],
      fn: () => ({
        values: [],
        error: null
      }),
      target: V({
        sid: "-72ua2v",
        fn: () => q({
          values: c,
          error: E
        }),
        name: "target",
        method: "spread"
      })
    }],
    or: {
      sid: "kgbsuy"
    }
  }), o({
    and: [{
      clock: [N, K],
      fn: () => {
        var f;
        const v = a(), m = (f = t == null ? void 0 : t.error) !== null && f !== void 0 ? f : null;
        return {
          sync: v,
          completed: {
            values: v,
            error: m
          },
          outerError: m,
          innerError: null
        };
      },
      target: V({
        sid: "lswnz0",
        fn: () => q({
          sync: c,
          completed: C,
          error: E,
          innerError: O
        }),
        name: "target",
        method: "spread"
      })
    }],
    or: {
      sid: "kwtmns"
    }
  }), o({
    and: [{
      clock: [_, T],
      target: x
    }],
    or: {
      sid: "lvgo1j"
    }
  });
  const j = I({
    and: {
      source: u,
      effect: (f, v) => f.concat(i(v)),
      name: "pushFx"
    },
    or: {
      name: "pushFx",
      sid: "-v88ekm"
    }
  }), fe = I({
    and: {
      source: u,
      effect: (f, v) => {
        const m = [...f], be = m[v.indexA];
        return m[v.indexA] = m[v.indexB], m[v.indexB] = be, m;
      },
      name: "swapFx"
    },
    or: {
      name: "swapFx",
      sid: "4ue4gq"
    }
  }), me = I({
    and: {
      source: u,
      effect: (f, v) => {
        const m = [...f];
        return m.splice(v.to, 0, ...m.splice(v.from, 1)), m;
      },
      name: "moveFx"
    },
    or: {
      name: "moveFx",
      sid: "mrl3wj"
    }
  }), Pe = I({
    and: {
      source: u,
      effect: (f, v) => {
        const m = [...f];
        return m.splice(v.index, 0, ...i(v.value)), m;
      },
      name: "insertFx"
    },
    or: {
      name: "insertFx",
      sid: "-bdcog7"
    }
  }), $e = I({
    and: {
      source: u,
      effect: (f, v) => {
        const m = [...f];
        return m.unshift(...i(v)), m;
      },
      name: "unshiftFx"
    },
    or: {
      name: "unshiftFx",
      sid: "wsfroz"
    }
  }), Ie = I({
    and: {
      source: u,
      effect: async (f, v) => {
        const m = [...f];
        return m.splice(v.index, 1)[0], m;
      },
      name: "removeFx"
    },
    or: {
      name: "removeFx",
      sid: "r4ehhq"
    }
  }), Ve = I({
    and: {
      source: u,
      effect: (f) => {
        const v = [...f];
        return v.pop(), v;
      },
      name: "popFx"
    },
    or: {
      name: "popFx",
      sid: "p3q50k"
    }
  }), Ce = I({
    and: {
      source: u,
      effect: (f, v) => {
        const m = [...f];
        return m.splice(v.index, 1, ...i(v.value)), m;
      },
      name: "replaceFx"
    },
    or: {
      name: "replaceFx",
      sid: "lcpsug"
    }
  });
  return o({
    and: [{
      clock: u,
      target: G
    }],
    or: {
      sid: "-ywncbo"
    }
  }), o({
    and: [{
      clock: A,
      fn: (f) => i(f.value),
      target: c
    }],
    or: {
      sid: "-yicowa"
    }
  }), o({
    and: [{
      clock: R,
      fn: (f) => i(f),
      target: c
    }],
    or: {
      sid: "-yf1xc4"
    }
  }), o({
    and: [{
      clock: L,
      target: j
    }],
    or: {
      sid: "-o29f1a"
    }
  }), o({
    and: [{
      clock: j.done,
      fn: (f) => {
        let {
          params: v,
          result: m
        } = f;
        return {
          pushed: {
            params: v,
            result: m
          },
          values: m
        };
      },
      target: V({
        sid: "-p6sv1l",
        fn: () => q({
          pushed: H,
          values: c
        }),
        name: "target",
        method: "spread"
      })
    }],
    or: {
      sid: "-o15tuk"
    }
  }), o({
    and: [{
      clock: D,
      target: fe
    }],
    or: {
      sid: "-nj0m9n"
    }
  }), o({
    and: [{
      clock: fe.done,
      fn: (f) => {
        let {
          params: v,
          result: m
        } = f;
        return {
          swapped: {
            params: v,
            result: m
          },
          values: m
        };
      },
      target: V({
        sid: "-8m838s",
        fn: () => q({
          swapped: Q,
          values: c
        }),
        name: "target",
        method: "spread"
      })
    }],
    or: {
      sid: "-nhx12x"
    }
  }), o({
    and: [{
      clock: te,
      target: me
    }],
    or: {
      sid: "-mo851f"
    }
  }), o({
    and: [{
      clock: me.done,
      fn: (f) => {
        let {
          params: v,
          result: m
        } = f;
        return {
          moved: {
            params: v,
            result: m
          },
          values: m
        };
      },
      target: V({
        sid: "7ycok1",
        fn: () => q({
          moved: X,
          values: c
        }),
        name: "target",
        method: "spread"
      })
    }],
    or: {
      sid: "-mn4jup"
    }
  }), o({
    and: [{
      clock: U,
      target: Pe
    }],
    or: {
      sid: "-m4zc9s"
    }
  }), o({
    and: [{
      clock: Pe.done,
      fn: (f) => {
        let {
          params: v,
          result: m
        } = f;
        return {
          inserted: {
            params: v,
            result: m
          },
          values: m
        };
      },
      target: V({
        sid: "ygvimx",
        fn: () => q({
          inserted: ne,
          values: c
        }),
        name: "target",
        method: "spread"
      })
    }],
    or: {
      sid: "-m3vr32"
    }
  }), o({
    and: [{
      clock: ae,
      target: $e
    }],
    or: {
      sid: "-llqji5"
    }
  }), o({
    and: [{
      clock: $e.done,
      fn: (f) => {
        let {
          params: v,
          result: m
        } = f;
        return {
          unshifted: {
            params: v,
            result: m
          },
          values: m
        };
      },
      target: V({
        sid: "-jznrje",
        fn: () => q({
          unshifted: Y,
          values: c
        }),
        name: "target",
        method: "spread"
      })
    }],
    or: {
      sid: "-l939uu"
    }
  }), o({
    and: [{
      clock: ce,
      target: Ie
    }],
    or: {
      sid: "-kqy29x"
    }
  }), o({
    and: [{
      clock: Ie.done,
      fn: (f) => {
        let {
          params: v,
          result: m
        } = f;
        return {
          removed: {
            params: v,
            result: m
          },
          values: m
        };
      },
      target: V({
        sid: "7xzxq3",
        fn: () => q({
          removed: Z,
          values: c
        }),
        name: "target",
        method: "spread"
      })
    }],
    or: {
      sid: "-ko73b4"
    }
  }), o({
    and: [{
      clock: ee,
      target: Ve
    }],
    or: {
      sid: "-jui79m"
    }
  }), o({
    and: [{
      clock: Ve.doneData,
      fn: (f) => f,
      target: [c, le]
    }],
    or: {
      sid: "-jrr8at"
    }
  }), o({
    and: [{
      clock: de,
      target: Ce
    }],
    or: {
      sid: "-9eypzz"
    }
  }), o({
    and: [{
      clock: Ce.done,
      fn: (f) => {
        let {
          params: v,
          result: m
        } = f;
        return {
          replaced: {
            params: v,
            result: m
          },
          values: m
        };
      },
      target: V({
        sid: "43v8et",
        fn: () => q({
          replaced: ue,
          values: c
        }),
        name: "target",
        method: "spread"
      })
    }],
    or: {
      sid: "-9c7r16"
    }
  }), o({
    and: [{
      clock: B,
      target: E
    }],
    or: {
      sid: "-8u2jg9"
    }
  }), o({
    and: [{
      clock: z,
      target: O
    }],
    or: {
      sid: "-8frw0v"
    }
  }), o({
    and: [{
      clock: B,
      target: E
    }],
    or: {
      sid: "-8d0x22"
    }
  }), o({
    and: [{
      clock: z,
      target: O
    }],
    or: {
      sid: "-7yq9mo"
    }
  }), o({
    and: [{
      clock: b,
      fn: (f) => f.value,
      target: O
    }],
    or: {
      sid: "-7vzanv"
    }
  }), o({
    and: [{
      clock: S,
      fn: (f) => f.value,
      target: E
    }],
    or: {
      sid: "-7h4un4"
    }
  }), o({
    and: [{
      clock: b,
      fn: (f) => f.value,
      target: O
    }],
    or: {
      sid: "-72aemd"
    }
  }), o({
    and: [{
      clock: S,
      fn: (f) => f.value,
      target: E
    }],
    or: {
      sid: "-6yzn27"
    }
  }), o({
    and: [{
      clock: h,
      target: J
    }],
    or: {
      sid: "-6k571g"
    }
  }), {
    "@@type": ie,
    batchedSetInnerError: b,
    batchedSetOuterError: S,
    batchedSetValue: A,
    batchedClear: T,
    batchedReset: K,
    $meta: w,
    $values: u,
    $error: h,
    $outerError: E,
    $innerError: O,
    $isValid: y,
    changeMeta: $,
    metaChanged: g,
    setInnerError: z,
    changeError: B,
    errorChanged: J,
    change: R,
    changed: G,
    push: L,
    pushed: H,
    swap: D,
    swapped: Q,
    move: te,
    moved: X,
    clear: _,
    cleared: x,
    insert: U,
    inserted: ne,
    unshift: ae,
    unshifted: Y,
    remove: ce,
    removed: Z,
    pop: ee,
    popped: le,
    replace: de,
    replaced: ue,
    reset: N,
    resetCompleted: C,