@jfdevelops/react-multi-step-form 1.0.0-alpha.4 → 1.0.0-alpha.5

package/dist/index.mjs

@@ -1,28 +1,137 @@
-import { jsx as $e, jsxs as te } from "react/jsx-runtime";
-import W from "react";
-function _e(o, ...e) {
+import { jsx as Te, jsxs as ne } from "react/jsx-runtime";
+import G from "react";
+function U(o, e, t) {
+  const r = [], s = new Set(o), n = t ? t.format(o.map((u) => `${u}`)) : `[${o.join(", ")}]`;
+  for (let u = 0; u < e.length; u++) {
+    const b = e[u];
+    s.has(b) || r.push(
+      `Extra element at index ${u}: "${b}" is not in ${n}`
+    );
+  }
+  return e.some((u) => s.has(u)) || r.push(
+    `Array must contain at least one valid element from ${n}`
+  ), r.length > 0 ? { status: "error", errors: r } : { status: "success" };
+}
+function R(o, e) {
+  const t = (r, s) => `❌ ${s + 1}. ${r}`;
+  return o.map((r, s) => t(r, s)).join(`
+`);
+}
+function se(o) {
+  return Object.keys(o);
+}
+function je(o, ...e) {
   return () => String.raw({ raw: o }, ...e);
 }
-function j(o, e, t = Error) {
+function _(o, e, t = Error) {
   if (!o) {
-    const r = typeof e == "function" ? e() : _e`${e}`();
+    const r = typeof e == "function" ? e() : je`${e}`();
     throw new t(r);
   }
 }
-const G = "MultiStepFormSchema";
-class me {
+function M(o) {
+  _(o.includes("step"), "Can't extract a valid step number since");
+  const e = o.replace("step", "");
+  return _(/^\d+$/.test(e), `Invalid step format: "${o}"`), Number.parseInt(e, 10);
+}
+function K(o) {
+  return function(e) {
+    const { step: t } = e, r = `step${t}`, s = o[r];
+    return { step: t, data: s };
+  };
+}
+function oe(o, e) {
+  return e.reduce((t, r) => {
+    const s = M(r), { data: n } = K(o)({
+      step: s
+    });
+    for (const [a, u] of Object.entries(n))
+      typeof u == "function" && a !== "update" || (n[a] = u);
+    return t[r] = n, t;
+  }, {});
+}
+function N(o, e) {
+  const t = new Intl.ListFormat("en", {
+    style: "long",
+    type: "disjunction"
+  }), r = Object.keys(o), s = () => `"stepData" must be set to an array of available steps (${t.format(
+    r
+  )})`;
+  if (e === "all") {
+    let n = {};
+    for (const a of r)
+      n = {
+        ...n,
+        [a]: K(o)({
+          step: M(a)
+        })
+      };
+    return Object.fromEntries(
+      r.map((a) => [
+        a,
+        K(o)({
+          step: M(a)
+        })
+      ])
+    );
+  }
+  if (Array.isArray(e))
+    return _(
+      e.every((n) => r.includes(n)),
+      () => {
+        const n = U(
+          e,
+          r.map((a) => M(a)),
+          t
+        );
+        return n.status === "error" ? `${s()}. See errors:
+ ${R(
+          n.errors
+        )}` : s();
+      }
+    ), oe(
+      o,
+      e
+    );
+  if (typeof e == "object") {
+    const n = Object.keys(e);
+    return _(
+      n.every((a) => r.includes(a)),
+      () => {
+        const a = U(
+          n,
+          r,
+          t
+        );
+        return a.status === "error" ? `${s()}. See errors:
+ ${R(
+          a.errors
+        )}` : s();
+      }
+    ), oe(
+      o,
+      n
+    );
+  }
+  throw new Error(`${s()} OR to "all"`);
+}
+function Ae(o, e) {
+  return typeof o == "function" ? o(e) : o;
+}
+const H = "MultiStepFormSchema";
+class Z {
   debug;
-  prefix = G;
+  prefix = H;
   includeTimestamp = !1;
   throwOnError = !1;
   constructor(e) {
     if (this.debug = e?.debug ?? !1, this.debug && e?.debug) {
       const {
         includeTimestamp: t = !1,
-        prefix: r = G,
-        throwOnError: n = !1
+        prefix: r = H,
+        throwOnError: s = !1
       } = e;
-      this.includeTimestamp = t, this.prefix = typeof r == "string" ? r : r(G), this.throwOnError = n;
+      this.includeTimestamp = t, this.prefix = typeof r == "string" ? r : r(H), this.throwOnError = s;
     }
   }
   wrapValue(e, t) {
@@ -39,34 +148,34 @@ class me {
   formatPrefix(e) {
     if (!e)
       return this.prefix;
-    const { action: t, value: r, wrapWith: n } = e;
+    const { action: t, value: r, wrapWith: s } = e;
     if (t === "replace")
-      return this.wrapValue(n ?? "[]", r);
-    const { delimiter: s } = e;
+      return this.wrapValue(s ?? "[]", r);
+    const { delimiter: n } = e;
     return t === "append" ? `${this.wrapValue(
-      n?.originalPrefix ?? "[]",
+      s?.originalPrefix ?? "[]",
       this.prefix
-    )}${s}${this.wrapValue(
-      n?.addedPrefix ?? "[]",
+    )}${n}${this.wrapValue(
+      s?.addedPrefix ?? "[]",
       r
     )}`.trim() : t === "prepend" ? `${this.wrapValue(
-      n?.addedPrefix ?? "[]",
+      s?.addedPrefix ?? "[]",
       r
-    )}${s}${this.wrapValue(
-      n?.originalPrefix ?? "[]",
+    )}${n}${this.wrapValue(
+      s?.originalPrefix ?? "[]",
       this.prefix
     )}`.trim() : this.prefix;
   }
   formatMessage(e, t, r) {
     const {
-      includeTimestamp: n = this.includeTimestamp,
-      prefix: s,
-      logLevelOptions: i
-    } = r ?? {}, y = this.formatPrefix(s), b = this.wrapValue(
-      i?.wrapWith ?? "[]",
-      (i?.level ?? e).toUpperCase()
-    ), f = `${y} ${b} ${t}`;
-    return n ? `[${(/* @__PURE__ */ new Date()).toISOString()}] ${f}` : f;
+      includeTimestamp: s = this.includeTimestamp,
+      prefix: n,
+      logLevelOptions: a
+    } = r ?? {}, u = this.formatPrefix(n), b = this.wrapValue(
+      a?.wrapWith ?? "[]",
+      (a?.level ?? e).toUpperCase()
+    ), S = `${u} ${b} ${t}`;
+    return s ? `[${(/* @__PURE__ */ new Date()).toISOString()}] ${S}` : S;
   }
   info(e, t) {
     this.debug && console.info(this.formatMessage("info", e, t));
@@ -82,412 +191,665 @@ class me {
       throw new Error(r);
   }
 }
-const re = '"window" in undefined. No storage is available', Q = "MultiStepForm";
-class ye {
-  key;
-  store;
-  data;
-  log;
-  isWindowUndefined;
-  constructor(e) {
-    const { key: t, data: r, store: n } = e;
-    this.log = new me({
-      prefix: Q
-    }), this.key = t, this.data = r, n ? (this.store = n, this.isWindowUndefined = !1) : typeof window < "u" ? (this.store = window.localStorage, this.isWindowUndefined = !1) : (this.isWindowUndefined = !0, this.log.warn(re));
-  }
-  throwOnEmptyStore() {
-    j(this.store, () => this.isWindowUndefined ? re : "No storage available");
-  }
-  resolveValue(e) {
-    if (typeof e == "object")
-      return e;
-    if (typeof e == "function")
-      return e(this.data);
-    this.log.error(
-      `The updater value must be a function or object. Was a ${typeof e}`,
-      { throw: !0 }
-    );
-  }
-  hasKey() {
-    return this.store.getItem(this.key) !== null;
-  }
-  get() {
-    this.throwOnEmptyStore();
-    const e = this.store.getItem(this.key);
-    if (e)
-      return JSON.parse(e);
-  }
-  remove() {
-    this.throwOnEmptyStore(), this.store.removeItem(this.key);
-  }
-  add(e) {
-    this.throwOnEmptyStore();
-    const t = JSON.stringify(this.resolveValue(e));
-    this.store.setItem(this.key, t);
-  }
-}
-const we = [
-  "sentence",
-  "title",
-  "camel",
-  "lower",
-  "upper",
-  "pascal",
-  "snake",
-  "screaming-snake",
-  "flat",
-  "kebab"
-], X = "title";
-function Te(o, e) {
-  const t = o.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[-_]+/g, " ").trim().split(/\s+/).map((r) => r.toLowerCase());
-  switch (e) {
-    case "sentence":
-      return t[0].charAt(0).toUpperCase() + t[0].slice(1) + (t.length > 1 ? " " + t.slice(1).join(" ") : "");
-    case "title":
-      return t.map((r) => r.charAt(0).toUpperCase() + r.slice(1)).join(" ");
-    case "camel":
-      return t[0] + t.slice(1).map((r) => r.charAt(0).toUpperCase() + r.slice(1)).join("");
-    case "pascal":
-      return t.map((r) => r.charAt(0).toUpperCase() + r.slice(1)).join("");
-    case "lower":
-      return t.join(" ");
-    case "upper":
-      return t.join(" ").toUpperCase();
-    case "snake":
-      return t.join("_");
-    case "screaming-snake":
-      return t.join("_").toUpperCase();
-    case "kebab":
-      return t.join("-");
-    case "flat":
-      return t.join("");
-    default:
-      return o;
-  }
-}
-function J(o) {
-  return typeof o != "string" ? !1 : we.includes(o);
-}
-function ge(o, e = X) {
-  return J(o) ? o : e;
-}
-const Ae = [
-  "string",
-  "string.phone",
-  "string.email",
-  "string.time",
-  "number",
-  "number.counter",
-  "date",
-  "dateTime",
-  "boolean.switch"
-], ne = "string";
-function Ce(o) {
-  return typeof o == "string" && Ae.includes(o);
-}
-function U(o, e, t) {
-  const r = [], n = new Set(o), s = t ? t.format(o.map((i) => `${i}`)) : `[${o.join(", ")}]`;
-  for (let i = 0; i < e.length; i++) {
-    const y = e[i];
-    n.has(y) || r.push(
-      `Extra element at index ${i}: "${y}" is not in ${s}`
-    );
-  }
-  return e.some((i) => n.has(i)) || r.push(
-    `Array must contain at least one valid element from ${s}`
-  ), r.length > 0 ? { status: "error", errors: r } : { status: "success" };
-}
-function R(o, e) {
-  const t = (r, n) => `❌ ${n + 1}. ${r}`;
-  return o.map((r, n) => t(r, n)).join(`
-`);
-}
-function se(o) {
-  return Object.keys(o);
-}
 var C;
 ((o) => {
-  function e(a, l) {
-    return l.split(".").reduce((h, u) => h?.[u], a);
-  }
-  function t(a, l, h) {
-    const u = l.split(".");
-    let d = a;
-    for (let E = 0; E < u.length; E++) {
-      const _ = u[E];
-      E === u.length - 1 ? d[_] !== void 0 && typeof d[_] == "object" && typeof h == "object" && h !== null ? Object.assign(d[_], h) : d[_] = h : ((typeof d[_] != "object" || d[_] === null) && (d[_] = {}), d = d[_]);
+  function e(i, l) {
+    return l.split(".").reduce((d, c) => d?.[c], i);
+  }
+  function t(i, l, d) {
+    const c = l.split(".");
+    let h = i;
+    for (let O = 0; O < c.length; O++) {
+      const $ = c[O];
+      O === c.length - 1 ? h[$] !== void 0 && typeof h[$] == "object" && typeof d == "object" && d !== null ? Object.assign(h[$], d) : h[$] = d : ((typeof h[$] != "object" || h[$] === null) && (h[$] = {}), h = h[$]);
     }
-    return d;
+    return h;
   }
   o.setBy = t;
-  function r(a) {
-    return a.filter((l) => !a.some((h) => h !== l && l.startsWith(h + ".")));
-  }
-  function n(a, ...l) {
-    const h = r(l);
-    if (h.length === 1)
-      return e(a, h[0]);
-    const u = {};
-    for (const d of h) {
-      const E = e(a, d);
-      t(u, d, E);
+  function r(i) {
+    return i.filter((l) => !i.some((d) => d !== l && l.startsWith(d + ".")));
+  }
+  function s(i, ...l) {
+    const d = r(l);
+    if (d.length === 1)
+      return e(i, d[0]);
+    const c = {};
+    for (const h of d) {
+      const O = e(i, h);
+      t(c, h, O);
     }
-    return u;
+    return c;
   }
-  o.pickBy = n;
-  function s(a) {
+  o.pickBy = s;
+  function n(i) {
     const l = [];
-    function h(u, d = "") {
-      if (u == null || typeof u != "object" || Array.isArray(u))
+    function d(c, h = "") {
+      if (c == null || typeof c != "object" || Array.isArray(c))
         return;
-      const E = Object.keys(u);
-      for (const _ of E) {
-        const T = d ? `${d}.${_}` : _;
-        l.push(T);
-        const A = u[_];
-        A != null && typeof A == "object" && !Array.isArray(A) && h(A, T);
+      const O = Object.keys(c);
+      for (const $ of O) {
+        const j = h ? `${h}.${$}` : $;
+        l.push(j);
+        const A = c[$];
+        A != null && typeof A == "object" && !Array.isArray(A) && d(A, j);
       }
     }
-    return h(a), l;
+    return d(i), l;
   }
-  o.createDeep = s;
-  function i(a) {
-    if (a === null) return "null";
-    if (Array.isArray(a)) return "Array";
-    const l = typeof a;
+  o.createDeep = n;
+  function a(i) {
+    if (i === null) return "null";
+    if (Array.isArray(i)) return "Array";
+    const l = typeof i;
     if (l !== "object") return l;
-    const h = a?.constructor?.name;
-    return h && h !== "Object" ? h : "object";
-  }
-  function y(a) {
-    if (!a) return [];
-    const l = [], h = /[^.[\]]+|\[(\d+)\]/g;
-    let u;
-    for (; u = h.exec(a); )
-      l.push(u[1] ?? u[0]);
+    const d = i?.constructor?.name;
+    return d && d !== "Object" ? d : "object";
+  }
+  function u(i) {
+    if (!i) return [];
+    const l = [], d = /[^.[\]]+|\[(\d+)\]/g;
+    let c;
+    for (; c = d.exec(i); )
+      l.push(c[1] ?? c[0]);
     return l;
   }
-  function b(a, l) {
-    if (!a) return;
-    if (typeof a == "function")
-      return a;
-    const h = y(l);
-    let u = a, d;
-    for (const E of h) {
-      if (!u) break;
-      if (typeof u == "function") {
-        d = u;
+  function b(i, l) {
+    if (!i) return;
+    if (typeof i == "function")
+      return i;
+    const d = u(l);
+    let c = i, h;
+    for (const O of d) {
+      if (!c) break;
+      if (typeof c == "function") {
+        h = c;
         break;
       }
-      if (u = u[E], typeof u == "function") {
-        d = u;
+      if (c = c[O], typeof c == "function") {
+        h = c;
         break;
       }
     }
-    return d;
-  }
-  function f(a, l, h) {
-    const u = b(h, l);
-    return u ? u(a, l) : i(a);
-  }
-  function g(a) {
-    return typeof a == "object" && a !== null;
-  }
-  function c(a, l, h, u, d) {
-    if (a === l)
-      return u;
-    if (a === null || l === null || typeof a != "object" || typeof l != "object") {
-      const _ = h || "(root)";
-      return typeof a != typeof l ? (u.push({
-        path: _,
-        expected: f(a, _, d.transformExpected),
+    return h;
+  }
+  function S(i, l, d) {
+    const c = b(d, l);
+    return c ? c(i, l) : a(i);
+  }
+  function p(i) {
+    return typeof i == "object" && i !== null;
+  }
+  function f(i, l, d, c, h) {
+    if (i === l)
+      return c;
+    if (i === null || l === null || typeof i != "object" || typeof l != "object") {
+      const $ = d || "(root)";
+      return typeof i != typeof l ? (c.push({
+        path: $,
+        expected: S(i, $, h.transformExpected),
         actual: l,
         reason: "type-mismatch"
-      }), u) : (d.includeValueMismatch && u.push({
-        path: _,
-        expected: f(a, _, d.transformExpected),
+      }), c) : (h.includeValueMismatch && c.push({
+        path: $,
+        expected: S(i, $, h.transformExpected),
         actual: l,
         reason: "value-mismatch"
-      }), u);
+      }), c);
     }
-    if (Array.isArray(a) || Array.isArray(l)) {
-      if (!Array.isArray(a) || !Array.isArray(l)) {
-        const T = h || "(root)";
-        return u.push({
-          path: T,
-          expected: f(a, T, d.transformExpected),
+    if (Array.isArray(i) || Array.isArray(l)) {
+      if (!Array.isArray(i) || !Array.isArray(l)) {
+        const j = d || "(root)";
+        return c.push({
+          path: j,
+          expected: S(i, j, h.transformExpected),
           actual: l,
           reason: "type-mismatch"
-        }), u;
+        }), c;
       }
-      const _ = a.length;
-      for (let T = 0; T < _; T++) {
-        const A = a[T], x = l[T], k = h === "" ? `[${T}]` : `${h}[${T}]`;
-        if (T >= l.length) {
-          u.push({
-            path: k,
-            expected: f(A, k, d.transformExpected),
+      const $ = i.length;
+      for (let j = 0; j < $; j++) {
+        const A = i[j], k = l[j], F = d === "" ? `[${j}]` : `${d}[${j}]`;
+        if (j >= l.length) {
+          c.push({
+            path: F,
+            expected: S(A, F, h.transformExpected),
             actual: void 0,
             reason: "missing-key"
           });
           continue;
         }
-        c(A, x, k, u, d);
+        f(A, k, F, c, h);
       }
-      if (l.length > a.length)
-        for (let T = a.length; T < l.length; T++) {
-          const A = h === "" ? `[${T}]` : `${h}[${T}]`;
-          u.push({
+      if (l.length > i.length)
+        for (let j = i.length; j < l.length; j++) {
+          const A = d === "" ? `[${j}]` : `${d}[${j}]`;
+          c.push({
             path: A,
             expected: void 0,
-            actual: l[T],
+            actual: l[j],
             reason: "extra-key"
           });
         }
-      return u;
+      return c;
     }
-    if (g(a) && g(l)) {
-      const _ = Object.keys(a), T = Object.keys(l);
-      for (const A of _) {
-        const x = a[A], k = l[A], F = h ? `${h}.${A}` : A;
+    if (p(i) && p(l)) {
+      const $ = Object.keys(i), j = Object.keys(l);
+      for (const A of $) {
+        const k = i[A], F = l[A], V = d ? `${d}.${A}` : A;
         if (!(A in l)) {
-          u.push({
-            path: F,
-            expected: f(x, F, d.transformExpected),
+          c.push({
+            path: V,
+            expected: S(k, V, h.transformExpected),
             actual: void 0,
             reason: "missing-key"
           });
           continue;
         }
-        c(x, k, F, u, d);
+        f(k, F, V, c, h);
       }
-      for (const A of T)
-        if (!(A in a)) {
-          const x = h ? `${h}.${A}` : A;
-          u.push({
-            path: x,
+      for (const A of j)
+        if (!(A in i)) {
+          const k = d ? `${d}.${A}` : A;
+          c.push({
+            path: k,
             expected: void 0,
             actual: l[A],
             reason: "extra-key"
           });
         }
-      return u;
+      return c;
     }
-    const E = h || "(root)";
-    return typeof a != typeof l ? u.push({
-      path: E,
-      expected: f(a, E, d.transformExpected),
+    const O = d || "(root)";
+    return typeof i != typeof l ? c.push({
+      path: O,
+      expected: S(i, O, h.transformExpected),
       actual: l,
       reason: "type-mismatch"
-    }) : d.includeValueMismatch && u.push({
-      path: E,
-      expected: f(a, E, d.transformExpected),
+    }) : h.includeValueMismatch && c.push({
+      path: O,
+      expected: S(i, O, h.transformExpected),
       actual: l,
       reason: "value-mismatch"
-    }), u;
+    }), c;
   }
-  function m(a, l, h, u) {
-    const d = n(a, ...l), E = [], _ = l.length === 1 ? l[0] : "";
-    return c(d, h, _, E, {
-      transformExpected: u?.transformExpected
+  function v(i, l, d, c) {
+    const h = s(i, ...l), O = [], $ = l.length === 1 ? l[0] : "";
+    return f(h, d, $, O, {
+      transformExpected: c?.transformExpected
     }), {
-      ok: E.length === 0,
-      mismatches: E
+      ok: O.length === 0,
+      mismatches: O
     };
   }
-  o.equalsAtPaths = m;
-  function p(a) {
-    if (a === void 0) return "undefined";
-    if (typeof a == "string") return JSON.stringify(a);
+  o.equalsAtPaths = v;
+  function y(i) {
+    if (i === void 0) return "undefined";
+    if (typeof i == "string") return JSON.stringify(i);
     try {
-      return JSON.stringify(a, null, 2);
+      return JSON.stringify(i, null, 2);
     } catch {
-      return String(a);
+      return String(i);
+    }
+  }
+  function m(i) {
+    switch (i.reason) {
+      case "missing-key":
+        return "Missing key";
+      case "extra-key":
+        return "Extra key";
+      case "type-mismatch":
+        return "Type mismatch";
+      case "value-mismatch":
+        return "Value mismatch";
+      default:
+        return i.reason;
+    }
+  }
+  function g(i) {
+    if (i.ok || i.mismatches.length === 0)
+      return "No mismatches.";
+    const l = [];
+    for (const d of i.mismatches)
+      l.push(
+        `
+● ${m(d)} at "${d.path}":`,
+        `    expected: ${y(d.expected)}`,
+        `    actual:   ${y(d.actual)}`,
+        ""
+        // blank line between entries
+      );
+    return l.at(-1) === "" && l.pop(), l.join(`
+`);
+  }
+  o.formatMismatches = g;
+  function E(i) {
+    const l = g(i);
+    l !== "No mismatches." && console.error(l);
+  }
+  o.printMismatches = E;
+  function w(i, l, d) {
+    const c = l.split(".");
+    function h(O, $) {
+      const j = c[$], A = Array.isArray(O) ? [...O] : { ...O };
+      if ($ === c.length - 1) {
+        let P = O && typeof O == "object" ? A : {};
+        return P = {
+          ...P,
+          [j]: d
+        }, P;
+      }
+      const k = O && typeof O == "object" ? O[j] : void 0, F = h(k ?? {}, $ + 1);
+      let V = O && typeof O == "object" ? A : {};
+      return V = {
+        ...V,
+        [j]: F
+      }, V;
+    }
+    return h(i, 0);
+  }
+  function T(i, l, d) {
+    const c = r(l);
+    if (c.length === 0) return i;
+    let h = i;
+    if (c.length === 1) {
+      const O = c[0];
+      return h = w(h, O, d), h;
+    }
+    for (const O of c) {
+      const $ = e(d, O);
+      h = w(h, O, $);
     }
+    return h;
+  }
+  o.updateAt = T;
+})(C || (C = {}));
+function ge(o, e) {
+  const t = o["~standard"].validate(e);
+  if (t instanceof Promise)
+    throw new TypeError("Schema validation must be synchronous", {
+      cause: o
+    });
+  if (t.issues)
+    throw new Error(JSON.stringify(t.issues, null, 2));
+  return t.value;
+}
+function Se(o, e) {
+  return Object.keys(o).includes(e);
+}
+class Q {
+  #e;
+  #t;
+  get value() {
+    return this.#e();
+  }
+  constructor(e) {
+    const { getValue: t, setValue: r } = e;
+    this.#e = t, this.#t = r;
+  }
+  handlePostUpdate(e) {
+    this.#t(this.enrichValues(e));
+  }
+  createStepUpdaterFnImpl(e) {
+    const { targetStep: t, updater: r, ctxData: s, fields: n = "all", debug: a } = e, u = new Z({
+      debug: a,
+      prefix: (m) => `${m}:update${t}`
+    });
+    u.info(`${t} will be updated`), _(
+      Se(this.value, t),
+      `[update]: The target step ${t} isn't a valid step. Please select a valid step`
+    );
+    const { [t]: b, ...S } = this.value;
+    let p = { ...this.value }, f = N(p, [t]);
+    if (s) {
+      _(
+        typeof s == "function",
+        '[update]: "ctxData" must be a function'
+      ), u.info('Custom "ctx" will be used');
+      const m = s({ ctx: S });
+      _(
+        typeof m == "object" && Object.keys(m).length > 0,
+        '[update]: "ctxData" must return an object with keys'
+      ), u.info(
+        `Custom "ctx" consists of the following keys: ${new Intl.ListFormat(
+          "en",
+          {
+            style: "long",
+            type: "conjunction"
+          }
+        ).format(Object.keys(m))}`
+      ), f = {
+        ...f,
+        ...m
+      };
+    }
+    const v = Ae(r, {
+      ctx: f,
+      update: this.createHelperFnInputUpdate([t])
+    });
+    if (u.info(`The updated data is ${JSON.stringify(v, null, 2)}`), !n) {
+      _(
+        typeof v == "object",
+        '[update]: "updater" must be an object or a function that returns an object'
+      );
+      const m = Object.keys(this.value), g = Object.keys(v);
+      _(g.length === m.length, () => {
+        const i = m.filter(
+          (d) => !g.includes(d)
+        );
+        return `[update]: "updater" is missing keys ${new Intl.ListFormat("en", {
+          style: "long",
+          type: "conjunction"
+        }).format(
+          i
+        )}`;
+      });
+      const E = C.createDeep(this.value), { mismatches: w, ok: T } = C.equalsAtPaths(
+        this.value,
+        E,
+        v
+      );
+      _(
+        T && w.length === 0,
+        `[update]: found value mismatches in ${C.printMismatches({
+          mismatches: w,
+          ok: T
+        })}`
+      ), u.info("The entire step will be updated"), p = {
+        ...p,
+        [t]: C.updateAt(p, E, v)
+      }, this.handlePostUpdate(p), u.info(`The new value is: ${JSON.stringify(p, null, 2)}`);
+      return;
+    }
+    const y = C.createDeep(b);
+    if (Array.isArray(n)) {
+      const m = U(y, n);
+      _(
+        m.status === "success",
+        `[update]: Found errors with the provided fields
+${m.status === "error" ? R(m.errors) : ""}`
+      );
+      const { mismatches: g, ok: E } = C.equalsAtPaths(
+        b,
+        n,
+        v
+      );
+      _(
+        E && g.length === 0,
+        `[update]: found value mismatches in ${C.printMismatches({
+          ok: E,
+          mismatches: g
+        })}`
+      ), u.info(
+        `The following fields will be updated: ${new Intl.ListFormat("en", {
+          type: "conjunction",
+          style: "long"
+        }).format(n)}`
+      ), p = {
+        ...p,
+        [t]: C.updateAt(b, n, v)
+      }, this.handlePostUpdate(p), u.info(`The new value is: ${JSON.stringify(p, null, 2)}`);
+      return;
+    }
+    if (typeof n == "object" && Object.keys(n).length > 0) {
+      const m = C.createDeep(n), g = U(
+        y,
+        m
+      );
+      _(
+        g.status === "success",
+        `[update]: Found errors with the provided fields
+${g.status === "error" ? R(g.errors) : ""}`
+      );
+      const { mismatches: E, ok: w } = C.equalsAtPaths(
+        b,
+        m,
+        v
+      );
+      _(
+        w && E.length === 0,
+        `[update]: found value mismatches in ${C.printMismatches({
+          ok: w,
+          mismatches: E
+        })}`
+      ), p = {
+        ...p,
+        [t]: C.updateAt(
+          b,
+          m,
+          v
+        )
+      }, u.info(
+        `The following fields will be updated: ${new Intl.ListFormat("en", {
+          type: "conjunction",
+          style: "long"
+        }).format(Object.keys(n))}`
+      ), this.handlePostUpdate(p), u.info(`The new value is: ${JSON.stringify(p, null, 2)}`);
+      return;
+    }
+    throw u.error('Unsupported value for the "fields" option'), new TypeError(
+      `[update]: property "fields" must be set to one of the following: "all", an array of deep paths to update, or an object of paths. Was ${typeof r}`,
+      { cause: r }
+    );
+  }
+  createStepUpdaterFn(e) {
+    return (t) => {
+      this.createStepUpdaterFnImpl({ targetStep: e, ...t });
+    };
+  }
+  update(e) {
+    return this.createStepUpdaterFnImpl(e);
+  }
+  createHelperFnInputUpdate(e) {
+    if (x.isAll(e)) {
+      const r = se(this.value).reduce((n, a) => (n[a] = this.createStepUpdaterFn(a), n), {});
+      return Object.assign(
+        this.update,
+        r
+      );
+    }
+    const t = Object.keys(this.value);
+    if (x.isTuple(e, t)) {
+      const r = e.reduce((n, a) => (n[a] = this.createStepUpdaterFn(a), n), {});
+      return Object.assign(
+        this.update,
+        r
+      );
+    }
+    if (x.isObject(e, t)) {
+      const r = se(e).reduce((n, a) => (n[a] = this.createStepUpdaterFn(a), n), {});
+      return Object.assign(
+        this.update,
+        r
+      );
+    }
+    throw new TypeError(`[update]: ${x.CATCH_ALL_MESSAGE}`);
+  }
+  createStepHelperFn(e) {
+    return (t, r) => {
+      const s = N(
+        this.value,
+        e
+      ), n = this.createHelperFnInputUpdate(
+        e
+      );
+      if (typeof t == "function")
+        return () => t({
+          ctx: s,
+          update: n
+        });
+      if (typeof t == "object")
+        return (a) => {
+          if ("validator" in t) {
+            _(
+              typeof a == "object",
+              "An input is expected since you provided a validator"
+            ), ge(
+              t.validator,
+              a.data
+            );
+            let u = s;
+            if (t.ctxData) {
+              const b = e[0], { [b]: S, ...p } = this.value;
+              u = {
+                ...u,
+                ...t.ctxData({ ctx: p })
+              };
+            }
+            return r({
+              ctx: u,
+              update: n,
+              ...a
+            });
+          }
+          return r({
+            ctx: s,
+            update: n
+          });
+        };
+      throw new Error(
+        `The first argument must be a function or an object, (was ${typeof t})`
+      );
+    };
+  }
+  enrichValues(e, t) {
+    let r = { ...e };
+    for (const [s, n] of Object.entries(r)) {
+      const [a] = [s], u = Number.parseInt(
+        a.replace("step", "")
+      );
+      r[a] = {
+        ...n,
+        update: this.createStepUpdaterFn(a),
+        createHelperFn: this.createStepHelperFn([a]),
+        ...t?.(u)
+      };
+    }
+    return r;
+  }
+}
+var x;
+((o) => {
+  o.CATCH_ALL_MESSAGE = 'The chosen steps must either be set to on of the following: "all", an array of steps (["step1", "step2", ...]), or an object containing the steps to chose ({ step1: true, step2: true, ...})';
+  function e(s) {
+    return !!(s && typeof s == "string" && s === "all");
+  }
+  o.isAll = e;
+  function t(s, n) {
+    return Array.isArray(s) ? n ? s.every((a) => n.includes(a)) : !0 : !1;
+  }
+  o.isTuple = t;
+  function r(s, n) {
+    if (!s)
+      return !1;
+    const a = Object.keys(s);
+    return a.length === 0 || n && !a.every((u) => n.includes(u)) ? !1 : Object.entries(s).every(([u, b]) => b === !0);
+  }
+  o.isObject = r;
+})(x || (x = {}));
+const Ce = [
+  "sentence",
+  "title",
+  "camel",
+  "lower",
+  "upper",
+  "pascal",
+  "snake",
+  "screaming-snake",
+  "flat",
+  "kebab"
+], ee = "title";
+function ke(o, e) {
+  const t = o.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[-_]+/g, " ").trim().split(/\s+/).map((r) => r.toLowerCase());
+  switch (e) {
+    case "sentence":
+      return t[0].charAt(0).toUpperCase() + t[0].slice(1) + (t.length > 1 ? " " + t.slice(1).join(" ") : "");
+    case "title":
+      return t.map((r) => r.charAt(0).toUpperCase() + r.slice(1)).join(" ");
+    case "camel":
+      return t[0] + t.slice(1).map((r) => r.charAt(0).toUpperCase() + r.slice(1)).join("");
+    case "pascal":
+      return t.map((r) => r.charAt(0).toUpperCase() + r.slice(1)).join("");
+    case "lower":
+      return t.join(" ");
+    case "upper":
+      return t.join(" ").toUpperCase();
+    case "snake":
+      return t.join("_");
+    case "screaming-snake":
+      return t.join("_").toUpperCase();
+    case "kebab":
+      return t.join("-");
+    case "flat":
+      return t.join("");
+    default:
+      return o;
+  }
+}
+function q(o) {
+  return typeof o != "string" ? !1 : Ce.includes(o);
+}
+function be(o, e = ee) {
+  return q(o) ? o : e;
+}
+const Fe = [
+  "string",
+  "string.phone",
+  "string.email",
+  "string.time",
+  "number",
+  "number.counter",
+  "date",
+  "dateTime",
+  "boolean.switch"
+], ie = "string";
+function Ve(o) {
+  return typeof o == "string" && Fe.includes(o);
+}
+const ae = '"window" in undefined. No storage is available', te = "MultiStepForm";
+class ve {
+  key;
+  store;
+  data;
+  log;
+  isWindowUndefined;
+  constructor(e) {
+    const { key: t, data: r, store: s } = e;
+    this.log = new Z({
+      prefix: te
+    }), this.key = t, this.data = r, s ? (this.store = s, this.isWindowUndefined = !1) : typeof window < "u" ? (this.store = window.localStorage, this.isWindowUndefined = !1) : (this.isWindowUndefined = !0, this.log.warn(ae));
+  }
+  throwOnEmptyStore() {
+    _(this.store, () => this.isWindowUndefined ? ae : "No storage available");
   }
-  function v(a) {
-    switch (a.reason) {
-      case "missing-key":
-        return "Missing key";
-      case "extra-key":
-        return "Extra key";
-      case "type-mismatch":
-        return "Type mismatch";
-      case "value-mismatch":
-        return "Value mismatch";
-      default:
-        return a.reason;
-    }
+  resolveValue(e) {
+    if (typeof e == "object")
+      return e;
+    if (typeof e == "function")
+      return e(this.data);
+    this.log.error(
+      `The updater value must be a function or object. Was a ${typeof e}`,
+      { throw: !0 }
+    );
   }
-  function S(a) {
-    if (a.ok || a.mismatches.length === 0)
-      return "No mismatches.";
-    const l = [];
-    for (const h of a.mismatches)
-      l.push(
-        `
-● ${v(h)} at "${h.path}":`,
-        `    expected: ${p(h.expected)}`,
-        `    actual:   ${p(h.actual)}`,
-        ""
-        // blank line between entries
-      );
-    return l.at(-1) === "" && l.pop(), l.join(`
-`);
+  hasKey() {
+    return this.store.getItem(this.key) !== null;
   }
-  o.formatMismatches = S;
-  function O(a) {
-    const l = S(a);
-    l !== "No mismatches." && console.error(l);
+  get() {
+    this.throwOnEmptyStore();
+    const e = this.store.getItem(this.key);
+    if (e)
+      return JSON.parse(e);
   }
-  o.printMismatches = O;
-  function $(a, l, h) {
-    const u = l.split(".");
-    function d(E, _) {
-      const T = u[_], A = Array.isArray(E) ? [...E] : { ...E };
-      if (_ === u.length - 1) {
-        let P = E && typeof E == "object" ? A : {};
-        return P = {
-          ...P,
-          [T]: h
-        }, P;
-      }
-      const x = E && typeof E == "object" ? E[T] : void 0, k = d(x ?? {}, _ + 1);
-      let F = E && typeof E == "object" ? A : {};
-      return F = {
-        ...F,
-        [T]: k
-      }, F;
-    }
-    return d(a, 0);
-  }
-  function w(a, l, h) {
-    const u = r(l);
-    if (u.length === 0) return a;
-    let d = a;
-    if (u.length === 1) {
-      const E = u[0];
-      return d = $(d, E, h), d;
-    }
-    for (const E of u) {
-      const _ = e(h, E);
-      d = $(d, E, _);
-    }
-    return d;
+  remove() {
+    this.throwOnEmptyStore(), this.store.removeItem(this.key);
+  }
+  add(e) {
+    this.throwOnEmptyStore();
+    const t = JSON.stringify(this.resolveValue(e));
+    this.store.setItem(this.key, t);
   }
-  o.updateAt = w;
-})(C || (C = {}));
-function be(o, e) {
-  const t = o["~standard"].validate(e);
-  if (t instanceof Promise)
-    throw new TypeError("Schema validation must be synchronous", {
-      cause: o
-    });
-  if (t.issues)
-    throw new Error(JSON.stringify(t.issues, null, 2));
-  return t.value;
 }
-class Se {
+class Ee {
   listeners = /* @__PURE__ */ new Set();
   constructor() {
     this.subscribe = this.subscribe.bind(this);
@@ -505,191 +867,83 @@ class Se {
   onUnsubscribe() {
   }
 }
-var V;
-((o) => {
-  o.CATCH_ALL_MESSAGE = 'The chosen steps must either be set to on of the following: "all", an array of steps (["step1", "step2", ...]), or an object containing the steps to chose ({ step1: true, step2: true, ...})';
-  function e(n) {
-    return !!(n && typeof n == "string" && n === "all");
-  }
-  o.isAll = e;
-  function t(n, s) {
-    return Array.isArray(n) ? s ? n.every((i) => s.includes(i)) : !0 : !1;
-  }
-  o.isTuple = t;
-  function r(n, s) {
-    if (!n)
-      return !1;
-    const i = Object.keys(n);
-    return i.length === 0 || s && !i.every((y) => s.includes(y)) ? !1 : Object.entries(n).every(([y, b]) => b === !0);
-  }
-  o.isObject = r;
-})(V || (V = {}));
-function M(o) {
-  j(o.includes("step"), "Can't extract a valid step number since");
-  const e = o.replace("step", "");
-  return j(/^\d+$/.test(e), `Invalid step format: "${o}"`), Number.parseInt(e, 10);
-}
-function H(o) {
-  return function(e) {
-    const { step: t } = e, r = `step${t}`, n = o[r];
-    return { step: t, data: n };
-  };
-}
-function oe(o, e) {
-  return e.reduce((t, r) => {
-    const n = M(r), { data: s } = H(o)({
-      step: n
-    });
-    for (const [i, y] of Object.entries(s))
-      typeof y == "function" && i !== "update" || (s[i] = y);
-    return t[r] = s, t;
-  }, {});
-}
-function I(o, e) {
-  const t = new Intl.ListFormat("en", {
-    style: "long",
-    type: "disjunction"
-  }), r = Object.keys(o), n = () => `"stepData" must be set to an array of available steps (${t.format(
-    r
-  )})`;
-  if (e === "all") {
-    let s = {};
-    for (const i of r)
-      s = {
-        ...s,
-        [i]: H(o)({
-          step: M(i)
-        })
-      };
-    return Object.fromEntries(
-      r.map((i) => [
-        i,
-        H(o)({
-          step: M(i)
-        })
-      ])
-    );
-  }
-  if (Array.isArray(e))
-    return j(
-      e.every((s) => r.includes(s)),
-      () => {
-        const s = U(
-          e,
-          r.map((i) => M(i)),
-          t
-        );
-        return s.status === "error" ? `${n()}. See errors:
- ${R(
-          s.errors
-        )}` : n();
-      }
-    ), oe(
-      o,
-      e
-    );
-  if (typeof e == "object") {
-    const s = Object.keys(e);
-    return j(
-      s.every((i) => r.includes(i)),
-      () => {
-        const i = U(
-          s,
-          r,
-          t
-        );
-        return i.status === "error" ? `${n()}. See errors:
- ${R(
-          i.errors
-        )}` : n();
-      }
-    ), oe(
-      o,
-      s
-    );
-  }
-  throw new Error(`${n()} OR to "all"`);
-}
-function xe(o, e) {
-  return typeof o == "function" ? o(e) : o;
-}
-const ke = [
+const xe = [
   "string",
   "number",
   "array.string",
   "array.string.untyped"
-], ve = /^step\d+$/i;
-function ae(o, e) {
+], _e = /^step\d+$/i;
+function ue(o, e) {
   if (typeof o != "object" || o === null) return !1;
   for (const t of Object.keys(e)) {
     if (!(t in o)) return !1;
-    const r = e[t], n = o[t];
-    if (!r(n)) return !1;
+    const r = e[t], s = o[t];
+    if (!r(s)) return !1;
   }
   return !0;
 }
-function ie(o, e, t) {
-  return o ?? Te(e, t);
+function ce(o, e, t) {
+  return o ?? ke(e, t);
 }
-function Fe(o) {
-  const e = {}, { fields: t, defaultCasing: r, validateFields: n } = o;
-  for (const [s, i] of Object.entries(t)) {
-    j(
-      typeof s == "string",
-      `Each key for the "fields" option must be a string. Key ${s} was a ${typeof s}`
-    ), j(
-      typeof i == "object",
-      `The value for key ${s} must be an object. Was ${typeof i}`
+function Le(o) {
+  const e = {}, { fields: t, defaultCasing: r, validateFields: s } = o;
+  for (const [n, a] of Object.entries(t)) {
+    _(
+      typeof n == "string",
+      `Each key for the "fields" option must be a string. Key ${n} was a ${typeof n}`
+    ), _(
+      typeof a == "object",
+      `The value for key ${n} must be an object. Was ${typeof a}`
     );
     const {
-      defaultValue: y,
+      defaultValue: u,
       label: b,
-      nameTransformCasing: f,
-      type: g = ne
-    } = i;
-    if (n)
-      e[s] = y;
+      nameTransformCasing: S,
+      type: p = ie
+    } = a;
+    if (s)
+      e[n] = u;
     else {
-      const c = f ?? r;
-      e[s] = {
-        ...e[s],
-        nameTransformCasing: c,
-        type: g,
-        defaultValue: y,
-        label: ie(b, s, c)
+      const f = S ?? r;
+      e[n] = {
+        ...e[n],
+        nameTransformCasing: f,
+        type: p,
+        defaultValue: u,
+        label: ce(b, n, f)
         // TODO add more fields here
       };
     }
   }
-  if (n) {
-    const s = be(
-      n,
+  if (s) {
+    const n = ge(
+      s,
       e
     );
-    j(
-      typeof s == "object",
-      `The result of the validated fields must be an object, was (${typeof s}). This is probably an internal error, so open up an issue about it`
-    ), j(
-      !!s,
+    _(
+      typeof n == "object",
+      `The result of the validated fields must be an object, was (${typeof n}). This is probably an internal error, so open up an issue about it`
+    ), _(
+      !!n,
       "The result of the validated fields must be defined. This is probably an internal error, so open up an issue about it"
     );
-    for (const [i, y] of Object.entries(s)) {
-      const b = t[i];
-      j(
+    for (const [a, u] of Object.entries(n)) {
+      const b = t[a];
+      _(
         b,
-        `No field found in the fields config for "${i}"`
+        `No field found in the fields config for "${a}"`
       );
       const {
-        label: f,
-        type: g = ne,
-        nameTransformCasing: c
-      } = b, m = c ?? r;
-      e[i] = {
-        ...e[i],
-        nameTransformCasing: m,
-        type: g,
-        defaultValue: y,
-        label: ie(f, i, m)
+        label: S,
+        type: p = ie,
+        nameTransformCasing: f
+      } = b, v = f ?? r;
+      e[a] = {
+        ...e[a],
+        nameTransformCasing: v,
+        type: p,
+        defaultValue: u,
+        label: ce(S, a, v)
       };
     }
   }
@@ -697,61 +951,61 @@ function Fe(o) {
 }
 function Oe(o) {
   const e = {};
-  j(!!o, "The steps config must be defined", TypeError), j(
+  _(!!o, "The steps config must be defined", TypeError), _(
     typeof o == "object",
     `The steps config must be an object, was (${typeof o})`,
     TypeError
   );
   for (const [t, r] of Object.entries(o)) {
-    j(
+    _(
       typeof t == "string",
       `Each key for the step config must be a string. Key "${t}" was ${typeof t} `,
       TypeError
-    ), j(
-      ve.test(t),
+    ), _(
+      _e.test(t),
       `The key "${t}" isn't formatted properly. Each key in the step config must be the following format: "step{number}"`
     );
-    const n = t, {
-      fields: s,
-      title: i,
-      nameTransformCasing: y = X,
+    const s = t, {
+      fields: n,
+      title: a,
+      nameTransformCasing: u = ee,
       description: b,
-      validateFields: f
-    } = r, g = n.toString().replace("step", "");
-    j(
-      s,
-      `Missing fields for step ${g} (${String(n)})`,
+      validateFields: S
+    } = r, p = s.toString().replace("step", "");
+    _(
+      n,
+      `Missing fields for step ${p} (${String(s)})`,
       TypeError
-    ), j(
-      typeof s == "object",
+    ), _(
+      typeof n == "object",
       "Fields must be an object",
       TypeError
-    ), j(
-      Object.keys(s).length > 0,
-      `The fields config for step ${g} (${String(
-        n
+    ), _(
+      Object.keys(n).length > 0,
+      `The fields config for step ${p} (${String(
+        s
       )}) is empty. Please add a field`
-    ), j(
-      typeof s == "object",
-      `The "fields" property must be an object. Was ${typeof s}`
+    ), _(
+      typeof n == "object",
+      `The "fields" property must be an object. Was ${typeof n}`
     );
-    const c = Fe({
-      defaultCasing: y,
-      fields: s,
-      validateFields: f
+    const f = Le({
+      defaultCasing: u,
+      fields: n,
+      validateFields: S
     });
-    e[n] = {
-      ...e[n],
-      title: i,
-      nameTransformCasing: y,
+    e[s] = {
+      ...e[s],
+      title: a,
+      nameTransformCasing: u,
       // Only add the description if it's defined
       ...typeof b == "string" ? { description: b } : {},
-      fields: c
+      fields: f
     };
   }
   return e;
 }
-class ee extends Se {
+let re = class extends Ee {
   /**
    * The original config before any validation or transformations have been applied.
    */
@@ -767,44 +1021,58 @@ class ee extends Se {
   lastStep;
   stepNumbers;
   storage;
+  #e;
   constructor(e) {
     super();
-    const { steps: t, nameTransformCasing: r, storage: n } = e;
-    this.defaultNameTransformationCasing = ge(
+    const { steps: t, nameTransformCasing: r, storage: s } = e;
+    this.defaultNameTransformationCasing = be(
       r
-    ), this.original = t, this.value = this.enrichValues(Oe(this.original)), this.stepNumbers = Object.keys(this.value).map(
-      (s) => Number.parseInt(s.replace("step", ""))
-    ), this.storage = new ye({
+    ), this.original = t, this.value = Oe(this.original), this.storage = new ve({
       data: this.value,
-      key: n?.key ?? Q,
-      store: n?.store
-    }), this.firstStep = this.first(), this.lastStep = this.last(), this.steps = {
+      key: s?.key ?? te,
+      store: s?.store
+    }), this.#e = new Q({
+      getValue: () => this.value,
+      setValue: (n) => this.handlePostUpdate(n)
+    }), this.value = this.#e.enrichValues(this.value), this.stepNumbers = Object.keys(this.value).map(
+      (n) => Number.parseInt(n.replace("step", ""))
+    ), this.firstStep = this.first(), this.lastStep = this.last(), this.steps = {
       first: this.firstStep.step,
       last: this.lastStep.step,
       value: this.stepNumbers,
-      as: (s) => {
-        if (j(
-          typeof s == "string",
-          `The type of the target transformation type must be a string, was ${typeof s}`
-        ), s === "string")
-          return this.stepNumbers.map((i) => `'${i}'`).join(" | ");
-        if (s === "number")
+      as: (n) => {
+        if (_(
+          typeof n == "string",
+          `The type of the target transformation type must be a string, was ${typeof n}`
+        ), n === "string")
+          return this.stepNumbers.map((a) => `'${a}'`).join(" | ");
+        if (n === "number")
           return this.stepNumbers.join(" | ");
-        if (s.includes("array.string"))
-          return this.stepNumbers.map((i) => `${i}`);
+        if (n.includes("array.string"))
+          return this.stepNumbers.map((a) => `${a}`);
         throw new Error(
-          `Transformation type "${s}" is not supported. Available transformations include: ${ke.map(
-            (i) => `"${i}"`
+          `Transformation type "${n}" is not supported. Available transformations include: ${xe.map(
+            (a) => `"${a}"`
           ).join(", ")}`
         );
       },
-      isValidStepNumber: (s) => this.stepNumbers.includes(s),
-      isValidStepKey: (s) => Object.keys(this.value).includes(s)
-    };
+      isValidStepNumber: (n) => this.stepNumbers.includes(n),
+      isValidStepKey: (n) => Se(this.value, n)
+    }, this.sync();
   }
   getSnapshot() {
     return this;
   }
+  /**
+   * Syncs the values from storage to {@linkcode value}.
+   */
+  sync() {
+    const e = this.storage.get();
+    if (e) {
+      const t = this.#e.enrichValues(e);
+      this.value = { ...t };
+    }
+  }
   notify() {
     for (const e of this.listeners)
       e({
@@ -814,28 +1082,13 @@ class ee extends Se {
         value: this.value
       });
   }
-  enrichValues(e, t) {
-    for (const [r, n] of Object.entries(e)) {
-      const s = Number.parseInt(r.replace("step", ""));
-      e = {
-        ...e,
-        [r]: {
-          ...n,
-          update: this.createStepUpdaterFn(r),
-          createHelperFn: this.createStepHelperFn(s),
-          ...t?.(s)
-        }
-      };
-    }
-    return e;
-  }
   /**
    * Gets the data for a specific step.
    * @param options The options for getting the step data.
    * @returns The step data for the target step.
    */
   get(e) {
-    return H(this.value)(e);
+    return K(this.value)(e);
   }
   /**
    * Gets the data for the first step.
@@ -853,232 +1106,36 @@ class ee extends Se {
     const e = Math.max(...this.stepNumbers);
     return this.get({ step: e });
   }
-  handlePostUpdate() {
-    this.storage.add(this.value), this.notify();
-  }
-  createHelperFnInputUpdate(e) {
-    if (V.isAll(e)) {
-      const r = se(this.value).reduce((n, s) => (n[s] = this.createStepUpdaterFn(s), n), {});
-      return Object.assign(
-        this.update,
-        r
-      );
-    }
-    const t = Object.keys(this.value);
-    if (V.isTuple(e, t)) {
-      const r = e.reduce((n, s) => (n[s] = this.createStepUpdaterFn(s), n), {});
-      return Object.assign(
-        this.update,
-        r
-      );
-    }
-    if (V.isObject(e, t)) {
-      const r = se(e).reduce((n, s) => (n[s] = this.createStepUpdaterFn(s), n), {});
-      return Object.assign(
-        this.update,
-        r
-      );
-    }
-    throw new TypeError(`[update]: ${V.CATCH_ALL_MESSAGE}`);
-  }
-  createStepUpdaterFnImpl(e) {
-    const { targetStep: t, updater: r, ctxData: n, fields: s = "all" } = e;
-    j(
-      this.steps.isValidStepKey(t),
-      `[update]: The target step ${t} isn't a valid step. Please select a valid step`
-    );
-    const { [t]: i, ...y } = this.value;
-    let b = I(this.value, [t]);
-    if (n) {
-      j(
-        typeof n == "function",
-        '[update]: "ctxData" must be a function'
-      );
-      const c = n({ ctx: y });
-      j(
-        typeof c == "object" && Object.keys(c).length > 0,
-        '[update]: "ctxData" must return an object with keys'
-      ), b = {
-        ...b,
-        ...c
-      };
-    }
-    const f = xe(r, {
-      ctx: b,
-      update: this.createHelperFnInputUpdate([t])
-    });
-    if (!s) {
-      j(
-        typeof f == "object",
-        '[update]: "updater" must be an object or a function that returns an object'
-      );
-      const c = Object.keys(this.value), m = Object.keys(f);
-      j(m.length === c.length, () => {
-        const O = c.filter(
-          ($) => !m.includes($)
-        );
-        return `[update]: "updater" is missing keys ${new Intl.ListFormat("en", {
-          style: "long",
-          type: "conjunction"
-        }).format(
-          O
-        )}`;
-      });
-      const p = C.createDeep(this.value), { mismatches: v, ok: S } = C.equalsAtPaths(
-        this.value,
-        p,
-        f
-      );
-      j(
-        S && v.length === 0,
-        `[update]: found value mismatches in ${C.printMismatches({
-          mismatches: v,
-          ok: S
-        })}`
-      ), this.value = {
-        ...this.value,
-        [t]: C.updateAt(this.value, p, f)
-      }, this.handlePostUpdate();
-      return;
-    }
-    const g = C.createDeep(i);
-    if (Array.isArray(s)) {
-      const c = U(g, s);
-      j(
-        c.status === "success",
-        `[update]: Found errors with the provided fields
-${c.status === "error" ? R(c.errors) : ""}`
-      );
-      const { mismatches: m, ok: p } = C.equalsAtPaths(
-        i,
-        s,
-        f
-      );
-      j(
-        p && m.length === 0,
-        `[update]: found value mismatches in ${C.printMismatches({
-          ok: p,
-          mismatches: m
-        })}`
-      ), this.value = {
-        ...this.value,
-        [t]: C.updateAt(i, s, f)
-      }, this.handlePostUpdate();
-      return;
-    }
-    if (typeof s == "object" && Object.keys(s).length > 0) {
-      const c = C.createDeep(s), m = U(
-        g,
-        c
-      );
-      j(
-        m.status === "success",
-        `[update]: Found errors with the provided fields
-${m.status === "error" ? R(m.errors) : ""}`
-      );
-      const { mismatches: p, ok: v } = C.equalsAtPaths(
-        i,
-        c,
-        f
-      );
-      j(
-        v && p.length === 0,
-        `[update]: found value mismatches in ${C.printMismatches({
-          ok: v,
-          mismatches: p
-        })}`
-      ), this.value = {
-        ...this.value,
-        [t]: C.updateAt(
-          i,
-          c,
-          f
-        )
-      }, this.handlePostUpdate();
-      return;
-    }
-    throw new TypeError(
-      `[update]: property "fields" must be set to one of the following: "all", an array of deep paths to update, or an object of paths. Was ${typeof r}`,
-      { cause: r }
-    );
-  }
-  createStepUpdaterFn(e) {
-    return (t) => {
-      this.createStepUpdaterFnImpl({ targetStep: e, ...t });
-    };
+  handlePostUpdate(e) {
+    this.value = { ...e }, this.storage.add(this.value), this.sync(), this.notify();
   }
   update(e) {
-    this.createStepUpdaterFnImpl(e);
-  }
-  createStepHelperFnImpl(e) {
-    return (t, r) => {
-      const n = I(
-        this.value,
-        e
-      );
-      if (typeof t == "function")
-        return () => t({
-          ctx: n,
-          update: this.createHelperFnInputUpdate(e)
-        });
-      if (typeof t == "object")
-        return (s) => {
-          if ("validator" in t) {
-            j(
-              typeof s == "object",
-              "An input is expected since you provided a validator"
-            ), be(
-              t.validator,
-              s.data
-            );
-            let i = n;
-            if (t.ctxData) {
-              const y = e[0], { [y]: b, ...f } = this.value;
-              i = {
-                ...i,
-                ...t.ctxData({ ctx: f })
-              };
-            }
-            return r({
-              ctx: i,
-              update: this.createHelperFnInputUpdate(e),
-              ...s
-            });
-          }
-          return r({ ctx: n, update: this.createHelperFnInputUpdate(e) });
-        };
-      throw new Error(
-        `The first argument must be a function or an object, (was ${typeof t})`
-      );
-    };
-  }
-  createStepHelperFn(e) {
-    return this.createStepHelperFnImpl([`step${e}`]);
+    this.#e.update(e);
   }
   // Implementation
   createHelperFn(e, t) {
-    const { stepData: r, ...n } = e;
-    return this.createStepHelperFnImpl(r)(n, t);
+    const { stepData: r, ...s } = e;
+    return this.#e.createStepHelperFn(r)(s, t);
   }
   /**
    * Validates that a given object is the proper shape for step data.
    * @param value
    */
   static hasData(e, t) {
-    return e === null || typeof e != "object" ? !1 : ae(e, {
+    return e === null || typeof e != "object" ? !1 : ue(e, {
       title: (r) => typeof r == "string",
       fields: (r) => {
         if (r === null || typeof r != "object")
           return !1;
-        for (const n of Object.keys(r)) {
-          if (typeof n != "string" || !(n in r))
+        for (const s of Object.keys(r)) {
+          if (typeof s != "string" || !(s in r))
             return !1;
-          const s = r[n];
-          if (s === null || typeof s != "object" || !ae(s, {
-            defaultValue: (i) => i !== "undefined" && i !== null,
-            label: (i) => typeof i == "string" || typeof i == "boolean" && !i,
-            nameTransformCasing: J,
-            type: Ce
+          const n = r[s];
+          if (n === null || typeof n != "object" || !ue(n, {
+            defaultValue: (u) => u !== "undefined" && u !== null,
+            label: (u) => typeof u == "string" || typeof u == "boolean" && !u,
+            nameTransformCasing: q,
+            type: Ve
           }))
             return !1;
         }
@@ -1087,28 +1144,27 @@ ${m.status === "error" ? R(m.errors) : ""}`
       createHelperFn: (r) => typeof r == "function",
       // update: (v): v is GetCurrentStep<resolvedStep, stepNumbers>['update'] =>
       //   typeof v === 'function',
-      nameTransformCasing: J,
+      nameTransformCasing: q,
       ...t?.optionalKeysToCheck
     });
   }
-}
-class Ve extends Se {
+}, Ne = class extends Ee {
   defaultNameTransformationCasing;
   stepSchema;
   storage;
   mountCount = 0;
   constructor(e) {
     super();
-    const { steps: t, nameTransformCasing: r, storage: n } = e;
-    this.defaultNameTransformationCasing = ge(
+    const { steps: t, nameTransformCasing: r, storage: s } = e;
+    this.defaultNameTransformationCasing = be(
       r
-    ), this.stepSchema = new ee({
+    ), this.stepSchema = new re({
       steps: t,
       nameTransformCasing: this.defaultNameTransformationCasing
-    }), this.storage = new ye({
-      key: n?.key ?? Q,
+    }), this.storage = new ve({
+      key: s?.key ?? te,
       data: this.stepSchema.value,
-      store: n?.store
+      store: s?.store
     }), this.stepSchema.subscribe(() => {
       this.notify();
     });
@@ -1142,267 +1198,265 @@ class Ve extends Se {
         steps: this.stepSchema.original
       });
   }
-}
-function Ne(o) {
+};
+function Ie(o) {
   function e(t) {
-    const { children: r, name: n } = t;
-    return r(o(n));
+    const { children: r, name: s } = t;
+    return r(o(s));
   }
   return e;
 }
-var N;
+var L;
 ((o) => {
   o.DEFAULT_FORM_ALIAS = "Form";
-  function e(r, n) {
+  function e(r, s) {
     if (Array.isArray(r)) {
-      if (n === "all")
+      if (s === "all")
         return !0;
-      if (typeof n == "object" && !Array.isArray(n))
-        return Object.keys(n).some(
-          (s) => r.includes(s)
+      if (typeof s == "object" && !Array.isArray(s))
+        return Object.keys(s).some(
+          (n) => r.includes(n)
         );
-      if (Array.isArray(n))
-        return n.some((s) => r.includes(s));
+      if (Array.isArray(s))
+        return s.some((n) => r.includes(n));
     }
     return !1;
   }
   o.isFormAvailable = e;
   function t(r) {
-    return (n) => /* @__PURE__ */ $e("form", { id: r, ...n });
+    return (s) => /* @__PURE__ */ Te("form", { id: r, ...s });
   }
   o.createDefaultForm = t;
-})(N || (N = {}));
+})(L || (L = {}));
 var Y;
 ((o) => {
   o.DEFAULT_FORM_INSTANCE_ALIAS = "form";
 })(Y || (Y = {}));
-function Ie(o, e) {
-  j(
+function De(o, e) {
+  _(
     e in o,
     `The target step ${e} is not a valid step key`
   );
   const t = o[e];
-  j("fields" in t, `No "fields" were found for ${e}`);
+  _("fields" in t, `No "fields" were found for ${e}`);
   let r = {};
-  for (const [n, s] of Object.entries(
+  for (const [s, n] of Object.entries(
     t.fields
   ))
     r = {
       ...r,
-      [n]: s.defaultValue
+      [s]: n.defaultValue
     };
   return r;
 }
-class De extends ee {
+class Me extends re {
   // @ts-ignore type doesn't match `MultiStepFormSchemaBase.value`
   value;
+  #e;
   constructor(e) {
     const { form: t, ...r } = e;
-    super(r), this.value = this.enrichValues(Oe(this.original)), this.value = this.enrichValues(this.value, (n) => {
-      const s = `step${n}`, i = t?.id ?? s;
+    super(r), this.value = Oe(this.original), this.#e = new Q({
+      getValue: () => this.value,
+      setValue: (s) => this.handlePostUpdate(s)
+    }), this.sync(), this.value = this.#e.enrichValues(this.value, (s) => {
+      const n = `step${s}`, a = [n], u = t?.id ?? n, b = N(this.value, a);
       return {
-        createComponent: this.createComponentForStep(
-          [`step${n}`],
+        createComponent: this.createStepSpecificComponentFactory(
+          a,
           {
             isStepSpecific: !0,
-            defaultId: i,
+            defaultId: u,
             form: t
-          }
+          },
+          b
         )
       };
     });
   }
   createFormComponent(e, t) {
-    const { render: r, enabledForSteps: n = "all", id: s = t } = e, i = {
-      id: s,
-      steps: I(this.value, n)
+    const { render: r, enabledForSteps: s = "all", id: n = t } = e, a = {
+      id: n,
+      steps: N(this.value, s)
     };
-    return (y) => r(i, y);
+    return (u) => r(a, u);
   }
-  createStepSpecificComponentImpl(e, t, r, n = {}) {
-    return (s) => ((i) => {
-      const y = {};
-      for (const [O, $] of Object.entries(n))
-        if (typeof $ == "function")
+  createStepSpecificComponentImpl(e, t, r, s = {}) {
+    return (n) => ((a) => {
+      const u = {};
+      for (const [E, w] of Object.entries(s))
+        if (typeof w == "function")
           try {
-            const w = $();
-            y[O] = w, typeof console < "u" && console.debug && console.debug(
-              `[multi-step-form] Hook "${O}" called successfully`,
-              { result: w !== void 0 ? "defined" : "undefined" }
+            const T = w();
+            u[E] = T, typeof console < "u" && console.debug && console.debug(
+              `[multi-step-form] Hook "${E}" called successfully`,
+              { result: T === void 0 ? "defined" : "undefined" }
             );
-          } catch (w) {
-            const a = w instanceof Error ? w.message : String(w);
+          } catch (T) {
+            const i = T instanceof Error ? T.message : String(T);
             throw new Error(
-              `[multi-step-form] Error calling hook "${O}" in useFormInstance.render: ${a}
+              `[multi-step-form] Error calling hook "${E}" in useFormInstance.render: ${i}
 
 This usually means:
 1. The hook is being called outside of a React component
 2. The hook has invalid dependencies or configuration
 3. There's an error in your hook implementation
 
-Original error: ${a}`,
-              { cause: w }
+Original error: ${i}`,
+              { cause: T }
             );
           }
         else
-          y[O] = $;
-      const { defaultId: b, form: f } = t, { ctx: g } = r, [c] = e;
-      j(
-        this.steps.isValidStepKey(c),
-        `[createComponent]: the target step ${c} is invalid. Note, this error shouldn't appear as the target step should always be valid. If you see this error, please open an issue.`
+          u[E] = w;
+      const { defaultId: b, form: S } = t, { ctx: p } = r, [f] = e;
+      _(
+        this.steps.isValidStepKey(f),
+        `[createComponent]: the target step ${f} is invalid. Note, this error shouldn't appear as the target step should always be valid. If you see this error, please open an issue.`
       );
-      const m = Number.parseInt(c.replace("step", ""));
-      j(
-        !Number.isNaN(m),
-        `[${c}:"createComponent"]: an error occurred while extracting the number`
+      const v = Number.parseInt(f.replace("step", ""));
+      _(
+        !Number.isNaN(v),
+        `[${f}:"createComponent"]: an error occurred while extracting the number`
       );
-      const p = this.value[c];
-      j(
-        "fields" in p,
-        `[${c}:createComponent]: unable to find the "fields" for the current step`
-      ), j(
-        typeof p.fields == "object",
-        `[${c}:createComponent]: the "fields" property must be an object, was ${typeof p.fields}`
+      const y = this.value[f];
+      _(
+        "fields" in y,
+        `[${f}:createComponent]: unable to find the "fields" for the current step`
+      ), _(
+        typeof y.fields == "object",
+        `[${f}:createComponent]: the "fields" property must be an object, was ${typeof y.fields}`
       );
-      const v = Ne((O) => {
-        j(typeof O == "string", () => {
-          const d = new Intl.ListFormat("en", {
+      const m = Ie((E) => {
+        _(typeof E == "string", () => {
+          const h = new Intl.ListFormat("en", {
             style: "long",
             type: "disjunction"
           });
-          return `[${c}:Field]: the "name" prop must be a string and a valid field for ${c}. Available fields include ${d.format(
-            Object.keys(p.fields)
+          return `[${f}:Field]: the "name" prop must be a string and a valid field for ${f}. Available fields include ${h.format(
+            Object.keys(y.fields)
           )}`;
-        }), j(
-          O in p.fields,
-          `[${c}:Field]: the field "${O}" doesn't exist for the current step`
-        ), j(
-          "update" in p,
-          `[${c}:Field]: No "update" function was found`
+        }), _(
+          E in y.fields,
+          `[${f}:Field]: the field "${E}" doesn't exist for the current step`
+        ), _(
+          "update" in y,
+          `[${f}:Field]: No "update" function was found`
         );
-        const { fields: $, update: w } = p, { defaultValue: a, label: l, nameTransformCasing: h, type: u } = $[O];
+        const { fields: w, update: T } = y, { defaultValue: i, label: l, nameTransformCasing: d, type: c } = w[E];
         return {
-          defaultValue: a,
+          defaultValue: i,
           label: l,
-          nameTransformCasing: h,
-          type: u,
-          name: O,
-          onInputChange: (d) => (
+          nameTransformCasing: d,
+          type: c,
+          name: E,
+          onInputChange: (h) => (
             // TODO remove type assertions
-            w({
-              fields: [`fields.${O}.defaultValue`],
-              updater: d
+            T({
+              fields: [`fields.${E}.defaultValue`],
+              updater: h
             })
           )
         };
       });
-      let S = {
-        ctx: g,
-        onInputChange: this.createStepUpdaterFn(c),
-        Field: v,
-        ...y
+      let g = {
+        ctx: p,
+        onInputChange: this.#e.createStepUpdaterFn(f),
+        Field: m,
+        ...u
       };
-      if (f) {
+      if (S) {
         const {
-          alias: O = N.DEFAULT_FORM_ALIAS,
-          ...$
-        } = f, w = $.enabledForSteps ?? "all";
-        return N.isFormAvailable(
+          alias: E = L.DEFAULT_FORM_ALIAS,
+          ...w
+        } = S, T = w.enabledForSteps ?? "all";
+        return L.isFormAvailable(
           e,
-          w
-        ) && (S = {
-          ...S,
-          [O]: this.createFormComponent($, b)
-        }), s(S, i);
+          T
+        ) && (g = {
+          ...g,
+          [E]: this.createFormComponent(w, b)
+        }), n(g, a);
       }
-      return s(
+      return n(
         {
-          ...S,
-          [N.DEFAULT_FORM_ALIAS]: N.createDefaultForm(b)
+          ...g,
+          [L.DEFAULT_FORM_ALIAS]: L.createDefaultForm(b)
         },
-        i
+        a
       );
     });
   }
   createStepSpecificComponentFactory(e, t, r) {
-    const n = this.createStepSpecificComponentImpl.bind(this), s = this.createDefaultValues.bind(this), i = this.value;
-    function y(b, f) {
-      function g(m) {
+    const s = this.createStepSpecificComponentImpl.bind(this), n = this.createDefaultValues.bind(this);
+    debugger;
+    const a = this.value, u = e[0], b = this.#e.createStepUpdaterFn(u).bind(this.#e);
+    function S(p, f) {
+      function v(m) {
         return m ? { ctx: { ...r, ...m } } : { ctx: r };
       }
-      function c() {
-        return j(
-          typeof b == "function",
+      function y() {
+        return _(
+          typeof p == "function",
           "The first argument must be a function"
-        ), n(
+        ), s(
           e,
           t,
-          g(void 0)
-        )(b);
+          v(void 0)
+        )(p);
       }
-      if (typeof b == "object") {
-        const { useFormInstance: m, ctxData: p, debug: v } = b, S = e[0], O = new me({
-          debug: v,
-          prefix(a) {
-            return `${a}-${String(S)}-createComponent`;
+      if (typeof p == "object") {
+        const { useFormInstance: m, ctxData: g, debug: E } = p, w = new Z({
+          debug: E,
+          prefix(l) {
+            return `${l}-${u}-createComponent`;
           }
         });
-        O.info("First argument is an object");
-        const { [S]: $, ...w } = i;
-        if (j(
+        w.info("First argument is an object");
+        const { [u]: T, ...i } = a;
+        if (_(
           typeof f == "function",
           "The second argument must be a function"
         ), m) {
           const {
-            render: a,
-            alias: l = Y.DEFAULT_FORM_INSTANCE_ALIAS
-          } = m, [h] = e, u = s(h), d = p ? {
+            render: l,
+            alias: d = Y.DEFAULT_FORM_INSTANCE_ALIAS
+          } = m, [c] = e, h = n(c), O = g ? {
             ...r,
-            ...p({ ctx: w })
-          } : r, E = { ctx: d, defaultValues: u };
-          return n(
+            ...g({ ctx: i })
+          } : r, $ = { ctx: O, defaultValues: h };
+          return s(
             e,
             t,
-            d,
+            O,
             {
-              [l]: () => a(E)
+              [d]: () => l($)
             }
           )(f);
         }
-        if (p) {
-          O.info('Option "ctxData" is defined'), j(
-            typeof p == "function",
+        if (g) {
+          w.info('Option "ctxData" is defined'), _(
+            typeof g == "function",
             'Option "ctxData" must be a function'
           );
-          const a = p({ ctx: w });
-          O.info(
-            `Addition context is: ${JSON.stringify(a, null, 2)}`
+          const l = g({ ctx: i });
+          w.info(
+            `Addition context is: ${JSON.stringify(l, null, 2)}`
           );
-          const l = {
+          const d = {
             ...r,
-            ...a
+            ...l
           };
-          return O.info(
-            `Resolved context is: ${JSON.stringify(l, null, 2)}`
-          ), n(e, t, {
-            ctx: l
+          return w.info(
+            `Resolved context is: ${JSON.stringify(d, null, 2)}`
+          ), s(e, t, {
+            ctx: d,
+            update: b
           })(f);
         }
-        return c();
+        return y();
       }
-      return c();
+      return y();
     }
-    return y;
-  }
-  createComponentImpl(e, t) {
-    const r = I(
-      this.value,
-      e
-    );
-    return t.isStepSpecific ? this.createStepSpecificComponentFactory(e, t, r) : (n) => ((s) => n(r, s));
-  }
-  createComponentForStep(e, t) {
-    return this.createComponentImpl(e, t);
+    return S;
   }
   /**
    * A helper function to create a component for a specific step.
@@ -1412,39 +1466,53 @@ Original error: ${a}`,
    * @returns The created component for the step.
    */
   createComponent(e, t) {
-    return this.createComponentImpl(e.stepData, {
-      isStepSpecific: !1
-    })(t);
+    const { stepData: r } = e, s = N(
+      this.value,
+      r
+    );
+    return ((n) => t(s, n));
   }
   createDefaultValues(e) {
-    return Ie(this.value, e);
+    return De(this.value, e);
   }
 }
-class Le extends Ve {
+class Ue extends Ne {
   stepSchema;
+  #e;
   constructor(e) {
-    const { nameTransformCasing: t = X, storage: r, ...n } = e;
+    const { nameTransformCasing: t = ee, storage: r, ...s } = e;
     super({
       nameTransformCasing: t,
       storage: r,
-      ...n
-    }), this.stepSchema = new De({
+      ...s
+    }), this.stepSchema = new Me({
       nameTransformCasing: t,
-      ...n
+      ...s
+    }), this.#e = new Q({
+      getValue: () => this.stepSchema.value,
+      setValue: (n) => {
+        this.stepSchema.value = { ...n }, this.storage.add(n), this.notify();
+      }
     });
   }
   createComponent(e, t) {
-    const { stepData: r } = e, n = I(
+    const { stepData: r } = e, s = N(
       this.stepSchema.value,
       r
     );
-    return ((s) => t({ ctx: n }, s));
+    return ((n) => t(
+      {
+        ctx: s,
+        update: this.#e.createHelperFnInputUpdate(r)
+      },
+      n
+    ));
   }
 }
-function Be(o) {
-  return new Le(o);
+function Ye(o) {
+  return new Ue(o);
 }
-var D = { exports: {} }, K = {}, L = { exports: {} }, B = {};
+var I = { exports: {} }, W = {}, D = { exports: {} }, B = {};
 /**
  * @license React
  * use-sync-external-store-shim.production.js
@@ -1454,48 +1522,48 @@ var D = { exports: {} }, K = {}, L = { exports: {} }, B = {};
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-var ue;
-function Me() {
-  if (ue) return B;
-  ue = 1;
-  var o = W;
-  function e(c, m) {
-    return c === m && (c !== 0 || 1 / c === 1 / m) || c !== c && m !== m;
-  }
-  var t = typeof Object.is == "function" ? Object.is : e, r = o.useState, n = o.useEffect, s = o.useLayoutEffect, i = o.useDebugValue;
-  function y(c, m) {
-    var p = m(), v = r({ inst: { value: p, getSnapshot: m } }), S = v[0].inst, O = v[1];
-    return s(
+var le;
+function Re() {
+  if (le) return B;
+  le = 1;
+  var o = G;
+  function e(f, v) {
+    return f === v && (f !== 0 || 1 / f === 1 / v) || f !== f && v !== v;
+  }
+  var t = typeof Object.is == "function" ? Object.is : e, r = o.useState, s = o.useEffect, n = o.useLayoutEffect, a = o.useDebugValue;
+  function u(f, v) {
+    var y = v(), m = r({ inst: { value: y, getSnapshot: v } }), g = m[0].inst, E = m[1];
+    return n(
       function() {
-        S.value = p, S.getSnapshot = m, b(S) && O({ inst: S });
+        g.value = y, g.getSnapshot = v, b(g) && E({ inst: g });
       },
-      [c, p, m]
-    ), n(
+      [f, y, v]
+    ), s(
       function() {
-        return b(S) && O({ inst: S }), c(function() {
-          b(S) && O({ inst: S });
+        return b(g) && E({ inst: g }), f(function() {
+          b(g) && E({ inst: g });
         });
       },
-      [c]
-    ), i(p), p;
+      [f]
+    ), a(y), y;
   }
-  function b(c) {
-    var m = c.getSnapshot;
-    c = c.value;
+  function b(f) {
+    var v = f.getSnapshot;
+    f = f.value;
     try {
-      var p = m();
-      return !t(c, p);
+      var y = v();
+      return !t(f, y);
     } catch {
       return !0;
     }
   }
-  function f(c, m) {
-    return m();
+  function S(f, v) {
+    return v();
   }
-  var g = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? f : y;
-  return B.useSyncExternalStore = o.useSyncExternalStore !== void 0 ? o.useSyncExternalStore : g, B;
+  var p = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? S : u;
+  return B.useSyncExternalStore = o.useSyncExternalStore !== void 0 ? o.useSyncExternalStore : p, B;
 }
-var q = {};
+var J = {};
 /**
  * @license React
  * use-sync-external-store-shim.development.js
@@ -1505,62 +1573,62 @@ var q = {};
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-var ce;
-function Ue() {
-  return ce || (ce = 1, process.env.NODE_ENV !== "production" && (function() {
-    function o(p, v) {
-      return p === v && (p !== 0 || 1 / p === 1 / v) || p !== p && v !== v;
+var fe;
+function Ke() {
+  return fe || (fe = 1, process.env.NODE_ENV !== "production" && (function() {
+    function o(y, m) {
+      return y === m && (y !== 0 || 1 / y === 1 / m) || y !== y && m !== m;
     }
-    function e(p, v) {
-      g || n.startTransition === void 0 || (g = !0, console.error(
+    function e(y, m) {
+      p || s.startTransition === void 0 || (p = !0, console.error(
         "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
       ));
-      var S = v();
-      if (!c) {
-        var O = v();
-        s(S, O) || (console.error(
+      var g = m();
+      if (!f) {
+        var E = m();
+        n(g, E) || (console.error(
           "The result of getSnapshot should be cached to avoid an infinite loop"
-        ), c = !0);
+        ), f = !0);
       }
-      O = i({
-        inst: { value: S, getSnapshot: v }
+      E = a({
+        inst: { value: g, getSnapshot: m }
       });
-      var $ = O[0].inst, w = O[1];
+      var w = E[0].inst, T = E[1];
       return b(
         function() {
-          $.value = S, $.getSnapshot = v, t($) && w({ inst: $ });
+          w.value = g, w.getSnapshot = m, t(w) && T({ inst: w });
         },
-        [p, S, v]
-      ), y(
+        [y, g, m]
+      ), u(
         function() {
-          return t($) && w({ inst: $ }), p(function() {
-            t($) && w({ inst: $ });
+          return t(w) && T({ inst: w }), y(function() {
+            t(w) && T({ inst: w });
           });
         },
-        [p]
-      ), f(S), S;
+        [y]
+      ), S(g), g;
     }
-    function t(p) {
-      var v = p.getSnapshot;
-      p = p.value;
+    function t(y) {
+      var m = y.getSnapshot;
+      y = y.value;
       try {
-        var S = v();
-        return !s(p, S);
+        var g = m();
+        return !n(y, g);
       } catch {
         return !0;
       }
     }
-    function r(p, v) {
-      return v();
+    function r(y, m) {
+      return m();
     }
     typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
-    var n = W, s = typeof Object.is == "function" ? Object.is : o, i = n.useState, y = n.useEffect, b = n.useLayoutEffect, f = n.useDebugValue, g = !1, c = !1, m = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? r : e;
-    q.useSyncExternalStore = n.useSyncExternalStore !== void 0 ? n.useSyncExternalStore : m, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
-  })()), q;
+    var s = G, n = typeof Object.is == "function" ? Object.is : o, a = s.useState, u = s.useEffect, b = s.useLayoutEffect, S = s.useDebugValue, p = !1, f = !1, v = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? r : e;
+    J.useSyncExternalStore = s.useSyncExternalStore !== void 0 ? s.useSyncExternalStore : v, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })()), J;
 }
-var le;
-function je() {
-  return le || (le = 1, process.env.NODE_ENV === "production" ? L.exports = Me() : L.exports = Ue()), L.exports;
+var pe;
+function we() {
+  return pe || (pe = 1, process.env.NODE_ENV === "production" ? D.exports = Re() : D.exports = Ke()), D.exports;
 }
 /**
  * @license React
@@ -1571,56 +1639,56 @@ function je() {
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-var fe;
-function Re() {
-  if (fe) return K;
-  fe = 1;
-  var o = W, e = je();
-  function t(f, g) {
-    return f === g && (f !== 0 || 1 / f === 1 / g) || f !== f && g !== g;
-  }
-  var r = typeof Object.is == "function" ? Object.is : t, n = e.useSyncExternalStore, s = o.useRef, i = o.useEffect, y = o.useMemo, b = o.useDebugValue;
-  return K.useSyncExternalStoreWithSelector = function(f, g, c, m, p) {
-    var v = s(null);
-    if (v.current === null) {
-      var S = { hasValue: !1, value: null };
-      v.current = S;
-    } else S = v.current;
-    v = y(
+var de;
+function Ge() {
+  if (de) return W;
+  de = 1;
+  var o = G, e = we();
+  function t(S, p) {
+    return S === p && (S !== 0 || 1 / S === 1 / p) || S !== S && p !== p;
+  }
+  var r = typeof Object.is == "function" ? Object.is : t, s = e.useSyncExternalStore, n = o.useRef, a = o.useEffect, u = o.useMemo, b = o.useDebugValue;
+  return W.useSyncExternalStoreWithSelector = function(S, p, f, v, y) {
+    var m = n(null);
+    if (m.current === null) {
+      var g = { hasValue: !1, value: null };
+      m.current = g;
+    } else g = m.current;
+    m = u(
       function() {
-        function $(u) {
-          if (!w) {
-            if (w = !0, a = u, u = m(u), p !== void 0 && S.hasValue) {
-              var d = S.value;
-              if (p(d, u))
-                return l = d;
+        function w(c) {
+          if (!T) {
+            if (T = !0, i = c, c = v(c), y !== void 0 && g.hasValue) {
+              var h = g.value;
+              if (y(h, c))
+                return l = h;
             }
-            return l = u;
+            return l = c;
           }
-          if (d = l, r(a, u)) return d;
-          var E = m(u);
-          return p !== void 0 && p(d, E) ? (a = u, d) : (a = u, l = E);
+          if (h = l, r(i, c)) return h;
+          var O = v(c);
+          return y !== void 0 && y(h, O) ? (i = c, h) : (i = c, l = O);
         }
-        var w = !1, a, l, h = c === void 0 ? null : c;
+        var T = !1, i, l, d = f === void 0 ? null : f;
         return [
           function() {
-            return $(g());
+            return w(p());
           },
-          h === null ? void 0 : function() {
-            return $(h());
+          d === null ? void 0 : function() {
+            return w(d());
           }
         ];
       },
-      [g, c, m, p]
+      [p, f, v, y]
     );
-    var O = n(f, v[0], v[1]);
-    return i(
+    var E = s(S, m[0], m[1]);
+    return a(
       function() {
-        S.hasValue = !0, S.value = O;
+        g.hasValue = !0, g.value = E;
       },
-      [O]
-    ), b(O), O;
-  }, K;
+      [E]
+    ), b(E), E;
+  }, W;
 }
 var z = {};
 /**
@@ -1632,96 +1700,96 @@ var z = {};
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-var pe;
-function He() {
-  return pe || (pe = 1, process.env.NODE_ENV !== "production" && (function() {
-    function o(f, g) {
-      return f === g && (f !== 0 || 1 / f === 1 / g) || f !== f && g !== g;
+var he;
+function Pe() {
+  return he || (he = 1, process.env.NODE_ENV !== "production" && (function() {
+    function o(S, p) {
+      return S === p && (S !== 0 || 1 / S === 1 / p) || S !== S && p !== p;
     }
     typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
-    var e = W, t = je(), r = typeof Object.is == "function" ? Object.is : o, n = t.useSyncExternalStore, s = e.useRef, i = e.useEffect, y = e.useMemo, b = e.useDebugValue;
-    z.useSyncExternalStoreWithSelector = function(f, g, c, m, p) {
-      var v = s(null);
-      if (v.current === null) {
-        var S = { hasValue: !1, value: null };
-        v.current = S;
-      } else S = v.current;
-      v = y(
+    var e = G, t = we(), r = typeof Object.is == "function" ? Object.is : o, s = t.useSyncExternalStore, n = e.useRef, a = e.useEffect, u = e.useMemo, b = e.useDebugValue;
+    z.useSyncExternalStoreWithSelector = function(S, p, f, v, y) {
+      var m = n(null);
+      if (m.current === null) {
+        var g = { hasValue: !1, value: null };
+        m.current = g;
+      } else g = m.current;
+      m = u(
         function() {
-          function $(u) {
-            if (!w) {
-              if (w = !0, a = u, u = m(u), p !== void 0 && S.hasValue) {
-                var d = S.value;
-                if (p(d, u))
-                  return l = d;
+          function w(c) {
+            if (!T) {
+              if (T = !0, i = c, c = v(c), y !== void 0 && g.hasValue) {
+                var h = g.value;
+                if (y(h, c))
+                  return l = h;
               }
-              return l = u;
+              return l = c;
             }
-            if (d = l, r(a, u))
-              return d;
-            var E = m(u);
-            return p !== void 0 && p(d, E) ? (a = u, d) : (a = u, l = E);
+            if (h = l, r(i, c))
+              return h;
+            var O = v(c);
+            return y !== void 0 && y(h, O) ? (i = c, h) : (i = c, l = O);
           }
-          var w = !1, a, l, h = c === void 0 ? null : c;
+          var T = !1, i, l, d = f === void 0 ? null : f;
           return [
             function() {
-              return $(g());
+              return w(p());
             },
-            h === null ? void 0 : function() {
-              return $(h());
+            d === null ? void 0 : function() {
+              return w(d());
             }
           ];
         },
-        [g, c, m, p]
+        [p, f, v, y]
       );
-      var O = n(f, v[0], v[1]);
-      return i(
+      var E = s(S, m[0], m[1]);
+      return a(
         function() {
-          S.hasValue = !0, S.value = O;
+          g.hasValue = !0, g.value = E;
         },
-        [O]
-      ), b(O), O;
+        [E]
+      ), b(E), E;
     }, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
   })()), z;
 }
-var de;
-function We() {
-  return de || (de = 1, process.env.NODE_ENV === "production" ? D.exports = Re() : D.exports = He()), D.exports;
+var me;
+function He() {
+  return me || (me = 1, process.env.NODE_ENV === "production" ? I.exports = Ge() : I.exports = Pe()), I.exports;
 }
-var Pe = We();
-function Z(o, e) {
-  j(
+var We = He();
+function X(o, e) {
+  _(
     typeof e == "string",
     `The target step must be a string, was ${typeof e}`
   );
-  const { as: t, isValidStepNumber: r } = o.stepSchema.steps, s = new Intl.ListFormat("en", {
+  const { as: t, isValidStepNumber: r } = o.stepSchema.steps, n = new Intl.ListFormat("en", {
     type: "disjunction",
     style: "long"
   }).format(t("array.string.untyped"));
-  j(
-    ve.test(e),
-    `The target step must match the following format: "step{number}". Available steps are ${s}`
+  _(
+    _e.test(e),
+    `The target step must match the following format: "step{number}". Available steps are ${n}`
   );
-  const i = Number.parseInt(e.replace("step", ""));
-  return j(
-    r(i),
-    `The step number "${i}" is not a valid step number. Valid step numbers include ${s}`,
+  const a = Number.parseInt(e.replace("step", ""));
+  return _(
+    r(a),
+    `The step number "${a}" is not a valid step number. Valid step numbers include ${n}`,
     TypeError
-  ), i;
+  ), a;
 }
-function Ee(o) {
+function $e(o) {
   function e(t) {
-    return Pe.useSyncExternalStoreWithSelector(
+    return We.useSyncExternalStoreWithSelector(
       o.subscribe,
       () => o.getSnapshot(),
       () => o.getSnapshot(),
       (r) => {
         if (typeof t == "object") {
-          const n = Z(
+          const s = X(
             r,
             t.targetStep
           );
-          return r.stepSchema.get({ step: n }).data;
+          return r.stepSchema.get({ step: s }).data;
         }
         return typeof t == "function" ? t(r) : r;
       }
@@ -1729,88 +1797,88 @@ function Ee(o) {
   }
   return e;
 }
-function qe(o, e) {
-  const t = Ee(o);
+function Xe(o, e) {
+  const t = $e(o);
   return typeof e == "object" || typeof e == "function" ? t(e) : t();
 }
-function he(o) {
+function ye(o) {
   return function(e) {
     return ((t) => e(o, t));
   };
 }
-function ze(o) {
-  const e = Ee(o);
-  function t(y) {
-    const { targetStep: b, notFoundMessage: f, isDataGuaranteed: g } = y, c = e({
+function Ze(o) {
+  const e = $e(o);
+  function t(u) {
+    const { targetStep: b, notFoundMessage: S, isDataGuaranteed: p } = u, f = e({
       targetStep: b
-    }), m = f ? i({ targetStep: b }, f) : (p) => /* @__PURE__ */ te("div", { ...p, children: [
+    }), v = S ? a({ targetStep: b }, S) : (y) => /* @__PURE__ */ ne("div", { ...y, children: [
       "No data found for step ",
       String(b)
     ] });
-    return g ? {
-      data: c,
-      NoCurrentData: m
-    } : ee.hasData(c) ? {
-      data: c,
+    return p ? {
+      data: f,
+      NoCurrentData: v
+    } : re.hasData(f) ? {
+      data: f,
       hasData: !0,
-      NoCurrentData: m
+      NoCurrentData: v
     } : {
       data: void 0,
       hasData: !1,
-      NoCurrentData: m
+      NoCurrentData: v
     };
   }
-  function r(y) {
+  function r(u) {
     const b = e(
-      (O) => O.stepSchema.steps.value.length
+      (E) => E.stepSchema.steps.value.length
     ), {
-      targetStep: f,
-      maxProgressValue: g = 100,
-      totalSteps: c = b,
-      progressTextTransformer: m
-    } = y, p = Z(o, f), v = p / c * g, S = m ? s(
-      { targetStep: f, maxProgressValue: g, totalSteps: c },
-      m
-    ) : (O) => /* @__PURE__ */ te("div", { ...O, children: [
+      targetStep: S,
+      maxProgressValue: p = 100,
+      totalSteps: f = b,
+      progressTextTransformer: v
+    } = u, y = X(o, S), m = y / f * p, g = v ? n(
+      { targetStep: S, maxProgressValue: p, totalSteps: f },
+      v
+    ) : (E) => /* @__PURE__ */ ne("div", { ...E, children: [
       "Step ",
-      p,
+      y,
       "/",
-      c
+      f
     ] });
     return {
-      value: v,
-      maxProgressValue: g,
-      ProgressText: S
+      value: m,
+      maxProgressValue: p,
+      ProgressText: g
     };
   }
-  function n(y) {
-    const f = e((c) => c.storage).get(), g = !!(f && typeof f == "object" && Object.keys(f).length > 0);
-    return y ? y(g) : g;
+  function s(u) {
+    const S = e((f) => f.storage).get(), p = !!(S && typeof S == "object" && Object.keys(S).length > 0);
+    return u ? u(p) : p;
   }
-  function s(y, b) {
-    const f = o.getSnapshot().stepSchema.steps.value.length, { targetStep: g, maxProgressValue: c = 100, totalSteps: m = f } = y;
-    return he({ targetStep: g, maxProgressValue: c, totalSteps: m })(b);
+  function n(u, b) {
+    const S = o.getSnapshot().stepSchema.steps.value.length, { targetStep: p, maxProgressValue: f = 100, totalSteps: v = S } = u;
+    return ye({ targetStep: p, maxProgressValue: f, totalSteps: v })(b);
   }
-  function i(y, b) {
-    return Z(o, y.targetStep), he(y)(b);
+  function a(u, b) {
+    return X(o, u.targetStep), ye(u)(b);
   }
   return {
     // MultiStepFormContext: Context,
     useMultiStepFormData: e,
     useCurrentStepData: t,
     useProgress: r,
-    useCanRestartForm: n,
-    withProgressText: s,
-    withNoStepDataFound: i
+    useCanRestartForm: s,
+    withProgressText: n,
+    withNoStepDataFound: a
   };
 }
 export {
-  Le as MultiStepFormSchema,
-  De as MultiStepFormStepSchema,
+  Ue as MultiStepFormSchema,
+  Me as MultiStepFormStepSchema,
   Y as StepSpecificComponent,
-  Ie as createDefaultValues,
-  ze as createMultiStepFormContext,
-  Be as createMultiStepFormSchema,
-  qe as useMultiStepFormData
+  De as createDefaultValues,
+  Ze as createMultiStepFormContext,
+  Ye as createMultiStepFormSchema,
+  Xe as useMultiStepFormData
 };
 //# sourceMappingURL=index.mjs.map