@reformer/core 10.2.0 → 11.0.0-beta.10

package/dist/safe-effect-BazLOv1g.js

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