@reformer/core 11.0.0-beta.8 → 11.0.0-beta.9

package/dist/safe-effect-BbtX3KuN.js

@@ -0,0 +1,643 @@
+import { isSignal as I } from "./signals.js";
+import { batch as S, signal as F, computed as G } from "@preact/signals-core";
+const h = /* @__PURE__ */ new WeakMap();
+function oe(e) {
+  h.set(e, (h.get(e) ?? 0) + 1);
+}
+function ae(e) {
+  const t = h.get(e);
+  t !== void 0 && (t <= 1 ? h.delete(e) : h.set(e, t - 1));
+}
+function $(e) {
+  return h.has(e);
+}
+const l = (e) => !(e === null || typeof e != "object" || Array.isArray(e) || e instanceof Date || typeof Blob < "u" && e instanceof Blob || typeof File < "u" && e instanceof File), d = (e, t) => e === "" ? String(t) : `${e}.${t}`, p = (e) => /^\d+$/.test(e), f = (e) => {
+  if (e instanceof Date) return new Date(e.getTime());
+  if (Array.isArray(e)) return e.map(f);
+  if (l(e)) {
+    const t = {};
+    for (const r of Object.keys(e)) t[r] = f(e[r]);
+    return t;
+  }
+  return e;
+}, O = (e, t) => {
+  if (e === t || Number.isNaN(e) && Number.isNaN(t)) return !0;
+  if (e instanceof Date && t instanceof Date) return Object.is(e.getTime(), t.getTime());
+  if (Array.isArray(e) && Array.isArray(t))
+    return e.length !== t.length ? !1 : e.every((r, n) => O(r, t[n]));
+  if (l(e) && l(t)) {
+    const r = Object.keys(e), n = Object.keys(t);
+    return r.length !== n.length ? !1 : r.every((s) => O(e[s], t[s]));
+  }
+  return !1;
+}, T = Symbol.for("@reformer/core:arrayBlank"), j = (e) => Array.isArray(e) ? e[T] : void 0, H = (e, t) => l(e) ? e[t] : void 0;
+function B(e, t) {
+  if (!l(e) || !l(t)) return t;
+  const r = { ...e };
+  for (const [n, s] of Object.entries(t))
+    r[n] = s === void 0 ? e[n] : B(e[n], s);
+  return r;
+}
+function ce(e, t = []) {
+  const r = [...t];
+  return Object.defineProperty(r, T, { value: e }), r;
+}
+const R = /* @__PURE__ */ new WeakMap();
+function J(e) {
+  return R.get(e);
+}
+class X {
+  constructor(t, r) {
+    this.path = r;
+    const n = F(t);
+    n.__path = r, this.signal = n, this.initial = f(t), R.set(this.signal, this);
+  }
+  kind = "leaf";
+  signal;
+  initial;
+  rebase(t) {
+    this.path = t, this.signal.__path = t;
+  }
+  /** Реактивное чтение (внутри effect/computed создаёт зависимость). */
+  read() {
+    return this.signal.value;
+  }
+  /** Нереактивный снимок. */
+  peek() {
+    return this.signal.peek();
+  }
+  set(t) {
+    this.signal.value = t;
+  }
+  /**
+   * Вернуть значение к снимку. Производное поле (цель `compute`, поле сервера с `markDerived`)
+   * сброс не пишет — как `set` и `patch`: значением владеет поведение, а снимок такого поля снят
+   * до первого расчёта, и `compute` пересчитал бы его только при смене источников.
+   */
+  resetToInitial() {
+    $(this.signal) || (this.signal.value = f(this.initial));
+  }
+  captureInitial() {
+    this.initial = f(this.signal.peek());
+  }
+  /** Значение точки отсчёта — копия: правка полученного снимок не трогает. */
+  reference() {
+    return f(this.initial);
+  }
+  dirty() {
+    return this.differsFrom(this.initial);
+  }
+  /**
+   * Отличается ли значение от снимка. Производное поле отличием не считается: его пишет поведение,
+   * а не пользователь — иначе форма без единой правки была бы «изменённой».
+   */
+  differsFrom(t) {
+    return !$(this.signal) && !O(this.signal.peek(), t);
+  }
+}
+class Q {
+  /**
+   * @param shape Образец той же группы из шаблона родительского массива: из него вложенные
+   *   массивы берут шаблоны, если значение пришло обычными данными (см. {@link ModelArrayNode}).
+   */
+  constructor(t, r, n) {
+    this.path = r;
+    for (const s of Object.keys(t)) {
+      const i = n && (() => H(n(), s));
+      this.children.set(s, W(t[s], d(r, s), i));
+    }
+  }
+  kind = "group";
+  children = /* @__PURE__ */ new Map();
+  rebase(t) {
+    this.path = t;
+    for (const [r, n] of this.children) n.rebase(d(t, r));
+  }
+  /** Реактивное чтение поддерева (внутри effect/computed подписывает на все листья группы). */
+  read() {
+    const t = {};
+    for (const [r, n] of this.children) t[r] = n.read();
+    return t;
+  }
+  peek() {
+    const t = {};
+    for (const [r, n] of this.children) t[r] = n.peek();
+    return t;
+  }
+  /**
+   * Полная установка: значение ожидается целиком. Ключи, которых в нём нет, остаются прежними —
+   * как у {@link patch}, — но в dev о них сообщает предупреждение: неполный объект в `set` — почти
+   * всегда ошибка вызывающего кода, а не намерение.
+   */
+  set(t) {
+    const r = [];
+    if (this.write(t, r), r.length > 0 && process.env.NODE_ENV !== "production") {
+      const n = this.path === "" ? "model" : `model.${this.path}`, s = t == null || typeof t != "object" ? "значение не объект — группа осталась прежней" : `в значении нет ключей ${r.map((i) => `«${i}»`).join(", ")} — эти поля остались прежними`;
+      console.warn(
+        `[@reformer/core] ${n}.set(...): ${s}. \`set\` ожидает объект целиком; для частичного обновления есть \`patch\`.`
+      );
+    }
+  }
+  /**
+   * Частичное обновление: записываются только переданные ключи. Вложенная группа сливается так
+   * же, массив заменяется целиком.
+   */
+  patch(t) {
+    this.write(t, void 0, !0);
+  }
+  /**
+   * Запись значения по ключам группы. Лишние ключи значения игнорируются, производные поля не
+   * затираются.
+   *
+   * @param missing - Куда складывать пути ключей, для которых значение не пришло. Передаётся при
+   *   полной установке ({@link set}); при частичной ({@link patch}) — `undefined`.
+   * @param partial - Частичное обновление: ключ со значением `undefined` — «не трогать», как в
+   *   частичном значении элемента массива (`DeepPartial` допускает `{ ключ: undefined }`).
+   */
+  write(t, r, n = !1) {
+    if (t == null || typeof t != "object") {
+      r?.push(this.path);
+      return;
+    }
+    const s = t;
+    S(() => {
+      for (const [i, a] of this.children)
+        if (!(a.kind === "leaf" && $(a.signal))) {
+          if (!(i in s)) {
+            r?.push(d(this.path, i));
+            continue;
+          }
+          n && s[i] === void 0 || (a.kind === "group" ? a.write(s[i], r, n) : a.set(s[i]));
+        }
+    });
+  }
+  resetToInitial() {
+    S(() => {
+      for (const t of this.children.values()) t.resetToInitial();
+    });
+  }
+  captureInitial() {
+    for (const t of this.children.values()) t.captureInitial();
+  }
+  dirty() {
+    for (const t of this.children.values()) if (t.dirty()) return !0;
+    return !1;
+  }
+  /** Отличается ли группа от снимка её значения (строка массива сверяется со снимком массива). */
+  differsFrom(t) {
+    if (!l(t)) return !0;
+    for (const [r, n] of this.children) if (n.differsFrom(t[r])) return !0;
+    return !1;
+  }
+}
+class U {
+  /** @param shape Образец того же массива из шаблона родителя (см. {@link ModelGroupNode}). */
+  constructor(t, r, n) {
+    this.path = r, this.shape = n, this.blank = j(t), this.items = F(t.map((s, i) => this.build(s, i))), this.initial = f(t);
+  }
+  kind = "array";
+  items;
+  initial;
+  // Шаблон нового элемента (`arrayOf`). Принадлежит узлу, а не значению: `set`/`reset` заменяют
+  // элементы, узел остаётся — и шаблон с ним.
+  blank;
+  // Запасной шаблон — от того, кто строит модель извне (сборка формы передаёт `initialValue`).
+  fallback;
+  // Образец элемента — один вызов шаблона. Нужен только ради вложенных шаблонов: элемент из
+  // обычных данных (`set` с сервера, `push(значение)`) метку `arrayOf` на своих массивах не несёт.
+  sample;
+  /** Шаблон по старшинству: свой (`arrayOf`) → из шаблона родителя → запасной извне. */
+  template() {
+    return this.blank ??= j(this.shape?.()), this.blank ?? this.fallback;
+  }
+  // Образец читается лениво — лишний вызов шаблона случается, только когда вложенному массиву
+  // элемента из обычных данных понадобился свой шаблон.
+  itemShape = () => {
+    if (!this.sample) {
+      const t = this.template();
+      if (!t) return;
+      this.sample = { value: t() };
+    }
+    return this.sample.value;
+  };
+  build(t, r) {
+    return W(t, d(this.path, r), this.itemShape);
+  }
+  /**
+   * Значение нового элемента: из шаблона; переданный объект накладывается поверх шаблона —
+   * недостающие ключи берутся из шаблона, поэтому `push({ type: 'house' })` даёт полный элемент.
+   */
+  fresh(t) {
+    const r = this.template();
+    if (t !== void 0) return r ? B(r(), t) : t;
+    if (!r)
+      throw new Error(
+        `[@reformer/core] ${this.path || "массив"}: добавление элемента без значения, а шаблона у массива нет. Объявите его в модели — \`arrayOf(() => ({ … }))\` — либо передайте значение: \`push(значение)\`.`
+      );
+    return r();
+  }
+  /** Запасной шаблон извне (сборка формы передаёт `initialValue`): шаблон модели главнее. */
+  provideBlank(t) {
+    this.fallback ??= t;
+  }
+  rebase(t) {
+    this.path = t, this.items.peek().forEach((r, n) => r.rebase(d(t, n)));
+  }
+  reindex() {
+    this.items.peek().forEach((t, r) => t.rebase(d(this.path, r)));
+  }
+  /**
+   * Индекс за концом массива — ошибка, а не «в конец»: `splice` молча сдвигал бы элемент на
+   * другой индекс, и вызывающий код получал бы путь, которого не просил.
+   */
+  beyondEnd(t, r, n) {
+    const s = this.path === "" ? "model" : `model.${this.path}`, i = this.items.peek().length;
+    return new RangeError(
+      `[@reformer/core] ${s}.${t}: индекс ${r} за концом массива (длина ${i}, наибольший допустимый — ${n}).` + (t.startsWith("insertAt") ? " Добавить в конец — push(…) или insertAt(length, …)." : "")
+    );
+  }
+  push(t) {
+    const r = this.items.peek();
+    this.items.value = [...r, this.build(this.fresh(t), r.length)];
+  }
+  insertAt(t, r) {
+    if (!Number.isInteger(t) || t < 0) return;
+    const n = [...this.items.peek()];
+    if (t > n.length) throw this.beyondEnd(`insertAt(${t})`, t, n.length);
+    n.splice(t, 0, this.build(this.fresh(r), t)), this.items.value = n, this.reindex();
+  }
+  removeAt(t) {
+    const r = [...this.items.peek()];
+    !Number.isInteger(t) || t < 0 || t >= r.length || (r.splice(t, 1), this.items.value = r, this.reindex());
+  }
+  move(t, r) {
+    const n = [...this.items.peek()];
+    if (!Number.isInteger(t) || !Number.isInteger(r) || t < 0 || r < 0) return;
+    const s = n.length - 1;
+    if (t > s) throw this.beyondEnd(`move(${t}, ${r})`, t, s);
+    if (r > s) throw this.beyondEnd(`move(${t}, ${r})`, r, s);
+    if (t === r) return;
+    const [i] = n.splice(t, 1);
+    i && n.splice(r, 0, i), this.items.value = n, this.reindex();
+  }
+  swap(t, r) {
+    const n = [...this.items.peek()];
+    t < 0 || r < 0 || t >= n.length || r >= n.length || t === r || ([n[t], n[r]] = [n[r], n[t]], this.items.value = n, this.reindex());
+  }
+  clear() {
+    this.items.value = [];
+  }
+  /**
+   * Реактивное чтение массива. Читаем `items.value` (а не `.peek()`) — внутри effect/computed это
+   * подписка на СОСТАВ массива, поэтому push/removeAt/move ретригерят наравне с правкой элемента.
+   */
+  read() {
+    return this.items.value.map((t) => t.read());
+  }
+  peek() {
+    return this.items.peek().map((t) => t.peek());
+  }
+  set(t) {
+    const r = Array.isArray(t) ? t : [];
+    this.items.value = r.map((n, s) => this.build(n, s));
+  }
+  resetToInitial() {
+    this.set(f(this.initial));
+  }
+  captureInitial() {
+    this.initial = f(this.peek());
+  }
+  /** Элементы точки отсчёта — копия: правка полученного снимок не трогает. */
+  reference() {
+    return f(this.initial);
+  }
+  dirty() {
+    return this.differsFrom(this.initial);
+  }
+  /**
+   * Отличается ли массив от снимка: другая длина либо отличается элемент. Сверка идёт по узлам, а
+   * не по значению целиком — производные поля строк (цели `compute` поведения строки) не в счёт.
+   */
+  differsFrom(t) {
+    const r = this.items.peek();
+    return !Array.isArray(t) || t.length !== r.length ? !0 : r.some((n, s) => n.differsFrom(t[s]));
+  }
+}
+function W(e, t, r) {
+  return Array.isArray(e) ? new U(e, t, r) : l(e) ? new Q(e, t, r) : new X(e, t);
+}
+const Y = (e) => typeof e == "function" ? e : () => f(e), _ = /* @__PURE__ */ new WeakMap(), C = /* @__PURE__ */ new WeakMap();
+function Z(e) {
+  const t = G(
+    () => process.env.NODE_ENV === "production" ? e.read() : A(e.read(), e)
+  );
+  return {
+    get value() {
+      return t.value;
+    },
+    peek: () => t.peek(),
+    subscribe: (r) => t.subscribe(r),
+    valueOf: () => t.value,
+    toString: () => String(t.value),
+    toJSON: () => t.value,
+    brand: t.brand
+  };
+}
+function A(e, t) {
+  if (t.kind === "leaf" || e === null || typeof e != "object") return e;
+  const r = e;
+  if (t.kind === "group")
+    for (const [n, s] of t.children) A(r[n], s);
+  else
+    t.items.peek().forEach((n, s) => A(r[s], n));
+  return Object.freeze(e);
+}
+function m(e) {
+  if (e.kind === "leaf") return e.signal;
+  const t = _.get(e);
+  if (t) return t;
+  const r = Z(e), n = e.kind === "group", s = (c) => n ? e.children.get(c) : p(c) ? e.items.value[Number(c)] : void 0, i = n ? {} : Object.defineProperty({}, "length", {
+    get: () => e.items.value.length,
+    enumerable: !1,
+    configurable: !0
+  }), a = new Proxy(i, {
+    get: (c, o, k) => {
+      if (o === "__path") return e.path;
+      if (o === "__kind") return e.kind;
+      if (typeof o != "string") return Reflect.get(r, o, r);
+      const g = s(o);
+      return g ? m(g) : !n && Object.prototype.hasOwnProperty.call(c, o) ? Reflect.get(c, o, k) : Reflect.get(r, o, r);
+    },
+    set: (c, o, k) => {
+      if (!n && o === "value")
+        return e.set(k), !0;
+      const g = e.path === "" ? "model.$" : `model.$.${e.path}`;
+      throw new TypeError(
+        `[@reformer/core] ${g}: запись в «${String(o)}» ` + (n ? "узла-группы невозможна — группа читается целиком, а пишется по полям (model.$.<поле>.value) либо через model.patch(...)" : "узла-массива невозможна — массив заменяется целиком через .value, а элемент правится своим сигналом (model.$.<массив>[i].value)")
+      );
+    },
+    has: (c, o) => typeof o == "string" && (s(o) !== void 0 || !n && Object.prototype.hasOwnProperty.call(c, o)),
+    ownKeys: () => n ? [...e.children.keys()] : [...e.items.value.keys()].map(String).concat("length"),
+    getOwnPropertyDescriptor: (c, o) => typeof o == "string" && s(o) ? { enumerable: !0, configurable: !0 } : n ? void 0 : Reflect.getOwnPropertyDescriptor(c, o)
+  });
+  return _.set(e, a), C.set(a, e), a;
+}
+function q(e) {
+  if (!(e == null || typeof e != "object"))
+    return C.get(e);
+}
+function E(e) {
+  if (e == null || typeof e != "object") return !1;
+  const t = e.__kind;
+  return t === "group" || t === "array";
+}
+function y(e) {
+  return e == null || typeof e != "object" ? !1 : e.__kind === "array";
+}
+function fe(e) {
+  return y(e) || I(e) && !E(e);
+}
+function ee(e, t) {
+  if (!t) return;
+  let r = e;
+  for (const n of t.split(".")) {
+    if (!r) return;
+    if (r.kind === "group") r = r.children.get(n);
+    else if (r.kind === "array") r = r.items.peek()[Number(n)];
+    else return;
+  }
+  if (r)
+    return r.kind === "leaf" ? r.signal : r.kind === "array" ? m(r) : void 0;
+}
+function u(e) {
+  if (e)
+    return e.kind === "group" ? K(e) : e.kind === "array" ? x(e) : e.read();
+}
+const D = /* @__PURE__ */ new WeakMap(), v = /* @__PURE__ */ new WeakMap();
+function x(e) {
+  const t = D.get(e);
+  if (t) return t;
+  const r = {
+    get length() {
+      return e.items.value.length;
+    },
+    push: (s) => e.push(s),
+    insertAt: (s, i) => e.insertAt(s, i),
+    removeAt: (s) => e.removeAt(s),
+    move: (s, i) => e.move(s, i),
+    swap: (s, i) => e.swap(s, i),
+    clear: () => e.clear(),
+    at: (s) => u(e.items.value[s]),
+    map: (s) => e.items.value.map((i, a) => s(u(i), a)),
+    forEach: (s) => e.items.value.forEach((i, a) => s(u(i), a)),
+    toArray: () => e.peek(),
+    toJSON: () => e.peek(),
+    [Symbol.iterator]: function* () {
+      const s = e.items.value;
+      for (let i = 0; i < s.length; i++) yield u(s[i]);
+    }
+  }, n = new Proxy(r, {
+    get: (s, i, a) => i === "__path" ? e.path : typeof i == "string" && p(i) ? u(e.items.value[Number(i)]) : Reflect.get(s, i, a),
+    has: (s, i) => typeof i == "string" && p(i) ? Number(i) < e.items.value.length : Reflect.has(s, i),
+    // Перечисляются данные, как у массива: индексы и неперечислимый `length`, а не методы API.
+    ownKeys: () => [...e.items.value.keys()].map(String).concat("length"),
+    getOwnPropertyDescriptor: (s, i) => {
+      if (i === "length")
+        return { ...Reflect.getOwnPropertyDescriptor(s, i), enumerable: !1 };
+      if (typeof i == "string" && p(i) && Number(i) < e.items.value.length)
+        return {
+          enumerable: !0,
+          configurable: !0,
+          writable: !0,
+          value: u(e.items.value[Number(i)])
+        };
+    },
+    set: (s, i, a) => {
+      const c = e.path === "" ? "model" : `model.${e.path}`;
+      if (typeof i == "string" && p(i)) {
+        const o = e.items.peek()[Number(i)];
+        if (o)
+          return o.set(a), !0;
+        throw new TypeError(
+          `[@reformer/core] ${c}[${i}]: элемента нет — добавляйте через push(…) / insertAt(…).`
+        );
+      }
+      throw new TypeError(
+        `[@reformer/core] ${c}: запись в «${String(i)}» невозможна — элементы пишутся по индексу или через push / insertAt / removeAt / move / swap / clear.`
+      );
+    }
+  });
+  return D.set(e, n), v.set(n, e), n;
+}
+const w = /* @__PURE__ */ new Set([
+  "$",
+  "get",
+  "set",
+  "patch",
+  "isDirty",
+  "reset",
+  "captureInitial",
+  "signalAt"
+]), te = () => "[object Object]", M = /* @__PURE__ */ new WeakMap(), N = /* @__PURE__ */ new WeakMap();
+function K(e) {
+  const t = M.get(e);
+  if (t) return t;
+  const r = {
+    $: m(e),
+    get: () => e.peek(),
+    set: (s) => e.set(s),
+    patch: (s) => e.patch(s),
+    isDirty: () => e.dirty(),
+    reset: () => e.resetToInitial(),
+    captureInitial: () => e.captureInitial(),
+    signalAt: (s) => ee(e, s)
+  }, n = new Proxy(
+    {},
+    {
+      get: (s, i) => {
+        if (i === "__path") return e.path;
+        if (typeof i != "string") return;
+        const a = e.children.get(i);
+        if (a) return u(a);
+        if (w.has(i)) return r[i];
+        if (i === "toString") return te;
+      },
+      set: (s, i, a) => {
+        const c = typeof i == "string" ? e.children.get(i) : void 0;
+        if (c)
+          return c.set(a), !0;
+        const o = e.path === "" ? "model" : `model.${e.path}`;
+        throw new TypeError(
+          `[@reformer/core] ${o}: поля «${String(i)}» в модели нет — запись невозможна. Состав полей задаёт начальное значение модели` + (typeof i == "string" && w.has(i) ? `; «${i}» — метод API модели.` : ".")
+        );
+      },
+      has: (s, i) => typeof i == "string" && (e.children.has(i) || w.has(i)),
+      ownKeys: () => [...e.children.keys()],
+      getOwnPropertyDescriptor: (s, i) => typeof i == "string" && e.children.has(i) ? { enumerable: !0, configurable: !0 } : void 0
+    }
+  );
+  return M.set(e, n), N.set(n, e), n;
+}
+function le(e) {
+  const t = q(e);
+  if (!t) {
+    const r = e?.__path, n = typeof r == "string" && r !== "" ? ` «${r}»` : "";
+    throw new TypeError(
+      I(e) && !E(e) ? `[@reformer/core] modelOf: ручка${n} — лист, у него нет под-модели. Группа или массив, созданные из начального null, в модели тоже лист: задайте начальное значение объектом или массивом.` : "[@reformer/core] modelOf: ожидалась ручка группы или массива из дерева model.$ (например, model.$.address или model.$.items)."
+    );
+  }
+  return t.kind === "group" ? K(t) : x(t);
+}
+function V(e) {
+  if (e == null || typeof e != "object") return;
+  const t = v.get(e);
+  if (t) return m(t);
+  const r = N.get(e);
+  return r ? m(r) : void 0;
+}
+function ue(e) {
+  if (y(e)) return e;
+  const t = V(e);
+  return y(t) ? t : void 0;
+}
+function he(e) {
+  const t = E(e) ? e : V(e);
+  return t !== void 0 && !y(t) ? t : void 0;
+}
+function de(e, t) {
+  const r = q(e);
+  r?.kind === "array" && r.provideBlank(Y(t));
+}
+function pe(e) {
+  if (typeof e != "object" || e === null) return;
+  const t = v.get(e);
+  if (t !== void 0) return { value: t.reference() };
+  const r = J(e);
+  return r === void 0 ? void 0 : { value: r.reference() };
+}
+function me(e) {
+  return e == null || typeof e != "object" ? !1 : v.has(e) || N.has(e);
+}
+const re = "runOutsideEffect";
+function P(e, t) {
+  process.env.NODE_ENV !== "production" && console.error(`[${t}]`, e);
+}
+function ne(e) {
+  return typeof e == "object" && e !== null && typeof e.then == "function";
+}
+function L(e, t) {
+  try {
+    const r = e();
+    ne(r) && r.then(void 0, (n) => P(n, t));
+  } catch (r) {
+    P(r, t);
+  }
+}
+function ge(e) {
+  return (...t) => {
+    z(() => e(...t));
+  };
+}
+function z(e) {
+  let t = !1;
+  return b++, queueMicrotask(() => {
+    b--, !t && L(e, re);
+  }), () => {
+    t = !0;
+  };
+}
+let b = 0;
+function ye() {
+  if (b !== 0)
+    return new Promise((e) => {
+      const t = () => {
+        b > 0 ? queueMicrotask(t) : e();
+      };
+      queueMicrotask(t);
+    });
+}
+function be() {
+  const e = /* @__PURE__ */ new Set();
+  return {
+    schedule(t) {
+      const r = z(() => {
+        e.delete(r), t();
+      });
+      e.add(r);
+    },
+    cancelAll() {
+      e.forEach((t) => t()), e.clear();
+    }
+  };
+}
+function ve(e, t) {
+  return () => {
+    t(() => L(e, "safeDebouncedCallback"));
+  };
+}
+export {
+  Q as M,
+  ce as a,
+  fe as b,
+  oe as c,
+  $ as d,
+  ve as e,
+  ye as f,
+  O as g,
+  be as h,
+  E as i,
+  K as j,
+  N as k,
+  m as l,
+  le as m,
+  he as n,
+  ue as o,
+  y as p,
+  pe as q,
+  z as r,
+  ge as s,
+  q as t,
+  ae as u,
+  me as v,
+  de as w
+};