@tachui/core 0.7.0-alpha1 → 0.7.1-alpha

package/dist/scheduler-7SvC3a21.js

@@ -0,0 +1,814 @@
+var n = /* @__PURE__ */ ((t) => (t[t.Clean = 0] = "Clean", t[t.Check = 1] = "Check", t[t.Dirty = 2] = "Dirty", t[t.Disposed = 3] = "Disposed", t))(n || {}), P = Object.defineProperty, T = (t, e, s) => e in t ? P(t, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : t[e] = s, o = (t, e, s) => T(t, typeof e != "symbol" ? e + "" : e, s);
+let D = 0, O = 0, h = null, a = null, d = !1;
+function I() {
+  return h;
+}
+function N() {
+  return a;
+}
+function Q() {
+  return d;
+}
+class H {
+  constructor(e = null) {
+    o(this, "id"), o(this, "parent"), o(this, "context", /* @__PURE__ */ new Map()), o(this, "cleanups", []), o(this, "sources", /* @__PURE__ */ new Set()), o(this, "disposed", !1), this.id = ++O, this.parent = e;
+  }
+  dispose() {
+    if (!this.disposed) {
+      this.disposed = !0;
+      for (const e of this.sources)
+        e.dispose();
+      this.sources.clear();
+      for (const e of this.cleanups)
+        try {
+          e();
+        } catch (s) {
+          console.error("Error in cleanup function:", s);
+        }
+      this.cleanups.length = 0, this.parent && !this.parent.disposed && this.parent.sources.delete(this);
+    }
+  }
+}
+class V {
+  constructor(e, s = null) {
+    o(this, "id"), o(this, "owner"), o(this, "fn"), o(this, "sources", /* @__PURE__ */ new Set()), o(this, "observers", /* @__PURE__ */ new Set()), o(this, "state", n.Dirty), o(this, "value"), this.id = ++D, this.fn = e, this.owner = s, s && !s.disposed && s.sources.add(this);
+  }
+  execute() {
+    if (this.state === n.Disposed)
+      return this.value;
+    for (const s of this.sources)
+      s && typeof s == "object" && "removeObserver" in s && s.removeObserver(this);
+    this.sources.clear();
+    const e = h;
+    h = this;
+    try {
+      return this.state = n.Clean, this.value = this.fn(), this.value;
+    } catch (s) {
+      throw this.state = n.Disposed, (typeof process > "u" || process.env.NODE_ENV !== "test") && console.error("Error in computation:", s), s;
+    } finally {
+      h = e;
+    }
+  }
+  dispose() {
+    if (this.state !== n.Disposed) {
+      this.state = n.Disposed;
+      for (const e of this.sources)
+        e && typeof e == "object" && "removeObserver" in e && e.removeObserver(this);
+      this.sources.clear();
+      for (const e of this.observers)
+        e.sources.delete(this);
+      this.observers.clear(), this.owner && !this.owner.disposed && this.owner.sources.delete(this);
+    }
+  }
+}
+function le(t) {
+  const e = new H(a), s = a;
+  a = e;
+  try {
+    return t(() => e.dispose());
+  } finally {
+    a = s;
+  }
+}
+function ce(t, e) {
+  const s = a;
+  a = t;
+  try {
+    return e();
+  } finally {
+    a = s;
+  }
+}
+function he() {
+  return a;
+}
+let C = null;
+function B(t) {
+  C = t;
+}
+function fe(t) {
+  if (d)
+    return t();
+  const e = d;
+  d = !0;
+  try {
+    const s = t();
+    return !e && C && C(), s;
+  } finally {
+    d = e;
+  }
+}
+function de(t) {
+  const e = h;
+  h = null;
+  try {
+    return t();
+  } finally {
+    h = e;
+  }
+}
+function pe(t, e) {
+  const s = new V(t, e || a);
+  return s.execute(), s;
+}
+function me() {
+  return {
+    computation: h,
+    batch: d
+  };
+}
+const ye = {
+  getCurrentComputation: () => h,
+  getCurrentOwner: () => a,
+  getComputationCount: () => D,
+  getOwnerCount: () => O,
+  isBatching: () => d
+};
+var U = Object.defineProperty, W = (t, e, s) => e in t ? U(t, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : t[e] = s, S = (t, e, s) => W(t, typeof e != "symbol" ? e + "" : e, s);
+let L = 0;
+class G {
+  constructor(e) {
+    S(this, "id"), S(this, "observers", /* @__PURE__ */ new Set()), S(this, "_value"), this.id = ++L, this._value = e;
+  }
+  /**
+   * Get the current value and track dependency
+   */
+  getValue() {
+    const e = I();
+    return e && e.state !== n.Disposed && (this.observers.add(e), e.sources.add(this)), this._value;
+  }
+  /**
+   * Get the current value without tracking dependency
+   */
+  peek() {
+    return this._value;
+  }
+  /**
+   * Set a new value and notify observers
+   */
+  set(e) {
+    const s = typeof e == "function" ? e(this._value) : e;
+    return s !== this._value && (this._value = s, this.notify()), s;
+  }
+  /**
+   * Notify all observers that this signal has changed
+   */
+  notify() {
+    for (const e of this.observers)
+      e.state !== n.Disposed && (e.state = n.Dirty, J(e));
+  }
+  /**
+   * Remove an observer (cleanup)
+   */
+  removeObserver(e) {
+    this.observers.delete(e);
+  }
+  /**
+   * Get debug information about this signal
+   */
+  [Symbol.for("tachui.debug")]() {
+    return {
+      id: this.id,
+      value: this._value,
+      observerCount: this.observers.size,
+      type: "Signal"
+    };
+  }
+}
+const b = /* @__PURE__ */ new Set();
+let _ = !1;
+function J(t) {
+  b.add(t), !_ && !Q() && queueMicrotask(k);
+}
+function k() {
+  if (!_) {
+    _ = !0;
+    try {
+      for (; b.size > 0; ) {
+        const t = Array.from(b).sort((e, s) => e.id - s.id);
+        b.clear();
+        for (const e of t)
+          e.state === n.Dirty && e.execute();
+      }
+    } finally {
+      _ = !1;
+    }
+  }
+}
+function K(t) {
+  const e = new G(t), s = e.getValue.bind(e);
+  s.peek = e.peek.bind(e);
+  const r = e.set.bind(e);
+  return Object.defineProperty(s, Symbol.for("tachui.signal"), {
+    value: e,
+    enumerable: !1
+  }), [s, r];
+}
+function ve(t) {
+  return typeof t == "function" && Symbol.for("tachui.signal") in t;
+}
+function ge(t) {
+  return t[Symbol.for("tachui.signal")] || null;
+}
+B(k);
+const w = (t, e) => t === e, E = (t, e) => {
+  if (t === e) return !0;
+  if (t == null || e == null || typeof t != typeof e) return !1;
+  if (typeof t == "object") {
+    if (Array.isArray(t) !== Array.isArray(e)) return !1;
+    if (Array.isArray(t)) {
+      const l = t, F = e;
+      return l.length !== F.length ? !1 : l.every((A, j) => E(A, F[j]));
+    }
+    const s = t, r = e, i = Object.keys(s), u = Object.keys(r);
+    return i.length !== u.length ? !1 : i.every((l) => E(s[l], r[l]));
+  }
+  return !1;
+}, be = (t, e) => {
+  if (t === e) return !0;
+  if (typeof t != "object" || typeof e != "object" || t == null || e == null) return !1;
+  const s = t, r = e, i = Object.keys(s), u = Object.keys(r);
+  return i.length !== u.length ? !1 : i.every((l) => s[l] === r[l]);
+}, _e = (t, e) => {
+  if (t === e) return !0;
+  if (t instanceof Date && e instanceof Date)
+    return t.getTime() === e.getTime();
+  if (t instanceof RegExp && e instanceof RegExp)
+    return t.toString() === e.toString();
+  if (t instanceof Set && e instanceof Set) {
+    if (t.size !== e.size) return !1;
+    for (const s of t)
+      if (!e.has(s)) return !1;
+    return !0;
+  }
+  if (t instanceof Map && e instanceof Map) {
+    if (t.size !== e.size) return !1;
+    for (const [s, r] of t)
+      if (!e.has(s) || e.get(s) !== r) return !1;
+    return !0;
+  }
+  return E(t, e);
+}, we = (t, e) => {
+  if (t === e) return !0;
+  try {
+    return JSON.stringify(t) === JSON.stringify(e);
+  } catch {
+    return t === e;
+  }
+}, qe = (t, e = w) => (s, r) => e(t(s), t(r)), Se = (t = w) => (e, s) => e === s ? !0 : e.length !== s.length ? !1 : e.every((r, i) => t(r, s[i])), Ce = (t = w) => (e, s) => {
+  if (e === s) return !0;
+  if (e == null || s == null) return !1;
+  const r = Object.keys(e), i = Object.keys(s);
+  return r.length !== i.length ? !1 : r.every((u) => t(e[u], s[u]));
+}, Ee = (...t) => (e, s) => t.every((r) => r(e, s)), Fe = (t, e) => (s, r) => {
+  const i = t(s, r);
+  return process.env.NODE_ENV === "development" && console.log(`[${e || "equals"}]`, { a: s, b: r, equal: i }), i;
+};
+var X = Object.defineProperty, Y = (t, e, s) => e in t ? X(t, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : t[e] = s, c = (t, e, s) => Y(t, typeof e != "symbol" ? e + "" : e, s), v = /* @__PURE__ */ ((t) => (t[t.Immediate = 0] = "Immediate", t[t.High = 1] = "High", t[t.Normal = 2] = "Normal", t[t.Low = 3] = "Low", t[t.Idle = 4] = "Idle", t))(v || {});
+class Z extends Error {
+  constructor(e, s, r) {
+    super(e), this.cause = s, this.node = r, this.name = "ReactiveError";
+  }
+}
+const M = class m {
+  constructor() {
+    c(this, "updateQueues", /* @__PURE__ */ new Map()), c(this, "isFlushPending", !1), c(this, "isDestroyed", !1), c(this, "errorHandlers", /* @__PURE__ */ new Set()), c(this, "maxRetries", 3), c(this, "totalUpdateCycles", 0), c(this, "totalUpdateTime", 0), c(this, "errorCount", 0), c(this, "nodeRegistry", /* @__PURE__ */ new WeakSet());
+    for (const e of Object.values(v))
+      typeof e == "number" && this.updateQueues.set(e, /* @__PURE__ */ new Set());
+  }
+  static getInstance() {
+    return m.instance || (m.instance = new m()), m.instance;
+  }
+  /**
+   * Schedule reactive node for update
+   */
+  schedule(e) {
+    if (this.isDestroyed) return;
+    this.nodeRegistry.add(e), this.getQueue(e.priority).add(e), this.isFlushPending || (this.isFlushPending = !0, this.scheduleFlush(e.priority));
+  }
+  /**
+   * Process all queued updates by priority
+   */
+  async flush() {
+    if (this.isDestroyed) return;
+    this.isFlushPending = !1;
+    const e = performance.now();
+    try {
+      for (const s of [
+        0,
+        1,
+        2,
+        3,
+        4
+        /* Idle */
+      ]) {
+        const r = this.updateQueues.get(s);
+        if (!r || r.size === 0) continue;
+        const i = Array.from(r);
+        r.clear();
+        for (const u of i)
+          try {
+            await this.updateNodeWithRetry(u);
+          } catch (l) {
+            this.handleReactiveError(
+              new Z(`Failed to update ${u.type} node ${u.id}`, l, u)
+            );
+          }
+        if (this.hasHigherPriorityWork(s))
+          return this.flush();
+      }
+      this.totalUpdateCycles++;
+    } finally {
+      const s = performance.now();
+      this.totalUpdateTime += s - e;
+    }
+  }
+  /**
+   * Update node with retry logic
+   */
+  async updateNodeWithRetry(e, s = 1) {
+    try {
+      e.notify();
+    } catch (r) {
+      if (s < this.maxRetries)
+        return console.warn(`Reactive update failed, retrying (${s}/${this.maxRetries})`), await new Promise((i) => setTimeout(i, s * 10)), this.updateNodeWithRetry(e, s + 1);
+      throw r;
+    }
+  }
+  /**
+   * Schedule flush based on priority
+   */
+  scheduleFlush(e) {
+    switch (e) {
+      case 0:
+        this.flush();
+        break;
+      case 1:
+        queueMicrotask(() => this.flush());
+        break;
+      case 2:
+        typeof requestAnimationFrame < "u" ? requestAnimationFrame(() => this.flush()) : queueMicrotask(() => this.flush());
+        break;
+      case 3:
+      case 4:
+        typeof requestIdleCallback < "u" ? requestIdleCallback(() => this.flush(), { timeout: 1e3 }) : setTimeout(() => this.flush(), 50);
+        break;
+    }
+  }
+  /**
+   * Check if there's higher priority work waiting
+   */
+  hasHigherPriorityWork(e) {
+    for (let s = 0; s < e; s++) {
+      const r = this.updateQueues.get(s);
+      if (r && r.size > 0)
+        return !0;
+    }
+    return !1;
+  }
+  /**
+   * Get queue for priority level
+   */
+  getQueue(e) {
+    const s = this.updateQueues.get(e);
+    if (!s)
+      throw new Error(`Invalid priority level: ${e}`);
+    return s;
+  }
+  /**
+   * Register error handler
+   */
+  onError(e) {
+    return this.errorHandlers.add(e), () => this.errorHandlers.delete(e);
+  }
+  /**
+   * Handle reactive errors with recovery
+   */
+  handleReactiveError(e) {
+    this.errorCount++;
+    let s = !1;
+    for (const r of this.errorHandlers)
+      try {
+        r(e), s = !0;
+      } catch (i) {
+        console.error("Error handler threw error:", i);
+      }
+    if (!s && (console.error("Unhandled reactive error:", e), process.env.NODE_ENV === "development"))
+      throw e;
+  }
+  /**
+   * Get performance metrics
+   */
+  getPerformanceMetrics() {
+    let e = 0;
+    for (const s of this.updateQueues.values())
+      e += s.size;
+    return {
+      totalNodes: e,
+      updateCycles: this.totalUpdateCycles,
+      averageUpdateTime: this.totalUpdateCycles > 0 ? this.totalUpdateTime / this.totalUpdateCycles : 0,
+      memoryUsage: this.estimateMemoryUsage(),
+      errorCount: this.errorCount
+    };
+  }
+  /**
+   * Estimate memory usage (rough approximation)
+   */
+  estimateMemoryUsage() {
+    let e = 0;
+    for (const s of this.updateQueues.values())
+      e += s.size * 50;
+    return e += this.errorHandlers.size * 100, e;
+  }
+  /**
+   * Check if node is scheduled
+   */
+  hasNode(e) {
+    for (const s of this.updateQueues.values())
+      if (s.has(e))
+        return !0;
+    return !1;
+  }
+  /**
+   * Flush all pending updates synchronously
+   */
+  flushSync() {
+    this.isFlushPending && (this.isFlushPending = !1, this.flush());
+  }
+  /**
+   * Clear all pending updates
+   */
+  clearPending() {
+    for (const e of this.updateQueues.values())
+      e.clear();
+    this.isFlushPending = !1;
+  }
+  /**
+   * Cleanup all reactive nodes and destroy scheduler
+   */
+  destroy() {
+    this.isDestroyed = !0;
+    for (const e of this.updateQueues.values()) {
+      for (const s of e)
+        try {
+          s.cleanup();
+        } catch (r) {
+          console.error("Error cleaning up reactive node:", r);
+        }
+      e.clear();
+    }
+    this.updateQueues.clear(), this.errorHandlers.clear(), m.instance = null;
+  }
+  /**
+   * Get debug information
+   */
+  getDebugInfo() {
+    const e = {};
+    for (const [s, r] of this.updateQueues)
+      e[v[s]] = r.size;
+    return {
+      isFlushPending: this.isFlushPending,
+      isDestroyed: this.isDestroyed,
+      queueSizes: e,
+      errorHandlerCount: this.errorHandlers.size,
+      performance: this.getPerformanceMetrics()
+    };
+  }
+};
+c(M, "instance", null);
+let De = M;
+var ee = Object.defineProperty, te = (t, e, s) => e in t ? ee(t, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : t[e] = s, p = (t, e, s) => te(t, typeof e != "symbol" ? e + "" : e, s);
+class se extends V {
+  constructor(e, s = {}, r = N()) {
+    super(e, r), p(this, "type", "computed"), p(this, "priority"), p(this, "_hasValue", !1), p(this, "_error", null), p(this, "equalsFn"), p(this, "options"), this.priority = s.priority ?? v.Normal, this.equalsFn = s.equals ?? w, this.options = s;
+  }
+  /**
+   * Get the computed value, tracking dependency and lazily computing
+   */
+  getValue() {
+    const e = I();
+    return e && e.state !== n.Disposed && (this.observers.add(e), e.sources.add(this)), (this.state === n.Dirty || !this._hasValue) && (this.execute(), this._hasValue = !0), this.value;
+  }
+  /**
+   * Get the current value without tracking dependency
+   */
+  peek() {
+    return (this.state === n.Dirty || !this._hasValue) && (this.execute(), this._hasValue = !0), this.value;
+  }
+  /**
+   * Remove an observer (cleanup)
+   */
+  removeObserver(e) {
+    this.observers.delete(e);
+  }
+  /**
+   * Execute the computation and notify observers
+   */
+  execute() {
+    const e = this._hasValue ? this.value : void 0, s = super.execute();
+    if (!this._hasValue || !this.equalsFn(e, s))
+      for (const r of this.observers)
+        r.state !== n.Disposed && (r.state = n.Dirty, "execute" in r && typeof r.execute == "function" && queueMicrotask(() => {
+          r.state === n.Dirty && r.execute();
+        }));
+    return s;
+  }
+  /**
+   * Notify method for ReactiveNode compatibility
+   */
+  notify() {
+    this.execute();
+  }
+  /**
+   * Complete cleanup for memory management
+   */
+  cleanup() {
+    for (const e of this.sources)
+      "removeObserver" in e && e.removeObserver(this);
+    this.sources.clear();
+    for (const e of this.observers)
+      e.sources.delete(this);
+    this.observers.clear(), this._hasValue = !1, this._error = null, this.state = n.Disposed;
+  }
+  /**
+   * Dispose the computed value
+   */
+  dispose() {
+    this.cleanup(), super.dispose();
+  }
+  /**
+   * Debug information
+   */
+  [Symbol.for("tachui.debug")]() {
+    return {
+      id: this.id,
+      type: this.type,
+      value: this._hasValue ? this.value : void 0,
+      hasValue: this._hasValue,
+      error: this._error?.message,
+      state: this.state,
+      sourceCount: this.sources.size,
+      observerCount: this.observers.size,
+      priority: v[this.priority],
+      debugName: this.options.debugName,
+      equalsFn: this.equalsFn.name || "anonymous"
+    };
+  }
+  toString() {
+    return `Computed(${this.options.debugName || this.id}): ${this._hasValue ? this.value : "no value"}`;
+  }
+}
+function g(t, e) {
+  const s = new se(t, e), r = s.getValue.bind(s);
+  return r.peek = s.peek.bind(s), Object.defineProperty(r, Symbol.for("tachui.computed"), {
+    value: s,
+    enumerable: !1
+  }), r;
+}
+function Oe(t, e) {
+  return g(t, e);
+}
+function Ie(t) {
+  return typeof t == "function" && Symbol.for("tachui.computed") in t;
+}
+function Ne(t) {
+  return t[Symbol.for("tachui.computed")] || null;
+}
+function Ve(t, e) {
+  return g(e ? () => {
+    for (const r of e)
+      r();
+    return t();
+  } : t);
+}
+function ke(t, e) {
+  let s, r = !1;
+  return g(() => (e() && (s = t(), r = !0), r || (s = t(), r = !0), s));
+}
+const [x, re] = K("light");
+function Me() {
+  const t = x();
+  return t === "system" ? $() : t;
+}
+function xe(t) {
+  re(t);
+}
+const ie = g(() => {
+  const t = x();
+  return t === "system" ? $() : t;
+});
+function $e() {
+  return ie;
+}
+function $() {
+  return typeof window < "u" && window.matchMedia && window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+}
+function q(t) {
+  const e = N();
+  e && !e.disposed ? e.cleanups.push(t) : __DEV__ && console.warn("onCleanup called outside of reactive context");
+}
+function ze(t) {
+  "dispose" in t && typeof t.dispose == "function" && t.dispose();
+}
+function Re(t) {
+  const [e, s] = t();
+  return q(s), e;
+}
+function Ae() {
+  const t = [];
+  let e = !1;
+  return {
+    add(s) {
+      if (e) {
+        __DEV__ && console.warn("Adding cleanup to disposed group");
+        return;
+      }
+      t.push(s);
+    },
+    dispose() {
+      if (!e) {
+        e = !0;
+        for (const s of t)
+          try {
+            s();
+          } catch (r) {
+            console.error("Error in cleanup function:", r);
+          }
+        t.length = 0;
+      }
+    },
+    get disposed() {
+      return e;
+    }
+  };
+}
+function je(t, e) {
+  const s = setTimeout(t, e);
+  return q(() => clearTimeout(s)), s;
+}
+function Pe(t, e) {
+  const s = setInterval(t, e);
+  return q(() => clearInterval(s)), s;
+}
+function Te(t, e, s, r) {
+  t.addEventListener(e, s, r), q(() => t.removeEventListener(e, s, r));
+}
+typeof globalThis.__DEV__ > "u" && (globalThis.__DEV__ = process.env.NODE_ENV !== "production");
+var ne = Object.defineProperty, ue = (t, e, s) => e in t ? ne(t, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : t[e] = s, y = (t, e, s) => ue(t, typeof e != "symbol" ? e + "" : e, s);
+class z {
+  constructor() {
+    y(this, "pending", /* @__PURE__ */ new Set()), y(this, "isFlushScheduled", !1);
+  }
+  schedule(e) {
+    this.pending.add(e), this.isFlushScheduled || (this.isFlushScheduled = !0, queueMicrotask(() => this.flush()));
+  }
+  flush() {
+    if (this.pending.size === 0) {
+      this.isFlushScheduled = !1;
+      return;
+    }
+    const e = Array.from(this.pending);
+    this.pending.clear(), this.isFlushScheduled = !1;
+    for (const s of e)
+      try {
+        s();
+      } catch (r) {
+        console.error("Error in scheduled task:", r);
+      }
+    this.pending.size > 0 && (this.isFlushScheduled = !0, queueMicrotask(() => this.flush()));
+  }
+}
+class oe {
+  schedule(e) {
+    try {
+      e();
+    } catch (s) {
+      console.error("Error in sync scheduled task:", s);
+    }
+  }
+  flush() {
+  }
+}
+var R = /* @__PURE__ */ ((t) => (t[t.Immediate = 0] = "Immediate", t[t.High = 1] = "High", t[t.Normal = 2] = "Normal", t[t.Low = 3] = "Low", t[t.Idle = 4] = "Idle", t))(R || {});
+class ae {
+  constructor() {
+    y(this, "queues", /* @__PURE__ */ new Map()), y(this, "taskIdCounter", 0), y(this, "isFlushScheduled", !1);
+    for (const e of Object.values(R))
+      typeof e == "number" && this.queues.set(e, /* @__PURE__ */ new Set());
+  }
+  schedule(e, s = 2) {
+    const r = {
+      fn: e,
+      priority: s,
+      id: ++this.taskIdCounter
+    }, i = this.queues.get(s);
+    i && i.add(r), this.isFlushScheduled || (this.isFlushScheduled = !0, s === 0 ? this.flush() : queueMicrotask(() => this.flush()));
+  }
+  flush() {
+    this.isFlushScheduled = !1;
+    for (const e of [
+      0,
+      1,
+      2,
+      3,
+      4
+      /* Idle */
+    ]) {
+      const s = this.queues.get(e);
+      if (!s || s.size === 0) continue;
+      const r = Array.from(s).sort((i, u) => i.id - u.id);
+      s.clear();
+      for (const i of r)
+        try {
+          i.fn();
+        } catch (u) {
+          console.error(`Error in priority ${e} task:`, u);
+        }
+      if (s.size === 0 && this.hasMoreTasks()) {
+        queueMicrotask(() => this.flush());
+        return;
+      }
+    }
+  }
+  hasMoreTasks() {
+    for (const e of this.queues.values())
+      if (e.size > 0) return !0;
+    return !1;
+  }
+}
+let f = new z();
+function Qe() {
+  return f;
+}
+function He(t) {
+  f = t;
+}
+function Be(t = !0) {
+  t ? f = new z() : f = new oe();
+}
+function Ue(t) {
+  f.schedule(t);
+}
+function We(t, e) {
+  f instanceof ae ? f.schedule(t, e) : f.schedule(t);
+}
+function Le(t) {
+  typeof requestIdleCallback < "u" ? requestIdleCallback(t) : setTimeout(t, 0);
+}
+export {
+  v as $,
+  Re as A,
+  je as B,
+  V as C,
+  ye as D,
+  Ee as E,
+  Se as F,
+  Ce as G,
+  qe as H,
+  Fe as I,
+  E as J,
+  w as K,
+  we as L,
+  be as M,
+  _e as N,
+  Be as O,
+  Qe as P,
+  Le as Q,
+  Ue as R,
+  We as S,
+  He as T,
+  R as U,
+  $ as V,
+  Me as W,
+  $e as X,
+  xe as Y,
+  Z,
+  De as _,
+  K as a,
+  n as a0,
+  g as b,
+  Ae as c,
+  ze as d,
+  Oe as e,
+  k as f,
+  ge as g,
+  Ie as h,
+  ve as i,
+  Ne as j,
+  Ve as k,
+  ke as l,
+  I as m,
+  N as n,
+  q as o,
+  Q as p,
+  le as q,
+  ce as r,
+  he as s,
+  B as t,
+  fe as u,
+  de as v,
+  pe as w,
+  me as x,
+  Te as y,
+  Pe as z
+};