@tachui/core 0.8.22 → 0.8.24

package/dist/{component-D-O9yq0P.js → component-BzvSm8rM.js}

@@ -1,8 +1,8 @@
-import { o as x } from "./scheduler-DppMK9mR.js";
-import { c as P, a as _ } from "./theme-CRLPHryV.js";
-import "@tachui/types/reactive";
-import { c as h } from "./effect-BsW3fy1q.js";
-import { b as K, r as $ } from "./component-context-B9HI2nZH.js";
+import { o as x } from "./cleanup-BR8UpYPX.js";
+import { c as h } from "./effect-DgNm6jk9.js";
+import { b as _, r as K } from "./component-context-C7Y6Xu6h.js";
+import { c as $ } from "./computed-CA4Cgtoe.js";
+import { d as P } from "./signal-BRoiFOO7.js";
 var Q = Object.defineProperty, N = (n, e, r) => e in n ? Q(n, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : n[e] = r, p = (n, e, r) => N(n, typeof e != "symbol" ? e + "" : e, r);
 class b {
   constructor(e, r) {
@@ -48,7 +48,7 @@ class b {
    * Create reactive computed for a specific prop
    */
   createPropComputed(e) {
-    return _(() => this.getProps()[e]);
+    return $(() => this.getProps()[e]);
   }
   /**
    * Create effect that runs when specific props change
@@ -360,14 +360,14 @@ u(E, "instance");
 let F = E;
 function m(n, e = {}) {
   const r = (t) => {
-    const o = R(), i = F.getInstance(), s = [], l = K(o), C = new b(t, {
+    const o = R(), i = F.getInstance(), s = [], l = _(o), C = new b(t, {
       defaults: e.defaultProps || void 0,
       ...e.validation
     }), w = new d(t.children), U = new g();
     let c, A = !1, v = !1;
     const M = {
       type: "component",
-      render: () => $(l, () => {
+      render: () => K(l, () => {
         if (e.lifecycle?.onMount && !A) {
           const a = e.lifecycle.onMount();
           typeof a == "function" && s.push(a), A = !0;
@@ -482,18 +482,18 @@ export {
   F as C,
   b as P,
   g as R,
-  J as a,
-  X as b,
-  m as c,
-  Y as d,
-  Z as e,
-  ee as f,
-  re as g,
-  d as h,
+  m as a,
+  Z as b,
+  Y as c,
+  J as d,
+  ee as e,
+  re as f,
+  d as g,
+  T as h,
   G as i,
-  T as j,
-  W as k,
-  z as l,
+  W as j,
+  z as k,
+  X as l,
   S as p,
   H as w
 };

package/dist/{component-base-C41K3NTe.js → component-base-Do2EdQkr.js}

@@ -1,6 +1,5 @@
-import "./scheduler-DppMK9mR.js";
-import { i as n, d as f, a as h } from "./theme-CRLPHryV.js";
-import "@tachui/types/reactive";
+import { i as f, c as h } from "./computed-CA4Cgtoe.js";
+import { i as n } from "./signal-BRoiFOO7.js";
 var g = Object.defineProperty, u = (i, s, e) => s in i ? g(i, s, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[s] = e, o = (i, s, e) => u(i, typeof s != "symbol" ? s + "" : s, e);
 const d = {
   sanitizeClassNames: !0,
@@ -84,8 +83,8 @@ class p {
   processClasses(s) {
     if (!s) return [];
     if (n(s) || f(s)) {
-      const r = s();
-      return this.processClasses(r);
+      const a = s();
+      return this.processClasses(a);
     }
     const e = this.getCacheKey(s);
     if (this.config.enableCaching && this.cacheHas(this.classCache, e))
@@ -94,18 +93,18 @@ class p {
     if (typeof s == "string")
       t = s.trim().split(/\s+/).filter(Boolean);
     else if (Array.isArray(s))
-      t = s.flatMap((r) => {
-        if (r == null || r === "")
+      t = s.flatMap((a) => {
+        if (a == null || a === "")
           return [];
-        const c = (typeof r == "string" ? r : String(r)).trim();
-        return typeof r != "string" && c ? [c] : c.split(/\s+/);
+        const c = (typeof a == "string" ? a : String(a)).trim();
+        return typeof a != "string" && c ? [c] : c.split(/\s+/);
       }).filter(Boolean);
     else {
-      const r = String(s).trim();
-      t = r ? [r] : [];
+      const a = String(s).trim();
+      t = a ? [a] : [];
     }
-    const a = this.processClassArray(t);
-    return this.config.enableCaching && this.setCachedClasses(e, a), a;
+    const r = this.processClassArray(t);
+    return this.config.enableCaching && this.setCachedClasses(e, r), r;
   }
   /**
    * Process an array of class names
@@ -114,7 +113,7 @@ class p {
     let e = s;
     return this.config.sanitizeClassNames && (e = e.map((t) => this.sanitizeClassName(t))), e = this.deduplicateClasses(e), this.config.warnDuplicateClasses && s.length !== e.length && console.warn(
       "[tachUI] Duplicate CSS classes detected and removed:",
-      s.filter((t, a) => s.indexOf(t) !== a)
+      s.filter((t, r) => s.indexOf(t) !== r)
     ), e;
   }
   /**
@@ -124,11 +123,11 @@ class p {
     if (!s || typeof s != "string") return "";
     const e = this.config.sanitizationRules;
     let t = s.trim();
-    t.includes(" ") && (t = t.replace(/\s+/g, "-"), this.config.warnInvalidClasses && console.warn(`[tachUI] CSS class names cannot contain spaces. Converted "${s}" to "${t}"`)), Object.entries(e.customReplacements || {}).forEach(([r, C]) => {
-      t = t.replace(new RegExp(r, "g"), C);
+    t.includes(" ") && (t = t.replace(/\s+/g, "-"), this.config.warnInvalidClasses && console.warn(`[tachUI] CSS class names cannot contain spaces. Converted "${s}" to "${t}"`)), Object.entries(e.customReplacements || {}).forEach(([a, C]) => {
+      t = t.replace(new RegExp(a, "g"), C);
     });
-    let a = "a-zA-Z\\-\\.";
-    return e.allowNumbers && (a += "0-9"), e.allowUnderscores && (a += "_"), a += ":\\[\\]/%", t = t.replace(new RegExp(`[^${a}]`, "g"), "-"), /^[0-9]/.test(t) && (t = "cls-" + t), t = t.replace(/---+/g, "--"), this.config.warnInvalidClasses && t !== s.trim() && console.warn(`[tachUI] CSS class "${s}" sanitized to "${t}"`), t;
+    let r = "a-zA-Z\\-\\.";
+    return e.allowNumbers && (r += "0-9"), e.allowUnderscores && (r += "_"), r += ":\\[\\]/%", t = t.replace(new RegExp(`[^${r}]`, "g"), "-"), /^[0-9]/.test(t) && (t = "cls-" + t), t = t.replace(/---+/g, "--"), this.config.warnInvalidClasses && t !== s.trim() && console.warn(`[tachUI] CSS class "${s}" sanitized to "${t}"`), t;
   }
   /**
    * Deduplicate classes while preserving first occurrence order
@@ -141,8 +140,8 @@ class p {
    * User classes come AFTER tachUI classes for proper CSS cascade
    */
   combineClasses(s, e) {
-    const t = this.processClasses(e), a = [...s, ...t];
-    return this.deduplicateClasses(a);
+    const t = this.processClasses(e), r = [...s, ...t];
+    return this.deduplicateClasses(r);
   }
   /**
    * Update configuration
@@ -184,21 +183,21 @@ class p {
    */
   setCachedClasses(s, e) {
     if (this.cacheSize(this.classCache) >= this.config.maxCacheSize) {
-      const t = this.cacheKeys(this.classCache), a = Array.isArray(t) ? t[0] : t.next().value;
-      a !== void 0 && this.cacheDelete(this.classCache, a);
+      const t = this.cacheKeys(this.classCache), r = Array.isArray(t) ? t[0] : t.next().value;
+      r !== void 0 && this.cacheDelete(this.classCache, r);
     }
     this.cacheSet(this.classCache, s, e);
   }
 }
 const l = new p();
-function v(i) {
+function w(i) {
   l.updateConfig(i);
 }
-function z() {
+function v() {
   return l.getConfig();
 }
 var m = Object.defineProperty, y = (i, s, e) => s in i ? m(i, s, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[s] = e, S = (i, s, e) => y(i, s + "", e);
-class M {
+class z {
   constructor() {
     S(this, "cssClassManager", l);
   }
@@ -231,27 +230,27 @@ class M {
       return;
     const e = s.css;
     if (typeof e == "string" || Array.isArray(e) || n(e) || console.warn("[tachUI] css must be a string, array of strings, or signal. Got:", typeof e), Array.isArray(e)) {
-      const a = e.filter((r) => typeof r != "string");
-      a.length > 0 && console.warn("[tachUI] All items in css array must be strings. Invalid items:", a);
+      const r = e.filter((a) => typeof a != "string");
+      r.length > 0 && console.warn("[tachUI] All items in css array must be strings. Invalid items:", r);
     }
   }
   /**
    * Get debug information about processed classes
    */
   getClassDebugInfo(s, e = []) {
-    const t = s.css ? this.cssClassManager.processClasses(s.css) : [], a = this.processComponentClasses(s, e);
+    const t = s.css ? this.cssClassManager.processClasses(s.css) : [], r = this.processComponentClasses(s, e);
     return {
       base: e,
       user: t,
-      processed: a,
-      final: a.join(" ")
+      processed: r,
+      final: r.join(" ")
     };
   }
 }
 export {
   p as C,
-  v as a,
-  M as b,
+  w as a,
+  z as b,
   l as c,
-  z as g
+  v as g
 };

package/dist/{component-context-B9HI2nZH.js → component-context-C7Y6Xu6h.js}

@@ -1,4 +1,4 @@
-import { l as u } from "./theme-CRLPHryV.js";
+import { j as u } from "./signal-BRoiFOO7.js";
 var d = Object.defineProperty, l = (e, t, n) => t in e ? d(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n, r = (e, t, n) => l(e, typeof t != "symbol" ? t + "" : t, n);
 const a = Symbol("TachUI.ComponentContext"), v = Symbol("TachUI.Environment");
 let o = null;

package/dist/components/index.js

@@ -1,4 +1,4 @@
-import { L as o, b as t, f as r, c as n, a as p, w as s, d as i, e as c } from "../factory-gqfMcmOy.js";
+import { h as o, L as t, g as r, b as n, d as p, w as s, e as i, f as c } from "../factory-B1YXfgU1.js";
 export {
   o as Layout,
   t as LayoutComponent,

package/dist/computed-CA4Cgtoe.js

@@ -0,0 +1,407 @@
+import { C as b, j as q, h as C } from "./signal-BRoiFOO7.js";
+import { ComputationState as a } from "@tachui/types/reactive";
+const d = (s, e) => s === e, p = (s, e) => {
+  if (s === e) return !0;
+  if (s == null || e == null || typeof s != typeof e) return !1;
+  if (typeof s == "object") {
+    if (Array.isArray(s) !== Array.isArray(e)) return !1;
+    if (Array.isArray(s)) {
+      const u = s, y = e;
+      return u.length !== y.length ? !1 : u.every((v, g) => p(v, y[g]));
+    }
+    const t = s, r = e, i = Object.keys(t), o = Object.keys(r);
+    return i.length !== o.length ? !1 : i.every((u) => p(t[u], r[u]));
+  }
+  return !1;
+}, V = (s, e) => {
+  if (s === e) return !0;
+  if (typeof s != "object" || typeof e != "object" || s == null || e == null) return !1;
+  const t = s, r = e, i = Object.keys(t), o = Object.keys(r);
+  return i.length !== o.length ? !1 : i.every((u) => t[u] === r[u]);
+}, k = (s, e) => {
+  if (s === e) return !0;
+  if (s instanceof Date && e instanceof Date)
+    return s.getTime() === e.getTime();
+  if (s instanceof RegExp && e instanceof RegExp)
+    return s.toString() === e.toString();
+  if (s instanceof Set && e instanceof Set) {
+    if (s.size !== e.size) return !1;
+    for (const t of s)
+      if (!e.has(t)) return !1;
+    return !0;
+  }
+  if (s instanceof Map && e instanceof Map) {
+    if (s.size !== e.size) return !1;
+    for (const [t, r] of s)
+      if (!e.has(t) || e.get(t) !== r) return !1;
+    return !0;
+  }
+  return p(s, e);
+}, j = (s, e) => {
+  if (s === e) return !0;
+  try {
+    return JSON.stringify(s) === JSON.stringify(e);
+  } catch {
+    return s === e;
+  }
+}, x = (s, e = d) => (t, r) => e(s(t), s(r)), z = (s = d) => (e, t) => e === t ? !0 : e.length !== t.length ? !1 : e.every((r, i) => s(r, t[i])), A = (s = d) => (e, t) => {
+  if (e === t) return !0;
+  if (e == null || t == null) return !1;
+  const r = Object.keys(e), i = Object.keys(t);
+  return r.length !== i.length ? !1 : r.every((o) => s(e[o], t[o]));
+}, I = (...s) => (e, t) => s.every((r) => r(e, t)), Q = (s, e) => (t, r) => {
+  const i = s(t, r);
+  return process.env.NODE_ENV === "development" && console.log(`[${e || "equals"}]`, { a: t, b: r, equal: i }), i;
+};
+var w = Object.defineProperty, O = (s, e, t) => e in s ? w(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t, n = (s, e, t) => O(s, typeof e != "symbol" ? e + "" : e, t), h = /* @__PURE__ */ ((s) => (s[s.Immediate = 0] = "Immediate", s[s.High = 1] = "High", s[s.Normal = 2] = "Normal", s[s.Low = 3] = "Low", s[s.Idle = 4] = "Idle", s))(h || {});
+class E extends Error {
+  constructor(e, t, r) {
+    super(e), this.cause = t, this.node = r, this.name = "ReactiveError";
+  }
+}
+const m = class c {
+  constructor() {
+    n(this, "updateQueues", /* @__PURE__ */ new Map()), n(this, "isFlushPending", !1), n(this, "isDestroyed", !1), n(this, "errorHandlers", /* @__PURE__ */ new Set()), n(this, "maxRetries", 3), n(this, "totalUpdateCycles", 0), n(this, "totalUpdateTime", 0), n(this, "errorCount", 0), n(this, "nodeRegistry", /* @__PURE__ */ new WeakSet());
+    for (const e of Object.values(h))
+      typeof e == "number" && this.updateQueues.set(e, /* @__PURE__ */ new Set());
+  }
+  static getInstance() {
+    return c.instance || (c.instance = new c()), c.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 t of [
+        0,
+        1,
+        2,
+        3,
+        4
+        /* Idle */
+      ]) {
+        const r = this.updateQueues.get(t);
+        if (!r || r.size === 0) continue;
+        const i = Array.from(r);
+        r.clear();
+        for (const o of i)
+          try {
+            await this.updateNodeWithRetry(o);
+          } catch (u) {
+            this.handleReactiveError(
+              new E(`Failed to update ${o.type} node ${o.id}`, u, o)
+            );
+          }
+        if (this.hasHigherPriorityWork(t))
+          return this.flush();
+      }
+      this.totalUpdateCycles++;
+    } finally {
+      const t = performance.now();
+      this.totalUpdateTime += t - e;
+    }
+  }
+  /**
+   * Update node with retry logic
+   */
+  async updateNodeWithRetry(e, t = 1) {
+    try {
+      e.notify();
+    } catch (r) {
+      if (t < this.maxRetries)
+        return console.warn(`Reactive update failed, retrying (${t}/${this.maxRetries})`), await new Promise((i) => setTimeout(i, t * 10)), this.updateNodeWithRetry(e, t + 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 t = 0; t < e; t++) {
+      const r = this.updateQueues.get(t);
+      if (r && r.size > 0)
+        return !0;
+    }
+    return !1;
+  }
+  /**
+   * Get queue for priority level
+   */
+  getQueue(e) {
+    const t = this.updateQueues.get(e);
+    if (!t)
+      throw new Error(`Invalid priority level: ${e}`);
+    return t;
+  }
+  /**
+   * Register error handler
+   */
+  onError(e) {
+    return this.errorHandlers.add(e), () => this.errorHandlers.delete(e);
+  }
+  /**
+   * Handle reactive errors with recovery
+   */
+  handleReactiveError(e) {
+    this.errorCount++;
+    let t = !1;
+    for (const r of this.errorHandlers)
+      try {
+        r(e), t = !0;
+      } catch (i) {
+        console.error("Error handler threw error:", i);
+      }
+    if (!t && (console.error("Unhandled reactive error:", e), process.env.NODE_ENV === "development"))
+      throw e;
+  }
+  /**
+   * Get performance metrics
+   */
+  getPerformanceMetrics() {
+    let e = 0;
+    for (const t of this.updateQueues.values())
+      e += t.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 t of this.updateQueues.values())
+      e += t.size * 50;
+    return e += this.errorHandlers.size * 100, e;
+  }
+  /**
+   * Check if node is scheduled
+   */
+  hasNode(e) {
+    for (const t of this.updateQueues.values())
+      if (t.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 t of e)
+        try {
+          t.cleanup();
+        } catch (r) {
+          console.error("Error cleaning up reactive node:", r);
+        }
+      e.clear();
+    }
+    this.updateQueues.clear(), this.errorHandlers.clear(), c.instance = null;
+  }
+  /**
+   * Get debug information
+   */
+  getDebugInfo() {
+    const e = {};
+    for (const [t, r] of this.updateQueues)
+      e[h[t]] = r.size;
+    return {
+      isFlushPending: this.isFlushPending,
+      isDestroyed: this.isDestroyed,
+      queueSizes: e,
+      errorHandlerCount: this.errorHandlers.size,
+      performance: this.getPerformanceMetrics()
+    };
+  }
+};
+n(m, "instance", null);
+let P = m;
+var S = Object.defineProperty, _ = (s, e, t) => e in s ? S(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t, l = (s, e, t) => _(s, typeof e != "symbol" ? e + "" : e, t);
+class F extends b {
+  constructor(e, t = {}, r = q()) {
+    super(e, r), l(this, "type", "computed"), l(this, "priority"), l(this, "_hasValue", !1), l(this, "_error", null), l(this, "equalsFn"), l(this, "options"), this.priority = t.priority ?? h.Normal, this.equalsFn = t.equals ?? d, this.options = t;
+  }
+  /**
+   * Get the computed value, tracking dependency and lazily computing
+   */
+  getValue() {
+    const e = C();
+    return e && e.state !== a.Disposed && (this.observers.add(e), e.sources.add(this)), (this.state === a.Dirty || !this._hasValue) && (this.execute(), this._hasValue = !0), this.value;
+  }
+  /**
+   * Get the current value without tracking dependency
+   */
+  peek() {
+    return (this.state === a.Dirty || !this._hasValue) && (this.execute(), this._hasValue = !0), this.value;
+  }
+  /**
+   * Remove an observer (cleanup)
+   */
+  removeObserver(e) {
+    this.observers.delete(e), this.options.releaseOnNoObservers === !0 && this.observers.size === 0 && e.state === a.Disposed && this.releaseSources();
+  }
+  releaseSources() {
+    for (const e of this.sources)
+      "removeObserver" in e && e.removeObserver(this);
+    this.sources.clear(), this._hasValue = !1, this.state = a.Dirty;
+  }
+  /**
+   * Execute the computation and notify observers
+   */
+  execute() {
+    const e = this._hasValue ? this.value : void 0, t = super.execute();
+    if (!this._hasValue || !this.equalsFn(e, t))
+      for (const r of this.observers)
+        r.state !== a.Disposed && (r.state = a.Dirty, "execute" in r && typeof r.execute == "function" && queueMicrotask(() => {
+          r.state === a.Dirty && r.execute();
+        }));
+    return t;
+  }
+  /**
+   * 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 = a.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: h[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 f(s, e) {
+  const t = new F(s, e), r = t.getValue.bind(t);
+  return r.peek = t.peek.bind(t), Object.defineProperty(r, Symbol.for("tachui.computed"), {
+    value: t,
+    enumerable: !1
+  }), r;
+}
+function H(s, e) {
+  return f(s, e);
+}
+function M(s) {
+  return typeof s == "function" && Symbol.for("tachui.computed") in s;
+}
+function N(s) {
+  return s[Symbol.for("tachui.computed")] || null;
+}
+function T(s) {
+  const e = N(s);
+  !e || e.observers.size !== 0 || e.releaseSources();
+}
+function $(s, e) {
+  return f(e ? () => {
+    for (const r of e)
+      r();
+    return s();
+  } : s);
+}
+function U(s, e) {
+  let t, r = !1;
+  return f(() => (e() && (t = s(), r = !0), r || (t = s(), r = !0), t));
+}
+export {
+  E as R,
+  h as U,
+  H as a,
+  I as b,
+  f as c,
+  z as d,
+  A as e,
+  x as f,
+  Q as g,
+  p as h,
+  M as i,
+  d as j,
+  j as k,
+  k as l,
+  P as m,
+  N as n,
+  $ as o,
+  U as p,
+  T as r,
+  V as s
+};