@d1os/simple-wizard 1.0.0

package/dist/simple-wizard.js

@@ -0,0 +1,855 @@
+import { jsx as R, jsxs as ue } from "react/jsx-runtime";
+import b, { createContext as fe, useContext as le, useRef as de, useEffect as _e, useMemo as pe, Children as ye, isValidElement as he } from "react";
+const H = (e) => {
+  let t;
+  const r = /* @__PURE__ */ new Set(), n = (o, l) => {
+    const p = typeof o == "function" ? o(t) : o;
+    if (!Object.is(p, t)) {
+      const x = t;
+      t = l ?? (typeof p != "object" || p === null) ? p : Object.assign({}, t, p), r.forEach((G) => G(t, x));
+    }
+  }, i = () => t, a = { setState: n, getState: i, getInitialState: () => s, subscribe: (o) => (r.add(o), () => r.delete(o)) }, s = t = e(n, i, a);
+  return a;
+}, me = ((e) => e ? H(e) : H), Se = (e) => e;
+function be(e, t = Se) {
+  const r = b.useSyncExternalStore(
+    e.subscribe,
+    b.useCallback(() => t(e.getState()), [e, t]),
+    b.useCallback(() => t(e.getInitialState()), [e, t])
+  );
+  return b.useDebugValue(r), r;
+}
+var re = Symbol.for("immer-nothing"), J = Symbol.for("immer-draftable"), f = Symbol.for("immer-state"), ge = process.env.NODE_ENV !== "production" ? [
+  // All error codes, starting by 0:
+  function(e) {
+    return `The plugin for '${e}' has not been loaded into Immer. To enable the plugin, import and call \`enable${e}()\` when initializing your application.`;
+  },
+  function(e) {
+    return `produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '${e}'`;
+  },
+  "This object has been frozen and should not be mutated",
+  function(e) {
+    return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + e;
+  },
+  "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.",
+  "Immer forbids circular references",
+  "The first or second argument to `produce` must be a function",
+  "The third argument to `produce` must be a function or undefined",
+  "First argument to `createDraft` must be a plain object, an array, or an immerable object",
+  "First argument to `finishDraft` must be a draft returned by `createDraft`",
+  function(e) {
+    return `'current' expects a draft, got: ${e}`;
+  },
+  "Object.defineProperty() cannot be used on an Immer draft",
+  "Object.setPrototypeOf() cannot be used on an Immer draft",
+  "Immer only supports deleting array indices",
+  "Immer only supports setting array indices and the 'length' property",
+  function(e) {
+    return `'original' expects a draft, got: ${e}`;
+  }
+  // Note: if more errors are added, the errorOffset in Patches.ts should be increased
+  // See Patches.ts for additional errors
+] : [];
+function _(e, ...t) {
+  if (process.env.NODE_ENV !== "production") {
+    const r = ge[e], n = typeof r == "function" ? r.apply(null, t) : r;
+    throw new Error(`[Immer] ${n}`);
+  }
+  throw new Error(
+    `[Immer] minified error nr: ${e}. Full error at: https://bit.ly/3cXEKWf`
+  );
+}
+var g = Object.getPrototypeOf;
+function S(e) {
+  return !!e && !!e[f];
+}
+function h(e) {
+  var t;
+  return e ? ne(e) || Array.isArray(e) || !!e[J] || !!((t = e.constructor) != null && t[J]) || O(e) || N(e) : !1;
+}
+var Pe = Object.prototype.constructor.toString(), X = /* @__PURE__ */ new WeakMap();
+function ne(e) {
+  if (!e || typeof e != "object")
+    return !1;
+  const t = Object.getPrototypeOf(e);
+  if (t === null || t === Object.prototype)
+    return !0;
+  const r = Object.hasOwnProperty.call(t, "constructor") && t.constructor;
+  if (r === Object)
+    return !0;
+  if (typeof r != "function")
+    return !1;
+  let n = X.get(r);
+  return n === void 0 && (n = Function.toString.call(r), X.set(r, n)), n === Pe;
+}
+function P(e, t, r = !0) {
+  A(e) === 0 ? (r ? Reflect.ownKeys(e) : Object.keys(e)).forEach((i) => {
+    t(i, e[i], e);
+  }) : e.forEach((n, i) => t(i, n, e));
+}
+function A(e) {
+  const t = e[f];
+  return t ? t.type_ : Array.isArray(e) ? 1 : O(e) ? 2 : N(e) ? 3 : 0;
+}
+function T(e, t) {
+  return A(e) === 2 ? e.has(t) : Object.prototype.hasOwnProperty.call(e, t);
+}
+function ie(e, t, r) {
+  const n = A(e);
+  n === 2 ? e.set(t, r) : n === 3 ? e.add(r) : e[t] = r;
+}
+function we(e, t) {
+  return e === t ? e !== 0 || 1 / e === 1 / t : e !== e && t !== t;
+}
+function O(e) {
+  return e instanceof Map;
+}
+function N(e) {
+  return e instanceof Set;
+}
+function d(e) {
+  return e.copy_ || e.base_;
+}
+function W(e, t) {
+  if (O(e))
+    return new Map(e);
+  if (N(e))
+    return new Set(e);
+  if (Array.isArray(e))
+    return Array.prototype.slice.call(e);
+  const r = ne(e);
+  if (t === !0 || t === "class_only" && !r) {
+    const n = Object.getOwnPropertyDescriptors(e);
+    delete n[f];
+    let i = Reflect.ownKeys(n);
+    for (let c = 0; c < i.length; c++) {
+      const u = i[c], a = n[u];
+      a.writable === !1 && (a.writable = !0, a.configurable = !0), (a.get || a.set) && (n[u] = {
+        configurable: !0,
+        writable: !0,
+        // could live with !!desc.set as well here...
+        enumerable: a.enumerable,
+        value: e[u]
+      });
+    }
+    return Object.create(g(e), n);
+  } else {
+    const n = g(e);
+    if (n !== null && r)
+      return { ...e };
+    const i = Object.create(n);
+    return Object.assign(i, e);
+  }
+}
+function K(e, t = !1) {
+  return F(e) || S(e) || !h(e) || (A(e) > 1 && Object.defineProperties(e, {
+    set: E,
+    add: E,
+    clear: E,
+    delete: E
+  }), Object.freeze(e), t && Object.values(e).forEach((r) => K(r, !0))), e;
+}
+function ve() {
+  _(2);
+}
+var E = {
+  value: ve
+};
+function F(e) {
+  return e === null || typeof e != "object" ? !0 : Object.isFrozen(e);
+}
+var U = {};
+function m(e) {
+  const t = U[e];
+  return t || _(0, e), t;
+}
+function ze(e, t) {
+  U[e] || (U[e] = t);
+}
+var w;
+function I() {
+  return w;
+}
+function Oe(e, t) {
+  return {
+    drafts_: [],
+    parent_: e,
+    immer_: t,
+    // Whenever the modified draft contains a draft from another scope, we
+    // need to prevent auto-freezing so the unowned draft can be finalized.
+    canAutoFreeze_: !0,
+    unfinalizedDrafts_: 0
+  };
+}
+function q(e, t) {
+  t && (m("Patches"), e.patches_ = [], e.inversePatches_ = [], e.patchListener_ = t);
+}
+function L(e) {
+  $(e), e.drafts_.forEach(xe), e.drafts_ = null;
+}
+function $(e) {
+  e === w && (w = e.parent_);
+}
+function Q(e) {
+  return w = Oe(w, e);
+}
+function xe(e) {
+  const t = e[f];
+  t.type_ === 0 || t.type_ === 1 ? t.revoke_() : t.revoked_ = !0;
+}
+function Y(e, t) {
+  t.unfinalizedDrafts_ = t.drafts_.length;
+  const r = t.drafts_[0];
+  return e !== void 0 && e !== r ? (r[f].modified_ && (L(t), _(4)), h(e) && (e = D(t, e), t.parent_ || M(t, e)), t.patches_ && m("Patches").generateReplacementPatches_(
+    r[f].base_,
+    e,
+    t.patches_,
+    t.inversePatches_
+  )) : e = D(t, r, []), L(t), t.patches_ && t.patchListener_(t.patches_, t.inversePatches_), e !== re ? e : void 0;
+}
+function D(e, t, r) {
+  if (F(t))
+    return t;
+  const n = e.immer_.shouldUseStrictIteration(), i = t[f];
+  if (!i)
+    return P(
+      t,
+      (c, u) => Z(e, i, t, c, u, r),
+      n
+    ), t;
+  if (i.scope_ !== e)
+    return t;
+  if (!i.modified_)
+    return M(e, i.base_, !0), i.base_;
+  if (!i.finalized_) {
+    i.finalized_ = !0, i.scope_.unfinalizedDrafts_--;
+    const c = i.copy_;
+    let u = c, a = !1;
+    i.type_ === 3 && (u = new Set(c), c.clear(), a = !0), P(
+      u,
+      (s, o) => Z(
+        e,
+        i,
+        c,
+        s,
+        o,
+        r,
+        a
+      ),
+      n
+    ), M(e, c, !1), r && e.patches_ && m("Patches").generatePatches_(
+      i,
+      r,
+      e.patches_,
+      e.inversePatches_
+    );
+  }
+  return i.copy_;
+}
+function Z(e, t, r, n, i, c, u) {
+  if (i == null || typeof i != "object" && !u)
+    return;
+  const a = F(i);
+  if (!(a && !u)) {
+    if (process.env.NODE_ENV !== "production" && i === r && _(5), S(i)) {
+      const s = c && t && t.type_ !== 3 && // Set objects are atomic since they have no keys.
+      !T(t.assigned_, n) ? c.concat(n) : void 0, o = D(e, i, s);
+      if (ie(r, n, o), S(o))
+        e.canAutoFreeze_ = !1;
+      else
+        return;
+    } else u && r.add(i);
+    if (h(i) && !a) {
+      if (!e.immer_.autoFreeze_ && e.unfinalizedDrafts_ < 1 || t && t.base_ && t.base_[n] === i && a)
+        return;
+      D(e, i), (!t || !t.scope_.parent_) && typeof n != "symbol" && (O(r) ? r.has(n) : Object.prototype.propertyIsEnumerable.call(r, n)) && M(e, i);
+    }
+  }
+}
+function M(e, t, r = !1) {
+  !e.parent_ && e.immer_.autoFreeze_ && e.canAutoFreeze_ && K(t, r);
+}
+function Ee(e, t) {
+  const r = Array.isArray(e), n = {
+    type_: r ? 1 : 0,
+    // Track which produce call this is associated with.
+    scope_: t ? t.scope_ : I(),
+    // True for both shallow and deep changes.
+    modified_: !1,
+    // Used during finalization.
+    finalized_: !1,
+    // Track which properties have been assigned (true) or deleted (false).
+    assigned_: {},
+    // The parent draft state.
+    parent_: t,
+    // The base state.
+    base_: e,
+    // The base proxy.
+    draft_: null,
+    // set below
+    // The base copy with any updated values.
+    copy_: null,
+    // Called by the `produce` function.
+    revoke_: null,
+    isManual_: !1
+  };
+  let i = n, c = B;
+  r && (i = [n], c = v);
+  const { revoke: u, proxy: a } = Proxy.revocable(i, c);
+  return n.draft_ = a, n.revoke_ = u, a;
+}
+var B = {
+  get(e, t) {
+    if (t === f)
+      return e;
+    const r = d(e);
+    if (!T(r, t))
+      return Ce(e, r, t);
+    const n = r[t];
+    return e.finalized_ || !h(n) ? n : n === j(e.base_, t) ? (k(e), e.copy_[t] = z(n, e)) : n;
+  },
+  has(e, t) {
+    return t in d(e);
+  },
+  ownKeys(e) {
+    return Reflect.ownKeys(d(e));
+  },
+  set(e, t, r) {
+    const n = se(d(e), t);
+    if (n != null && n.set)
+      return n.set.call(e.draft_, r), !0;
+    if (!e.modified_) {
+      const i = j(d(e), t), c = i == null ? void 0 : i[f];
+      if (c && c.base_ === r)
+        return e.copy_[t] = r, e.assigned_[t] = !1, !0;
+      if (we(r, i) && (r !== void 0 || T(e.base_, t)))
+        return !0;
+      k(e), y(e);
+    }
+    return e.copy_[t] === r && // special case: handle new props with value 'undefined'
+    (r !== void 0 || t in e.copy_) || // special case: NaN
+    Number.isNaN(r) && Number.isNaN(e.copy_[t]) || (e.copy_[t] = r, e.assigned_[t] = !0), !0;
+  },
+  deleteProperty(e, t) {
+    return j(e.base_, t) !== void 0 || t in e.base_ ? (e.assigned_[t] = !1, k(e), y(e)) : delete e.assigned_[t], e.copy_ && delete e.copy_[t], !0;
+  },
+  // Note: We never coerce `desc.value` into an Immer draft, because we can't make
+  // the same guarantee in ES5 mode.
+  getOwnPropertyDescriptor(e, t) {
+    const r = d(e), n = Reflect.getOwnPropertyDescriptor(r, t);
+    return n && {
+      writable: !0,
+      configurable: e.type_ !== 1 || t !== "length",
+      enumerable: n.enumerable,
+      value: r[t]
+    };
+  },
+  defineProperty() {
+    _(11);
+  },
+  getPrototypeOf(e) {
+    return g(e.base_);
+  },
+  setPrototypeOf() {
+    _(12);
+  }
+}, v = {};
+P(B, (e, t) => {
+  v[e] = function() {
+    return arguments[0] = arguments[0][0], t.apply(this, arguments);
+  };
+});
+v.deleteProperty = function(e, t) {
+  return process.env.NODE_ENV !== "production" && isNaN(parseInt(t)) && _(13), v.set.call(this, e, t, void 0);
+};
+v.set = function(e, t, r) {
+  return process.env.NODE_ENV !== "production" && t !== "length" && isNaN(parseInt(t)) && _(14), B.set.call(this, e[0], t, r, e[0]);
+};
+function j(e, t) {
+  const r = e[f];
+  return (r ? d(r) : e)[t];
+}
+function Ce(e, t, r) {
+  var i;
+  const n = se(t, r);
+  return n ? "value" in n ? n.value : (
+    // This is a very special case, if the prop is a getter defined by the
+    // prototype, we should invoke it with the draft as context!
+    (i = n.get) == null ? void 0 : i.call(e.draft_)
+  ) : void 0;
+}
+function se(e, t) {
+  if (!(t in e))
+    return;
+  let r = g(e);
+  for (; r; ) {
+    const n = Object.getOwnPropertyDescriptor(r, t);
+    if (n)
+      return n;
+    r = g(r);
+  }
+}
+function y(e) {
+  e.modified_ || (e.modified_ = !0, e.parent_ && y(e.parent_));
+}
+function k(e) {
+  e.copy_ || (e.copy_ = W(
+    e.base_,
+    e.scope_.immer_.useStrictShallowCopy_
+  ));
+}
+var Ie = class {
+  constructor(e) {
+    this.autoFreeze_ = !0, this.useStrictShallowCopy_ = !1, this.useStrictIteration_ = !0, this.produce = (t, r, n) => {
+      if (typeof t == "function" && typeof r != "function") {
+        const c = r;
+        r = t;
+        const u = this;
+        return function(s = c, ...o) {
+          return u.produce(s, (l) => r.call(this, l, ...o));
+        };
+      }
+      typeof r != "function" && _(6), n !== void 0 && typeof n != "function" && _(7);
+      let i;
+      if (h(t)) {
+        const c = Q(this), u = z(t, void 0);
+        let a = !0;
+        try {
+          i = r(u), a = !1;
+        } finally {
+          a ? L(c) : $(c);
+        }
+        return q(c, n), Y(i, c);
+      } else if (!t || typeof t != "object") {
+        if (i = r(t), i === void 0 && (i = t), i === re && (i = void 0), this.autoFreeze_ && K(i, !0), n) {
+          const c = [], u = [];
+          m("Patches").generateReplacementPatches_(t, i, c, u), n(c, u);
+        }
+        return i;
+      } else
+        _(1, t);
+    }, this.produceWithPatches = (t, r) => {
+      if (typeof t == "function")
+        return (u, ...a) => this.produceWithPatches(u, (s) => t(s, ...a));
+      let n, i;
+      return [this.produce(t, r, (u, a) => {
+        n = u, i = a;
+      }), n, i];
+    }, typeof (e == null ? void 0 : e.autoFreeze) == "boolean" && this.setAutoFreeze(e.autoFreeze), typeof (e == null ? void 0 : e.useStrictShallowCopy) == "boolean" && this.setUseStrictShallowCopy(e.useStrictShallowCopy), typeof (e == null ? void 0 : e.useStrictIteration) == "boolean" && this.setUseStrictIteration(e.useStrictIteration);
+  }
+  createDraft(e) {
+    h(e) || _(8), S(e) && (e = De(e));
+    const t = Q(this), r = z(e, void 0);
+    return r[f].isManual_ = !0, $(t), r;
+  }
+  finishDraft(e, t) {
+    const r = e && e[f];
+    (!r || !r.isManual_) && _(9);
+    const { scope_: n } = r;
+    return q(n, t), Y(void 0, n);
+  }
+  /**
+   * Pass true to automatically freeze all copies created by Immer.
+   *
+   * By default, auto-freezing is enabled.
+   */
+  setAutoFreeze(e) {
+    this.autoFreeze_ = e;
+  }
+  /**
+   * Pass true to enable strict shallow copy.
+   *
+   * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
+   */
+  setUseStrictShallowCopy(e) {
+    this.useStrictShallowCopy_ = e;
+  }
+  /**
+   * Pass false to use faster iteration that skips non-enumerable properties
+   * but still handles symbols for compatibility.
+   *
+   * By default, strict iteration is enabled (includes all own properties).
+   */
+  setUseStrictIteration(e) {
+    this.useStrictIteration_ = e;
+  }
+  shouldUseStrictIteration() {
+    return this.useStrictIteration_;
+  }
+  applyPatches(e, t) {
+    let r;
+    for (r = t.length - 1; r >= 0; r--) {
+      const i = t[r];
+      if (i.path.length === 0 && i.op === "replace") {
+        e = i.value;
+        break;
+      }
+    }
+    r > -1 && (t = t.slice(r + 1));
+    const n = m("Patches").applyPatches_;
+    return S(e) ? n(e, t) : this.produce(
+      e,
+      (i) => n(i, t)
+    );
+  }
+};
+function z(e, t) {
+  const r = O(e) ? m("MapSet").proxyMap_(e, t) : N(e) ? m("MapSet").proxySet_(e, t) : Ee(e, t);
+  return (t ? t.scope_ : I()).drafts_.push(r), r;
+}
+function De(e) {
+  return S(e) || _(10, e), oe(e);
+}
+function oe(e) {
+  if (!h(e) || F(e))
+    return e;
+  const t = e[f];
+  let r, n = !0;
+  if (t) {
+    if (!t.modified_)
+      return t.base_;
+    t.finalized_ = !0, r = W(e, t.scope_.immer_.useStrictShallowCopy_), n = t.scope_.immer_.shouldUseStrictIteration();
+  } else
+    r = W(e, !0);
+  return P(
+    r,
+    (i, c) => {
+      ie(r, i, oe(c));
+    },
+    n
+  ), t && (t.finalized_ = !1), r;
+}
+function Me() {
+  class e extends Map {
+    constructor(s, o) {
+      super(), this[f] = {
+        type_: 2,
+        parent_: o,
+        scope_: o ? o.scope_ : I(),
+        modified_: !1,
+        finalized_: !1,
+        copy_: void 0,
+        assigned_: void 0,
+        base_: s,
+        draft_: this,
+        isManual_: !1,
+        revoked_: !1
+      };
+    }
+    get size() {
+      return d(this[f]).size;
+    }
+    has(s) {
+      return d(this[f]).has(s);
+    }
+    set(s, o) {
+      const l = this[f];
+      return u(l), (!d(l).has(s) || d(l).get(s) !== o) && (r(l), y(l), l.assigned_.set(s, !0), l.copy_.set(s, o), l.assigned_.set(s, !0)), this;
+    }
+    delete(s) {
+      if (!this.has(s))
+        return !1;
+      const o = this[f];
+      return u(o), r(o), y(o), o.base_.has(s) ? o.assigned_.set(s, !1) : o.assigned_.delete(s), o.copy_.delete(s), !0;
+    }
+    clear() {
+      const s = this[f];
+      u(s), d(s).size && (r(s), y(s), s.assigned_ = /* @__PURE__ */ new Map(), P(s.base_, (o) => {
+        s.assigned_.set(o, !1);
+      }), s.copy_.clear());
+    }
+    forEach(s, o) {
+      const l = this[f];
+      d(l).forEach((p, x, G) => {
+        s.call(o, this.get(x), x, this);
+      });
+    }
+    get(s) {
+      const o = this[f];
+      u(o);
+      const l = d(o).get(s);
+      if (o.finalized_ || !h(l) || l !== o.base_.get(s))
+        return l;
+      const p = z(l, o);
+      return r(o), o.copy_.set(s, p), p;
+    }
+    keys() {
+      return d(this[f]).keys();
+    }
+    values() {
+      const s = this.keys();
+      return {
+        [Symbol.iterator]: () => this.values(),
+        next: () => {
+          const o = s.next();
+          return o.done ? o : {
+            done: !1,
+            value: this.get(o.value)
+          };
+        }
+      };
+    }
+    entries() {
+      const s = this.keys();
+      return {
+        [Symbol.iterator]: () => this.entries(),
+        next: () => {
+          const o = s.next();
+          if (o.done)
+            return o;
+          const l = this.get(o.value);
+          return {
+            done: !1,
+            value: [o.value, l]
+          };
+        }
+      };
+    }
+    [Symbol.iterator]() {
+      return this.entries();
+    }
+  }
+  function t(a, s) {
+    return new e(a, s);
+  }
+  function r(a) {
+    a.copy_ || (a.assigned_ = /* @__PURE__ */ new Map(), a.copy_ = new Map(a.base_));
+  }
+  class n extends Set {
+    constructor(s, o) {
+      super(), this[f] = {
+        type_: 3,
+        parent_: o,
+        scope_: o ? o.scope_ : I(),
+        modified_: !1,
+        finalized_: !1,
+        copy_: void 0,
+        base_: s,
+        draft_: this,
+        drafts_: /* @__PURE__ */ new Map(),
+        revoked_: !1,
+        isManual_: !1
+      };
+    }
+    get size() {
+      return d(this[f]).size;
+    }
+    has(s) {
+      const o = this[f];
+      return u(o), o.copy_ ? !!(o.copy_.has(s) || o.drafts_.has(s) && o.copy_.has(o.drafts_.get(s))) : o.base_.has(s);
+    }
+    add(s) {
+      const o = this[f];
+      return u(o), this.has(s) || (c(o), y(o), o.copy_.add(s)), this;
+    }
+    delete(s) {
+      if (!this.has(s))
+        return !1;
+      const o = this[f];
+      return u(o), c(o), y(o), o.copy_.delete(s) || (o.drafts_.has(s) ? o.copy_.delete(o.drafts_.get(s)) : (
+        /* istanbul ignore next */
+        !1
+      ));
+    }
+    clear() {
+      const s = this[f];
+      u(s), d(s).size && (c(s), y(s), s.copy_.clear());
+    }
+    values() {
+      const s = this[f];
+      return u(s), c(s), s.copy_.values();
+    }
+    entries() {
+      const s = this[f];
+      return u(s), c(s), s.copy_.entries();
+    }
+    keys() {
+      return this.values();
+    }
+    [Symbol.iterator]() {
+      return this.values();
+    }
+    forEach(s, o) {
+      const l = this.values();
+      let p = l.next();
+      for (; !p.done; )
+        s.call(o, p.value, p.value, this), p = l.next();
+    }
+  }
+  function i(a, s) {
+    return new n(a, s);
+  }
+  function c(a) {
+    a.copy_ || (a.copy_ = /* @__PURE__ */ new Set(), a.base_.forEach((s) => {
+      if (h(s)) {
+        const o = z(s, a);
+        a.drafts_.set(s, o), a.copy_.add(o);
+      } else
+        a.copy_.add(s);
+    }));
+  }
+  function u(a) {
+    a.revoked_ && _(3, JSON.stringify(d(a)));
+  }
+  ze("MapSet", { proxyMap_: t, proxySet_: i });
+}
+var Ae = new Ie(), Ne = Ae.produce;
+const Fe = (e) => (t, r, n) => (n.setState = (i, c, ...u) => {
+  const a = typeof i == "function" ? Ne(i) : i;
+  return t(a, c, ...u);
+}, e(n.setState, r, n)), je = Fe, C = () => {
+};
+function ke(e) {
+  return e instanceof Promise;
+}
+const Re = (e, t) => ({
+  activeStep: 0,
+  stepCount: 0,
+  isLoading: !1,
+  nextButtonLabel: "Next",
+  previousButtonLabel: "Back",
+  isNextButtonDisabled: !1,
+  stepAction: C,
+  nextStep: (r = 1) => {
+    const n = t();
+    if (n.activeStep < n.stepCount - r) {
+      const i = n.stepAction();
+      ke(i) ? (e({ isLoading: !0 }), i.then(() => {
+        e((c) => {
+          c.activeStep += r, c.stepAction = C;
+        });
+      }).catch((c) => {
+        console.error("Error in stepAction:", c);
+      }).finally(() => {
+        e({ isLoading: !1 });
+      })) : e((c) => {
+        c.activeStep += r, c.stepAction = C;
+      });
+    }
+  },
+  previousStep: (r = 1) => e((n) => {
+    n.activeStep - r >= 0 && (n.stepAction = C, n.activeStep -= r);
+  }),
+  setStepAction: (r) => {
+    e((n) => {
+      n.stepAction = r;
+    });
+  },
+  setIsLoading: (r) => e({ isLoading: r }),
+  setActiveStep: (r) => e({ activeStep: r }),
+  setStepCount: (r) => e({ stepCount: r }),
+  setNextButtonLabel: (r) => e({ nextButtonLabel: r }),
+  setPreviousButtonLabel: (r) => e({ previousButtonLabel: r }),
+  setNextButtonDisabled: (r) => e({ isNextButtonDisabled: r })
+}), Te = (e = {}) => me(
+  je((...t) => ({
+    ...Re(...t),
+    ...e
+  }))
+), V = (e) => Symbol.iterator in e, ee = (e) => (
+  // HACK: avoid checking entries type
+  "entries" in e
+), te = (e, t) => {
+  const r = e instanceof Map ? e : new Map(e.entries()), n = t instanceof Map ? t : new Map(t.entries());
+  if (r.size !== n.size)
+    return !1;
+  for (const [i, c] of r)
+    if (!n.has(i) || !Object.is(c, n.get(i)))
+      return !1;
+  return !0;
+}, We = (e, t) => {
+  const r = e[Symbol.iterator](), n = t[Symbol.iterator]();
+  let i = r.next(), c = n.next();
+  for (; !i.done && !c.done; ) {
+    if (!Object.is(i.value, c.value))
+      return !1;
+    i = r.next(), c = n.next();
+  }
+  return !!i.done && !!c.done;
+};
+function Ue(e, t) {
+  return Object.is(e, t) ? !0 : typeof e != "object" || e === null || typeof t != "object" || t === null || Object.getPrototypeOf(e) !== Object.getPrototypeOf(t) ? !1 : V(e) && V(t) ? ee(e) && ee(t) ? te(e, t) : We(e, t) : te(
+    { entries: () => Object.entries(e) },
+    { entries: () => Object.entries(t) }
+  );
+}
+function Le(e) {
+  const t = b.useRef(void 0);
+  return (r) => {
+    const n = e(r);
+    return Ue(t.current, n) ? t.current : t.current = n;
+  };
+}
+const ce = fe(void 0), $e = ({
+  children: e,
+  config: t
+}) => {
+  const r = de();
+  return r.current || (r.current = Te(t)), /* @__PURE__ */ R(ce.Provider, { value: r.current, children: e });
+}, ae = (e) => {
+  const t = le(ce);
+  if (!t)
+    throw new Error("useWizard must be used within a WizardProvider");
+  return be(
+    t,
+    Le((r) => {
+      const n = {
+        ...r,
+        isFirstStep: r.activeStep === 0,
+        isLastStep: r.activeStep >= r.stepCount - 1
+      };
+      return e(n);
+    })
+  );
+}, Ke = ({ stepCount: e }) => {
+  const { currentStepCount: t, setStepCount: r, activeStep: n, setActiveStep: i } = ae((c) => ({
+    currentStepCount: c.stepCount,
+    setStepCount: c.setStepCount,
+    activeStep: c.activeStep,
+    setActiveStep: c.setActiveStep
+  }));
+  return _e(() => {
+    e !== t && (r(e), n >= e && i(Math.max(0, e - 1)));
+  }, [e, t, r, n, i]), null;
+}, Be = ({ steps: e }) => {
+  const { activeStep: t } = ae(
+    (r) => ({
+      activeStep: r.activeStep
+    })
+  );
+  return e[t] ?? null;
+};
+Me();
+function Je({
+  header: e = null,
+  footer: t = null,
+  children: r,
+  startAtEnd: n = !1,
+  initialStep: i = 0
+}) {
+  const c = pe(() => ye.toArray(r).filter((a) => {
+    var s;
+    return !(a === null || he(a) && ((s = a.props) != null && s.skip));
+  }), [r]), u = c.length;
+  return /* @__PURE__ */ ue(
+    $e,
+    {
+      config: {
+        activeStep: n ? u - 1 : i,
+        stepCount: u
+      },
+      children: [
+        /* @__PURE__ */ R(Ke, { stepCount: u }),
+        e,
+        /* @__PURE__ */ R(Be, { steps: c }),
+        t
+      ]
+    }
+  );
+}
+export {
+  Je as Wizard,
+  ce as WizardContext,
+  ae as useWizard
+};
+//# sourceMappingURL=simple-wizard.js.map