mada-design-system 0.0.9

package/index.es128.js

@@ -0,0 +1,4 @@
+var M = /* @__PURE__ */ ((Y) => (Y.ArShort = "DD MMMM YYYY", Y.EnShort = "MMM DD, YYYY", Y))(M || {});
+export {
+  M as DateFormat
+};

package/index.es129.js

@@ -0,0 +1,13 @@
+import { createTailwindMerge as e } from "./index.es186.js";
+import { getDefaultConfig as m } from "./index.es189.js";
+import { mergeConfigs as n } from "./index.es192.js";
+function f(t) {
+  for (var o = arguments.length, a = new Array(o > 1 ? o - 1 : 0), r = 1; r < o; r++)
+    a[r - 1] = arguments[r];
+  return typeof t == "function" ? e.apply(void 0, [m, t].concat(a)) : e.apply(void 0, [function() {
+    return n(m(), t);
+  }].concat(a));
+}
+export {
+  f as extendTailwindMerge
+};

package/index.es13.js

@@ -0,0 +1,43 @@
+import { jsx as r, jsxs as d } from "react/jsx-runtime";
+import a from "react";
+import { useMediaQuery as l } from "./index.es87.js";
+import { cn as m } from "./index.es69.js";
+import { Button as n } from "./index.es23.js";
+import { Sheet as i, SheetTrigger as c, SheetContent as p, SheetHeader as f, SheetClose as h, SheetFooter as u } from "./index.es50.js";
+import S from "./index.es92.js";
+const T = i, b = a.forwardRef(({ className: e, ...o }, t) => /* @__PURE__ */ r(c, { asChild: !0, children: /* @__PURE__ */ r(n, { ref: t, colors: "primary", className: m("flex items-center gap-space-02", e), ...o }) }));
+b.displayName = "SheetFormTrigger";
+const x = a.forwardRef(({ className: e, ...o }, t) => {
+  const s = l("(min-width: 768px)");
+  return /* @__PURE__ */ r(
+    p,
+    {
+      ref: t,
+      className: m(
+        "flex flex-col rounded-tl-4 rounded-tr-4 bg-card p-0 data-[side=bottom]:max-md:h-[93%] sm:max-w-[60rem] md:rounded-tl-none md:rounded-tr-none",
+        e
+      ),
+      side: s ? "left" : "bottom",
+      "data-side": s ? "left" : "bottom",
+      ...o
+    }
+  );
+});
+x.displayName = "SheetFormContent";
+const F = ({ className: e, title: o, ...t }) => /* @__PURE__ */ d(f, { className: m("flex flex-row items-center justify-between border-b border-input px-space-05 py-space-04", e), ...t, children: [
+  /* @__PURE__ */ r("h1", { className: "text-subtitle-02 font-bold", children: o }),
+  /* @__PURE__ */ r(h, { children: /* @__PURE__ */ r(S, {}) })
+] });
+F.displayName = "SheetFormHeader";
+const g = ({ className: e, title: o, ...t }) => /* @__PURE__ */ r(u, { className: m("absolute bottom-0 left-0 mt-auto w-full bg-background p-space-05", e), ...t });
+g.displayName = "SheetFormFooter";
+const y = a.forwardRef(({ className: e, ...o }, t) => /* @__PURE__ */ r("div", { ref: t, className: m("mb-space-11 overflow-auto p-space-05 text-foreground", e), ...o }));
+y.displayName = "SheetFormBody";
+export {
+  T as SheetForm,
+  y as SheetFormBody,
+  x as SheetFormContent,
+  g as SheetFormFooter,
+  F as SheetFormHeader,
+  b as SheetFormTrigger
+};

package/index.es130.js

@@ -0,0 +1,473 @@
+var W = Symbol.for("immer-nothing"), R = Symbol.for("immer-draftable"), u = Symbol.for("immer-state"), Q = 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 f(e, ...t) {
+  if (process.env.NODE_ENV !== "production") {
+    const r = Q[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 m = Object.getPrototypeOf;
+function h(e) {
+  return !!e && !!e[u];
+}
+function _(e) {
+  var t;
+  return e ? U(e) || Array.isArray(e) || !!e[R] || !!((t = e.constructor) != null && t[R]) || O(e) || D(e) : !1;
+}
+var Y = Object.prototype.constructor.toString();
+function U(e) {
+  if (!e || typeof e != "object")
+    return !1;
+  const t = m(e);
+  if (t === null)
+    return !0;
+  const r = Object.hasOwnProperty.call(t, "constructor") && t.constructor;
+  return r === Object ? !0 : typeof r == "function" && Function.toString.call(r) === Y;
+}
+function b(e, t) {
+  z(e) === 0 ? Reflect.ownKeys(e).forEach((r) => {
+    t(r, e[r], e);
+  }) : e.forEach((r, n) => t(n, r, e));
+}
+function z(e) {
+  const t = e[u];
+  return t ? t.type_ : Array.isArray(e) ? 1 : O(e) ? 2 : D(e) ? 3 : 0;
+}
+function A(e, t) {
+  return z(e) === 2 ? e.has(t) : Object.prototype.hasOwnProperty.call(e, t);
+}
+function B(e, t, r) {
+  const n = z(e);
+  n === 2 ? e.set(t, r) : n === 3 ? e.add(r) : e[t] = r;
+}
+function Z(e, t) {
+  return e === t ? e !== 0 || 1 / e === 1 / t : e !== e && t !== t;
+}
+function O(e) {
+  return e instanceof Map;
+}
+function D(e) {
+  return e instanceof Set;
+}
+function d(e) {
+  return e.copy_ || e.base_;
+}
+function N(e, t) {
+  if (O(e))
+    return new Map(e);
+  if (D(e))
+    return new Set(e);
+  if (Array.isArray(e))
+    return Array.prototype.slice.call(e);
+  const r = U(e);
+  if (t === !0 || t === "class_only" && !r) {
+    const n = Object.getOwnPropertyDescriptors(e);
+    delete n[u];
+    let i = Reflect.ownKeys(n);
+    for (let o = 0; o < i.length; o++) {
+      const s = i[o], c = n[s];
+      c.writable === !1 && (c.writable = !0, c.configurable = !0), (c.get || c.set) && (n[s] = {
+        configurable: !0,
+        writable: !0,
+        // could live with !!desc.set as well here...
+        enumerable: c.enumerable,
+        value: e[s]
+      });
+    }
+    return Object.create(m(e), n);
+  } else {
+    const n = m(e);
+    if (n !== null && r)
+      return { ...e };
+    const i = Object.create(n);
+    return Object.assign(i, e);
+  }
+}
+function T(e, t = !1) {
+  return S(e) || h(e) || !_(e) || (z(e) > 1 && (e.set = e.add = e.clear = e.delete = L), Object.freeze(e), t && Object.entries(e).forEach(([r, n]) => T(n, !0))), e;
+}
+function L() {
+  f(2);
+}
+function S(e) {
+  return Object.isFrozen(e);
+}
+var V = {};
+function y(e) {
+  const t = V[e];
+  return t || f(0, e), t;
+}
+var p;
+function G() {
+  return p;
+}
+function ee(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 x(e, t) {
+  t && (y("Patches"), e.patches_ = [], e.inversePatches_ = [], e.patchListener_ = t);
+}
+function v(e) {
+  C(e), e.drafts_.forEach(te), e.drafts_ = null;
+}
+function C(e) {
+  e === p && (p = e.parent_);
+}
+function j(e) {
+  return p = ee(p, e);
+}
+function te(e) {
+  const t = e[u];
+  t.type_ === 0 || t.type_ === 1 ? t.revoke_() : t.revoked_ = !0;
+}
+function $(e, t) {
+  t.unfinalizedDrafts_ = t.drafts_.length;
+  const r = t.drafts_[0];
+  return e !== void 0 && e !== r ? (r[u].modified_ && (v(t), f(4)), _(e) && (e = w(t, e), t.parent_ || g(t, e)), t.patches_ && y("Patches").generateReplacementPatches_(
+    r[u].base_,
+    e,
+    t.patches_,
+    t.inversePatches_
+  )) : e = w(t, r, []), v(t), t.patches_ && t.patchListener_(t.patches_, t.inversePatches_), e !== W ? e : void 0;
+}
+function w(e, t, r) {
+  if (S(t))
+    return t;
+  const n = t[u];
+  if (!n)
+    return b(
+      t,
+      (i, o) => K(e, n, t, i, o, r)
+    ), t;
+  if (n.scope_ !== e)
+    return t;
+  if (!n.modified_)
+    return g(e, n.base_, !0), n.base_;
+  if (!n.finalized_) {
+    n.finalized_ = !0, n.scope_.unfinalizedDrafts_--;
+    const i = n.copy_;
+    let o = i, s = !1;
+    n.type_ === 3 && (o = new Set(i), i.clear(), s = !0), b(
+      o,
+      (c, l) => K(e, n, i, c, l, r, s)
+    ), g(e, i, !1), r && e.patches_ && y("Patches").generatePatches_(
+      n,
+      r,
+      e.patches_,
+      e.inversePatches_
+    );
+  }
+  return n.copy_;
+}
+function K(e, t, r, n, i, o, s) {
+  if (process.env.NODE_ENV !== "production" && i === r && f(5), h(i)) {
+    const c = o && t && t.type_ !== 3 && // Set objects are atomic since they have no keys.
+    !A(t.assigned_, n) ? o.concat(n) : void 0, l = w(e, i, c);
+    if (B(r, n, l), h(l))
+      e.canAutoFreeze_ = !1;
+    else
+      return;
+  } else
+    s && r.add(i);
+  if (_(i) && !S(i)) {
+    if (!e.immer_.autoFreeze_ && e.unfinalizedDrafts_ < 1)
+      return;
+    w(e, i), (!t || !t.scope_.parent_) && typeof n != "symbol" && Object.prototype.propertyIsEnumerable.call(r, n) && g(e, i);
+  }
+}
+function g(e, t, r = !1) {
+  !e.parent_ && e.immer_.autoFreeze_ && e.canAutoFreeze_ && T(t, r);
+}
+function re(e, t) {
+  const r = Array.isArray(e), n = {
+    type_: r ? 1 : 0,
+    // Track which produce call this is associated with.
+    scope_: t ? t.scope_ : G(),
+    // 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, o = M;
+  r && (i = [n], o = P);
+  const { revoke: s, proxy: c } = Proxy.revocable(i, o);
+  return n.draft_ = c, n.revoke_ = s, c;
+}
+var M = {
+  get(e, t) {
+    if (t === u)
+      return e;
+    const r = d(e);
+    if (!A(r, t))
+      return ne(e, r, t);
+    const n = r[t];
+    return e.finalized_ || !_(n) ? n : n === F(e.base_, t) ? (E(e), e.copy_[t] = k(n, e)) : n;
+  },
+  has(e, t) {
+    return t in d(e);
+  },
+  ownKeys(e) {
+    return Reflect.ownKeys(d(e));
+  },
+  set(e, t, r) {
+    const n = H(d(e), t);
+    if (n != null && n.set)
+      return n.set.call(e.draft_, r), !0;
+    if (!e.modified_) {
+      const i = F(d(e), t), o = i == null ? void 0 : i[u];
+      if (o && o.base_ === r)
+        return e.copy_[t] = r, e.assigned_[t] = !1, !0;
+      if (Z(r, i) && (r !== void 0 || A(e.base_, t)))
+        return !0;
+      E(e), I(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 F(e.base_, t) !== void 0 || t in e.base_ ? (e.assigned_[t] = !1, E(e), I(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() {
+    f(11);
+  },
+  getPrototypeOf(e) {
+    return m(e.base_);
+  },
+  setPrototypeOf() {
+    f(12);
+  }
+}, P = {};
+b(M, (e, t) => {
+  P[e] = function() {
+    return arguments[0] = arguments[0][0], t.apply(this, arguments);
+  };
+});
+P.deleteProperty = function(e, t) {
+  return process.env.NODE_ENV !== "production" && isNaN(parseInt(t)) && f(13), P.set.call(this, e, t, void 0);
+};
+P.set = function(e, t, r) {
+  return process.env.NODE_ENV !== "production" && t !== "length" && isNaN(parseInt(t)) && f(14), M.set.call(this, e[0], t, r, e[0]);
+};
+function F(e, t) {
+  const r = e[u];
+  return (r ? d(r) : e)[t];
+}
+function ne(e, t, r) {
+  var i;
+  const n = H(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 H(e, t) {
+  if (!(t in e))
+    return;
+  let r = m(e);
+  for (; r; ) {
+    const n = Object.getOwnPropertyDescriptor(r, t);
+    if (n)
+      return n;
+    r = m(r);
+  }
+}
+function I(e) {
+  e.modified_ || (e.modified_ = !0, e.parent_ && I(e.parent_));
+}
+function E(e) {
+  e.copy_ || (e.copy_ = N(
+    e.base_,
+    e.scope_.immer_.useStrictShallowCopy_
+  ));
+}
+var ie = class {
+  constructor(e) {
+    this.autoFreeze_ = !0, this.useStrictShallowCopy_ = !1, this.produce = (t, r, n) => {
+      if (typeof t == "function" && typeof r != "function") {
+        const o = r;
+        r = t;
+        const s = this;
+        return function(l = o, ...q) {
+          return s.produce(l, (J) => r.call(this, J, ...q));
+        };
+      }
+      typeof r != "function" && f(6), n !== void 0 && typeof n != "function" && f(7);
+      let i;
+      if (_(t)) {
+        const o = j(this), s = k(t, void 0);
+        let c = !0;
+        try {
+          i = r(s), c = !1;
+        } finally {
+          c ? v(o) : C(o);
+        }
+        return x(o, n), $(i, o);
+      } else if (!t || typeof t != "object") {
+        if (i = r(t), i === void 0 && (i = t), i === W && (i = void 0), this.autoFreeze_ && T(i, !0), n) {
+          const o = [], s = [];
+          y("Patches").generateReplacementPatches_(t, i, o, s), n(o, s);
+        }
+        return i;
+      } else
+        f(1, t);
+    }, this.produceWithPatches = (t, r) => {
+      if (typeof t == "function")
+        return (s, ...c) => this.produceWithPatches(s, (l) => t(l, ...c));
+      let n, i;
+      return [this.produce(t, r, (s, c) => {
+        n = s, i = c;
+      }), 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);
+  }
+  createDraft(e) {
+    _(e) || f(8), h(e) && (e = oe(e));
+    const t = j(this), r = k(e, void 0);
+    return r[u].isManual_ = !0, C(t), r;
+  }
+  finishDraft(e, t) {
+    const r = e && e[u];
+    (!r || !r.isManual_) && f(9);
+    const { scope_: n } = r;
+    return x(n, t), $(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;
+  }
+  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 = y("Patches").applyPatches_;
+    return h(e) ? n(e, t) : this.produce(
+      e,
+      (i) => n(i, t)
+    );
+  }
+};
+function k(e, t) {
+  const r = O(e) ? y("MapSet").proxyMap_(e, t) : D(e) ? y("MapSet").proxySet_(e, t) : re(e, t);
+  return (t ? t.scope_ : G()).drafts_.push(r), r;
+}
+function oe(e) {
+  return h(e) || f(10, e), X(e);
+}
+function X(e) {
+  if (!_(e) || S(e))
+    return e;
+  const t = e[u];
+  let r;
+  if (t) {
+    if (!t.modified_)
+      return t.base_;
+    t.finalized_ = !0, r = N(e, t.scope_.immer_.useStrictShallowCopy_);
+  } else
+    r = N(e, !0);
+  return b(r, (n, i) => {
+    B(r, n, X(i));
+  }), t && (t.finalized_ = !1), r;
+}
+var a = new ie(), se = a.produce;
+a.produceWithPatches.bind(
+  a
+);
+a.setAutoFreeze.bind(a);
+a.setUseStrictShallowCopy.bind(a);
+a.applyPatches.bind(a);
+a.createDraft.bind(a);
+a.finishDraft.bind(a);
+export {
+  ie as Immer,
+  oe as current,
+  T as freeze,
+  R as immerable,
+  h as isDraft,
+  _ as isDraftable,
+  W as nothing,
+  se as produce
+};

package/index.es131.js

@@ -0,0 +1,141 @@
+const y = /* @__PURE__ */ new Map(), v = (d) => {
+  const l = y.get(d);
+  return l ? Object.fromEntries(
+    Object.entries(l.stores).map(([i, c]) => [i, c.getState()])
+  ) : {};
+}, O = (d, l, i) => {
+  if (d === void 0)
+    return {
+      type: "untracked",
+      connection: l.connect(i)
+    };
+  const c = y.get(i.name);
+  if (c)
+    return { type: "tracked", store: d, ...c };
+  const n = {
+    connection: l.connect(i),
+    stores: {}
+  };
+  return y.set(i.name, n), { type: "tracked", store: d, ...n };
+}, R = (d, l = {}) => (i, c, n) => {
+  const { enabled: A, anonymousActionType: C, store: r, ...p } = l;
+  let E;
+  try {
+    E = (A ?? !1) && window.__REDUX_DEVTOOLS_EXTENSION__;
+  } catch {
+  }
+  if (!E)
+    return d(i, c, n);
+  const { connection: t, ...f } = O(r, E, p);
+  let _ = !0;
+  n.setState = (o, a, e) => {
+    const s = i(o, a);
+    if (!_)
+      return s;
+    const T = e === void 0 ? { type: C || "anonymous" } : typeof e == "string" ? { type: e } : e;
+    return r === void 0 ? (t == null || t.send(T, c()), s) : (t == null || t.send(
+      {
+        ...T,
+        type: `${r}/${T.type}`
+      },
+      {
+        ...v(p.name),
+        [r]: n.getState()
+      }
+    ), s);
+  };
+  const u = (...o) => {
+    const a = _;
+    _ = !1, i(...o), _ = a;
+  }, S = d(n.setState, c, n);
+  if (f.type === "untracked" ? t == null || t.init(S) : (f.stores[f.store] = n, t == null || t.init(
+    Object.fromEntries(
+      Object.entries(f.stores).map(([o, a]) => [
+        o,
+        o === f.store ? S : a.getState()
+      ])
+    )
+  )), n.dispatchFromDevtools && typeof n.dispatch == "function") {
+    let o = !1;
+    const a = n.dispatch;
+    n.dispatch = (...e) => {
+      a(...e);
+    };
+  }
+  return t.subscribe((o) => {
+    var a;
+    switch (o.type) {
+      case "ACTION":
+        return typeof o.payload != "string" ? void 0 : I(
+          o.payload,
+          (e) => {
+            if (e.type === "__setState") {
+              if (r === void 0) {
+                u(e.state);
+                return;
+              }
+              Object.keys(e.state).length;
+              const s = e.state[r];
+              if (s == null)
+                return;
+              JSON.stringify(n.getState()) !== JSON.stringify(s) && u(s);
+              return;
+            }
+            n.dispatchFromDevtools && typeof n.dispatch == "function" && n.dispatch(e);
+          }
+        );
+      case "DISPATCH":
+        switch (o.payload.type) {
+          case "RESET":
+            return u(S), r === void 0 ? t == null ? void 0 : t.init(n.getState()) : t == null ? void 0 : t.init(v(p.name));
+          case "COMMIT":
+            if (r === void 0) {
+              t == null || t.init(n.getState());
+              return;
+            }
+            return t == null ? void 0 : t.init(v(p.name));
+          case "ROLLBACK":
+            return I(o.state, (e) => {
+              if (r === void 0) {
+                u(e), t == null || t.init(n.getState());
+                return;
+              }
+              u(e[r]), t == null || t.init(v(p.name));
+            });
+          case "JUMP_TO_STATE":
+          case "JUMP_TO_ACTION":
+            return I(o.state, (e) => {
+              if (r === void 0) {
+                u(e);
+                return;
+              }
+              JSON.stringify(n.getState()) !== JSON.stringify(e[r]) && u(e[r]);
+            });
+          case "IMPORT_STATE": {
+            const { nextLiftedState: e } = o.payload, s = (a = e.computedStates.slice(-1)[0]) == null ? void 0 : a.state;
+            if (!s)
+              return;
+            u(r === void 0 ? s : s[r]), t == null || t.send(
+              null,
+              // FIXME no-any
+              e
+            );
+            return;
+          }
+          case "PAUSE_RECORDING":
+            return _ = !_;
+        }
+        return;
+    }
+  }), S;
+}, h = R, I = (d, l) => {
+  let i;
+  try {
+    i = JSON.parse(d);
+  } catch {
+  }
+  i !== void 0 && l(i);
+};
+export {
+  h as devtools
+};

package/index.es132.js

@@ -0,0 +1,8 @@
+import { produce as f } from "./index.es130.js";
+const p = (n) => (m, o, t) => (t.setState = (e, r, ...c) => {
+  const i = typeof e == "function" ? f(e) : e;
+  return m(i, r, ...c);
+}, n(t.setState, o, t)), S = p;
+export {
+  S as immer
+};