@tachui/core 0.7.1-alpha → 0.8.0-alpha

package/dist/index-Nfi2SBQh.js

@@ -1,3268 +0,0 @@
-import { a0 as S, i as m, X as $, T as I, dg as h, db as E, dd as R, da as ye, dp as ne, ds as G, _ as z, A as se, dN as be, dO as Ce } from "./concatenated-component-DPcl2TEO.js";
-import { a as j, b, e as ve, i as T, n as ie } from "./scheduler-7SvC3a21.js";
-import { aC as y, aF as q, aE as H, b0 as A } from "./Spacer-BbteDQ9I.js";
-import { c as v } from "./effect-CytAc9em.js";
-import { n as we, R as Se, L as xe } from "./binding-CmdpowkI.js";
-import { i as D, j as Ee, p as _e, f as Oe } from "./dom-bridge-Cx-s6Ihx.js";
-import "./context--zQFIImS.js";
-import "./components/index.js";
-import "./ScrollView-h-6wYMAm.js";
-import "./plugins/index.js";
-import "./debug.js";
-import "./validation/index.js";
-function Y() {
-  return new S({
-    frame: {
-      maxWidth: m
-    }
-  });
-}
-function ae() {
-  return new S({
-    frame: {
-      maxHeight: m
-    }
-  });
-}
-function oe() {
-  return new S({
-    frame: {
-      maxWidth: m,
-      maxHeight: m
-    }
-  });
-}
-function ce() {
-  return new S({
-    frame: {
-      width: m,
-      height: m
-    }
-  });
-}
-function ke(n) {
-  return new S({
-    frame: {
-      width: n,
-      maxHeight: m
-    }
-  });
-}
-function Re(n) {
-  return new S({
-    frame: {
-      height: n,
-      maxWidth: m
-    }
-  });
-}
-function Te(n, e) {
-  return new S({
-    frame: {
-      width: m,
-      height: m,
-      maxWidth: n,
-      maxHeight: e
-    }
-  });
-}
-function Me(n, e, t, r) {
-  return new S({
-    frame: {
-      width: m,
-      height: m,
-      minWidth: n,
-      maxWidth: e,
-      minHeight: t,
-      maxHeight: r
-    }
-  });
-}
-function je() {
-  return new S({
-    frame: {
-      maxWidth: m,
-      maxHeight: m
-    }
-  });
-}
-function le() {
-  return new S({
-    frame: {
-      width: "100vw",
-      height: "100vh"
-    }
-  });
-}
-function Pe() {
-  return new S({
-    frame: {
-      width: m,
-      height: m
-    }
-  });
-}
-function Ae() {
-  return new S({
-    frame: {
-      width: m
-    }
-  });
-}
-const Gt = Symbol.for("tachui.concat");
-function Ht(n) {
-  return n && typeof n == "object" && typeof n.isConcatenatable == "function" && n.isConcatenatable();
-}
-function qt(n) {
-  return n && typeof n == "object" && n.constructor.name === "ConcatenatedComponent";
-}
-const Kt = Symbol.for("tachui.concat");
-class Xt {
-  /**
-   * Concatenate this component with another concatenatable component
-   */
-  concat(e) {
-    const t = this.toSegment(), r = e.toSegment();
-    return e instanceof $ ? new $(
-      [t, ...e.segments],
-      this.mergeMetadata(e.metadata, e.segments.length + 1)
-    ) : new $(
-      [t, r],
-      this.createMetadata(2)
-    );
-  }
-  /**
-   * Check if this component supports concatenation
-   */
-  isConcatenatable() {
-    return !0;
-  }
-  /**
-   * Create metadata for a new concatenated component
-   */
-  createMetadata(e) {
-    return {
-      totalSegments: e,
-      accessibilityRole: this.determineAccessibilityRole(),
-      semanticStructure: this.determineSemanticStructure()
-    };
-  }
-  /**
-   * Merge metadata when concatenating with existing concatenated component
-   */
-  mergeMetadata(e, t) {
-    return {
-      totalSegments: t,
-      accessibilityRole: this.mergeAccessibilityRoles(e.accessibilityRole),
-      semanticStructure: this.mergeSemanticStructures(e.semanticStructure)
-    };
-  }
-  /**
-   * Determine the accessibility role for this component
-   */
-  determineAccessibilityRole() {
-    const e = this.constructor.name;
-    return e === "EnhancedText" ? "text" : e === "EnhancedImage" || e === "EnhancedButton" || e === "EnhancedLink" ? "group" : "composite";
-  }
-  /**
-   * Determine the semantic structure for this component
-   */
-  determineSemanticStructure() {
-    const e = this.constructor.name;
-    return e === "EnhancedText" || e === "EnhancedImage" ? "inline" : "mixed";
-  }
-  /**
-   * Merge accessibility roles when combining components
-   */
-  mergeAccessibilityRoles(e) {
-    const t = this.determineAccessibilityRole();
-    return t === "text" && e === "text" ? "text" : t === "composite" || e === "composite" ? "composite" : "group";
-  }
-  /**
-   * Merge semantic structures when combining components
-   */
-  mergeSemanticStructures(e) {
-    const t = this.determineSemanticStructure();
-    return t === "inline" && e === "inline" ? "inline" : t === "block" && e === "block" ? "block" : "mixed";
-  }
-}
-function Yt(n) {
-  const e = n;
-  return e.concat = function(t) {
-    const r = {
-      id: this.id,
-      component: this,
-      modifiers: this.modifiers || [],
-      render: () => {
-        const i = this.render();
-        return Array.isArray(i) ? i[0] : i;
-      }
-    }, s = t.toSegment();
-    return t instanceof $ ? new $(
-      [r, ...t.segments],
-      {
-        totalSegments: t.segments.length + 1,
-        accessibilityRole: "group",
-        semanticStructure: "mixed"
-      }
-    ) : new $(
-      [r, s],
-      {
-        totalSegments: 2,
-        accessibilityRole: "group",
-        semanticStructure: "mixed"
-      }
-    );
-  }, e.toSegment = function() {
-    return {
-      id: this.id,
-      component: this,
-      modifiers: this.modifiers || [],
-      render: () => {
-        const t = this.render();
-        return Array.isArray(t) ? t[0] : t;
-      }
-    };
-  }, e.isConcatenatable = function() {
-    return !0;
-  }, e;
-}
-const _ = /* @__PURE__ */ new Map(), $e = 300 * 1e3, Z = 100;
-class Jt {
-  /**
-   * Optimize an array of segments by merging compatible adjacent text segments
-   * Enhanced with caching and performance monitoring
-   */
-  static optimize(e) {
-    const t = performance.now();
-    if (e.length < 2) return e;
-    const r = this.generateCacheKey(e), s = this.getCachedOptimization(r);
-    if (s)
-      return s.optimizedSegments;
-    const i = this.performOptimization(e), a = performance.now() - t, o = {
-      ...this.getOptimizationStats(e, i),
-      processingTimeMs: a
-    };
-    return this.cacheOptimization(r, i, o), process.env.NODE_ENV === "development" && a > 5 && console.log(`TachUI Concatenation: Optimization took ${a.toFixed(2)}ms for ${e.length} segments`), i;
-  }
-  /**
-   * Core optimization algorithm separated for clarity
-   */
-  static performOptimization(e) {
-    const t = [];
-    for (const r of e) {
-      const s = t[t.length - 1];
-      s && this.canMergeTextSegments(s, r) ? t[t.length - 1] = this.mergeTextSegments(s, r) : t.push(r);
-    }
-    return t;
-  }
-  /**
-   * Generate a cache key from segments
-   */
-  static generateCacheKey(e) {
-    return e.map((r) => {
-      const s = r.component, i = this.extractTextContent(s), a = this.hashModifiers(r.modifiers);
-      return `${s.constructor.name}:${i}:${a}`;
-    }).join("|");
-  }
-  /**
-   * Hash modifiers for cache key generation
-   */
-  static hashModifiers(e) {
-    if (e.length === 0) return "none";
-    try {
-      const t = e.map((s) => ({
-        type: s.type,
-        props: s.properties
-      })), r = JSON.stringify(t);
-      return typeof btoa == "function" ? btoa(r).substring(0, 8) : this.simpleHash(r).toString(16).substring(0, 8);
-    } catch {
-      return "hash-error";
-    }
-  }
-  /**
-   * Simple hash function fallback for environments without btoa
-   */
-  static simpleHash(e) {
-    let t = 0;
-    for (let r = 0; r < e.length; r++) {
-      const s = e.charCodeAt(r);
-      t = (t << 5) - t + s, t = t & t;
-    }
-    return Math.abs(t);
-  }
-  /**
-   * Get cached optimization result
-   */
-  static getCachedOptimization(e) {
-    const t = _.get(e);
-    return t ? Date.now() - t.timestamp > $e ? (_.delete(e), null) : t : null;
-  }
-  /**
-   * Cache optimization result
-   */
-  static cacheOptimization(e, t, r) {
-    if (_.size >= Z) {
-      const s = _.keys().next().value;
-      s && _.delete(s);
-    }
-    _.set(e, {
-      optimizedSegments: t,
-      stats: r,
-      timestamp: Date.now()
-    });
-  }
-  /**
-   * Clear optimization cache (useful for testing)
-   */
-  static clearCache() {
-    _.clear();
-  }
-  /**
-   * Get cache statistics
-   */
-  static getCacheStats() {
-    return {
-      size: _.size,
-      maxSize: Z,
-      hitRate: 0
-      // Would need to track hits/misses to calculate this
-    };
-  }
-  /**
-   * Check if two segments can be merged
-   */
-  static canMergeTextSegments(e, t) {
-    return e.component.constructor.name !== "EnhancedText" || t.component.constructor.name !== "EnhancedText" ? !1 : this.modifiersCompatible(e.modifiers, t.modifiers);
-  }
-  /**
-   * Check if two modifier arrays are compatible for merging
-   */
-  static modifiersCompatible(e, t) {
-    if (e.length !== t.length) return !1;
-    for (let r = 0; r < e.length; r++)
-      if (!this.modifierEqual(e[r], t[r]))
-        return !1;
-    return !0;
-  }
-  /**
-   * Check if two modifiers are equal (simplified comparison)
-   */
-  static modifierEqual(e, t) {
-    if (e.type !== t.type) return !1;
-    try {
-      return JSON.stringify(e.properties) === JSON.stringify(t.properties);
-    } catch {
-      return !1;
-    }
-  }
-  /**
-   * Merge two text segments into a single segment
-   */
-  static mergeTextSegments(e, t) {
-    const r = e.component, s = t.component, i = this.extractTextContent(r), a = this.extractTextContent(s), o = i + a;
-    return {
-      id: `merged-${e.id}-${t.id}`,
-      component: this.createMergedTextComponent(o, r.props, e.modifiers),
-      modifiers: e.modifiers,
-      // Use modifiers from first segment (they're identical)
-      render: () => this.createMergedTextComponent(o, r.props, e.modifiers).render()[0]
-    };
-  }
-  /**
-   * Extract text content from a text component
-   */
-  static extractTextContent(e) {
-    const t = e.props?.content;
-    return typeof t == "string" ? t : typeof t == "function" ? t() : t && typeof t == "object" && "peek" in t && t.peek() || "";
-  }
-  /**
-   * Create a new merged text component
-   */
-  static createMergedTextComponent(e, t, r) {
-    const s = {
-      ...t,
-      content: e
-    };
-    return {
-      type: "Text",
-      id: `merged-text-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-      props: s,
-      mounted: !1,
-      cleanup: [],
-      modifiers: r,
-      render() {
-        const i = globalThis.__tachui_runtime;
-        if (i && i.h && i.text) {
-          const a = i.text(e);
-          return [i.h("span", {}, [a])];
-        }
-        return [];
-      }
-    };
-  }
-  /**
-   * Analyze segments and determine if optimization would be beneficial
-   */
-  static shouldOptimize(e) {
-    if (e.length < 2) return !1;
-    let t = 0;
-    for (let r = 0; r < e.length - 1; r++) {
-      const s = e[r], i = e[r + 1];
-      s.component.constructor.name === "EnhancedText" && i.component.constructor.name === "EnhancedText" && t++;
-    }
-    return t > 0;
-  }
-  /**
-   * Get optimization statistics (enhanced for Phase 4.1)
-   */
-  static getOptimizationStats(e, t) {
-    const r = e.length - t.length, s = e.length > 0 ? Math.round(r / e.length * 100) : 0;
-    return {
-      originalCount: e.length,
-      optimizedCount: t.length,
-      reductionPercent: s,
-      textSegmentsMerged: r
-    };
-  }
-  /**
-   * Advanced optimization analysis for performance monitoring
-   */
-  static analyzeOptimizationOpportunities(e) {
-    let t = 0, r = 0, s = 0, i = 0;
-    for (let o = 0; o < e.length; o++) {
-      const c = e[o];
-      switch (c.component.constructor.name) {
-        case "EnhancedText":
-          if (t++, o < e.length - 1) {
-            const u = e[o + 1];
-            this.canMergeTextSegments(c, u) && i++;
-          }
-          break;
-        case "EnhancedImage":
-          r++;
-          break;
-        case "EnhancedButton":
-        case "EnhancedLinkComponent":
-          s++;
-          break;
-      }
-    }
-    const a = e.length > 0 ? Math.round(i / e.length * 100) : 0;
-    return {
-      totalSegments: e.length,
-      textSegments: t,
-      imageSegments: r,
-      interactiveSegments: s,
-      optimizableTextPairs: i,
-      estimatedReductionPercent: a
-    };
-  }
-}
-const Zt = {
-  fillMaxWidth: Y,
-  fillMaxHeight: ae,
-  fillMaxSize: oe,
-  expand: ce,
-  flexible: je,
-  fullScreen: le,
-  remainingSpace: Pe,
-  equalShare: Ae
-}, Qt = {
-  /**
-   * Full-width button pattern
-   * Common in forms and action sheets
-   */
-  fullWidthButton: Y,
-  /**
-   * Sidebar layout pattern
-   * Fixed width with full height
-   */
-  sidebar: (n = 250) => ke(n),
-  /**
-   * Header/footer pattern
-   * Fixed height with full width
-   */
-  header: (n = 60) => Re(n),
-  /**
-   * Content area pattern
-   * Fills remaining space with constraints
-   */
-  content: (n) => Te(n),
-  /**
-   * Card layout pattern
-   * Responsive with sensible constraints
-   */
-  card: Me(320, 800, 200),
-  /**
-   * Modal overlay pattern
-   * Full screen coverage
-   */
-  overlay: le
-}, Ve = {
-  /**
-   * Pattern: .frame(maxWidth: .infinity)
-   * TachUI: fillMaxWidth()
-   */
-  "frame(maxWidth: .infinity)": Y,
-  /**
-   * Pattern: .frame(maxHeight: .infinity)
-   * TachUI: fillMaxHeight()
-   */
-  "frame(maxHeight: .infinity)": ae,
-  /**
-   * Pattern: .frame(maxWidth: .infinity, maxHeight: .infinity)
-   * TachUI: fillMaxSize()
-   */
-  "frame(maxWidth: .infinity, maxHeight: .infinity)": oe,
-  /**
-   * Pattern: .frame(width: .infinity, height: .infinity)
-   * TachUI: expand()
-   */
-  "frame(width: .infinity, height: .infinity)": ce
-};
-function er(n) {
-  if (process.env.NODE_ENV === "development") {
-    const e = Ve[n];
-    e ? console.info(`SUI Pattern: ${n} → TachUI: ${e.name}()`) : console.warn(`No TachUI equivalent found for: ${n}`);
-  }
-}
-var ze = Object.defineProperty, De = (n, e, t) => e in n ? ze(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, C = (n, e, t) => De(n, typeof e != "symbol" ? e + "" : e, t);
-class ue {
-  constructor(e = {}) {
-    C(this, "state", "closed"), C(this, "failureCount", 0), C(this, "lastFailureTime", 0), C(this, "successCount", 0), C(this, "requestCount", 0), C(this, "lastRequestTime", 0), C(this, "config"), C(this, "stateSignal"), C(this, "setState"), this.config = {
-      failureThreshold: 5,
-      resetTimeout: 6e4,
-      // 1 minute
-      monitoringPeriod: 3e5,
-      // 5 minutes
-      minimumThroughput: 10,
-      ...e
-    };
-    const [t, r] = j("closed");
-    this.stateSignal = t, this.setState = r;
-  }
-  /**
-   * Execute function with circuit breaker protection
-   */
-  async execute(e) {
-    if (this.updateRequestCount(), this.state === "open")
-      if (this.shouldAttemptReset())
-        this.state = "half-open", this.setState("half-open");
-      else
-        throw new Error("Circuit breaker is open");
-    try {
-      const t = await e();
-      return this.onSuccess(), t;
-    } catch (t) {
-      throw this.onFailure(), t;
-    }
-  }
-  /**
-   * Handle successful execution
-   */
-  onSuccess() {
-    this.successCount++, this.state === "half-open" && this.reset();
-  }
-  /**
-   * Handle failed execution
-   */
-  onFailure() {
-    this.failureCount++, this.lastFailureTime = Date.now(), this.shouldTrip() && this.trip();
-  }
-  /**
-   * Check if circuit breaker should trip to open state
-   */
-  shouldTrip() {
-    return this.failureCount >= this.config.failureThreshold && this.requestCount >= this.config.minimumThroughput;
-  }
-  /**
-   * Trip circuit breaker to open state
-   */
-  trip() {
-    this.state = "open", this.setState("open"), y.reportError(
-      y.createTachUIError(new Error("Circuit breaker tripped"), {
-        category: "component_error",
-        severity: "medium",
-        context: {
-          failureCount: this.failureCount,
-          requestCount: this.requestCount
-        }
-      })
-    );
-  }
-  /**
-   * Check if should attempt reset from open state
-   */
-  shouldAttemptReset() {
-    return Date.now() - this.lastFailureTime >= this.config.resetTimeout;
-  }
-  /**
-   * Reset circuit breaker to closed state
-   */
-  reset() {
-    this.state = "closed", this.failureCount = 0, this.successCount = 0, this.setState("closed");
-  }
-  /**
-   * Update request count for monitoring period
-   */
-  updateRequestCount() {
-    const e = Date.now();
-    e - this.lastRequestTime > this.config.monitoringPeriod && (this.requestCount = 0), this.requestCount++, this.lastRequestTime = e;
-  }
-  /**
-   * Get current state
-   */
-  getState() {
-    return this.state;
-  }
-  /**
-   * Get state signal
-   */
-  getStateSignal() {
-    return this.stateSignal;
-  }
-  /**
-   * Get metrics
-   */
-  getMetrics() {
-    return {
-      state: this.state,
-      failureCount: this.failureCount,
-      successCount: this.successCount,
-      requestCount: this.requestCount,
-      failureRate: this.requestCount > 0 ? this.failureCount / this.requestCount : 0
-    };
-  }
-}
-class pe {
-  constructor(e = {}) {
-    C(this, "config"), this.config = {
-      maxAttempts: 3,
-      baseDelay: 1e3,
-      maxDelay: 3e4,
-      backoffMultiplier: 2,
-      jitter: !0,
-      retryableErrors: [],
-      // Empty means retry all errors by default (except non-retryable)
-      nonRetryableErrors: ["ValidationError", "AuthenticationError"],
-      ...e
-    };
-  }
-  /**
-   * Execute function with retry policy
-   */
-  async execute(e) {
-    let t;
-    for (let r = 1; r <= this.config.maxAttempts; r++)
-      try {
-        return await e();
-      } catch (s) {
-        if (t = s, !this.shouldRetry(s, r))
-          throw s;
-        if (r < this.config.maxAttempts) {
-          const i = this.calculateDelay(r);
-          await this.sleep(i), y.reportError(
-            y.createTachUIError(s, {
-              category: "network_error",
-              severity: "low",
-              context: {
-                attempt: r,
-                nextDelay: i,
-                retryPolicy: !0
-              }
-            })
-          );
-        }
-      }
-    throw t;
-  }
-  /**
-   * Check if error should be retried
-   */
-  shouldRetry(e, t) {
-    if (t >= this.config.maxAttempts)
-      return !1;
-    const r = e.constructor.name;
-    return this.config.nonRetryableErrors.includes(r) ? !1 : this.config.retryableErrors.length > 0 ? this.config.retryableErrors.includes(r) : !["ValidationError", "AuthenticationError", "AuthorizationError"].includes(r);
-  }
-  /**
-   * Calculate delay for next retry
-   */
-  calculateDelay(e) {
-    const t = this.config.baseDelay * this.config.backoffMultiplier ** (e - 1);
-    let r = Math.min(t, this.config.maxDelay);
-    return this.config.jitter && (r = r * (0.5 + Math.random() * 0.5)), Math.floor(r);
-  }
-  /**
-   * Sleep for specified duration
-   */
-  sleep(e) {
-    return new Promise((t) => setTimeout(t, e));
-  }
-  /**
-   * Get configuration
-   */
-  getConfig() {
-    return { ...this.config };
-  }
-}
-class de {
-  constructor() {
-    C(this, "cache", /* @__PURE__ */ new Map());
-  }
-  /**
-   * Execute with fallback
-   */
-  async executeWithFallback(e, t) {
-    try {
-      return t.timeout ? await this.withTimeout(e(), t.timeout) : await e();
-    } catch (r) {
-      return this.getFallbackValue(t, r);
-    }
-  }
-  /**
-   * Get fallback value
-   */
-  async getFallbackValue(e, t) {
-    if (e.cache && e.cacheKey) {
-      const s = this.getCachedValue(e.cacheKey, e.cacheTimeout || 3e5);
-      if (s !== null)
-        return s;
-    }
-    let r;
-    if (e.factory)
-      r = await e.factory();
-    else if (e.value !== void 0)
-      r = e.value;
-    else
-      throw t;
-    return e.cache && e.cacheKey && this.setCachedValue(e.cacheKey, r), r;
-  }
-  /**
-   * Execute with timeout
-   */
-  withTimeout(e, t) {
-    return new Promise((r, s) => {
-      const i = setTimeout(() => {
-        s(new Error(`Operation timed out after ${t}ms`));
-      }, t);
-      e.then(r).catch(s).finally(() => clearTimeout(i));
-    });
-  }
-  /**
-   * Get cached value
-   */
-  getCachedValue(e, t) {
-    const r = this.cache.get(e);
-    return r ? Date.now() - r.timestamp > t ? (this.cache.delete(e), null) : r.value : null;
-  }
-  /**
-   * Set cached value
-   */
-  setCachedValue(e, t) {
-    this.cache.set(e, { value: t, timestamp: Date.now() });
-  }
-  /**
-   * Clear cache
-   */
-  clearCache() {
-    this.cache.clear();
-  }
-}
-class Be {
-  constructor(e, t) {
-    C(this, "circuitBreaker"), C(this, "retryPolicy"), C(this, "fallbackManager", new de()), e && (this.circuitBreaker = new ue(e)), t && (this.retryPolicy = new pe(t));
-  }
-  /**
-   * Execute with all recovery mechanisms
-   */
-  async execute(e, t) {
-    const r = this.wrapWithRecovery(e);
-    return t ? this.fallbackManager.executeWithFallback(r, t) : r();
-  }
-  /**
-   * Wrap function with recovery mechanisms
-   */
-  wrapWithRecovery(e) {
-    let t = e;
-    if (this.retryPolicy) {
-      const r = t;
-      t = () => this.retryPolicy.execute(r);
-    }
-    if (this.circuitBreaker) {
-      const r = t;
-      t = () => this.circuitBreaker.execute(r);
-    }
-    return t;
-  }
-  /**
-   * Get circuit breaker metrics
-   */
-  getCircuitBreakerMetrics() {
-    return this.circuitBreaker?.getMetrics();
-  }
-  /**
-   * Get retry policy configuration
-   */
-  getRetryPolicyConfig() {
-    return this.retryPolicy?.getConfig();
-  }
-}
-const tr = {
-  /**
-   * Create a robust function wrapper with all recovery mechanisms
-   */
-  createRobustFunction(n, e = {}) {
-    const t = new Be(e.circuitBreaker, e.retryPolicy);
-    return (async (...r) => {
-      try {
-        return await t.execute(() => n(...r), e.fallback);
-      } catch (s) {
-        if (e.onError) {
-          const i = y.createTachUIError(s, {
-            category: "network_error"
-          });
-          e.onError(i);
-        }
-        throw s;
-      }
-    });
-  },
-  /**
-   * Create simple retry wrapper
-   */
-  withRetry(n, e = 3, t = 1e3) {
-    const r = new pe({
-      maxAttempts: e,
-      baseDelay: t
-    });
-    return ((...s) => r.execute(() => n(...s)));
-  },
-  /**
-   * Create circuit breaker wrapper
-   */
-  withCircuitBreaker(n, e) {
-    const t = new ue(e);
-    return ((...r) => t.execute(() => n(...r)));
-  },
-  /**
-   * Create fallback wrapper
-   */
-  withFallback(n, e) {
-    const t = new de();
-    return ((...r) => t.executeWithFallback(() => n(...r), {
-      factory: typeof e == "function" ? e : void 0,
-      value: typeof e != "function" ? e : void 0
-    }));
-  }
-}, rr = {
-  /**
-   * Configuration for network requests
-   */
-  network: {
-    circuitBreaker: {
-      failureThreshold: 5,
-      resetTimeout: 6e4,
-      monitoringPeriod: 3e5
-    },
-    retryPolicy: {
-      maxAttempts: 3,
-      baseDelay: 1e3,
-      backoffMultiplier: 2,
-      jitter: !0,
-      retryableErrors: ["NetworkError", "TimeoutError", "ServiceUnavailable"]
-    }
-  },
-  /**
-   * Configuration for component rendering
-   */
-  component: {
-    retryPolicy: {
-      maxAttempts: 2,
-      baseDelay: 100,
-      backoffMultiplier: 1.5,
-      jitter: !1,
-      retryableErrors: ["RenderError", "ComponentError"]
-    }
-  },
-  /**
-   * Configuration for reactive operations
-   */
-  reactive: {
-    retryPolicy: {
-      maxAttempts: 1,
-      baseDelay: 0,
-      retryableErrors: []
-    }
-  }
-};
-var Ie = Object.defineProperty, Ne = (n, e, t) => e in n ? Ie(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, We = (n, e, t) => Ne(n, e + "", t);
-class Ue {
-  constructor() {
-    We(this, "windowSize", 100);
-  }
-  // Number of recent errors to analyze
-  /**
-   * Analyze error patterns
-   */
-  analyzePatterns(e) {
-    const t = e.slice(-this.windowSize), r = this.detectErrorPatterns(t), s = this.detectCascadingErrors(t), i = this.detectErrorCorrelations(t);
-    return { patterns: r, cascadingErrors: s, correlations: i };
-  }
-  /**
-   * Detect error patterns
-   */
-  detectErrorPatterns(e) {
-    const t = /* @__PURE__ */ new Map();
-    for (const r of e) {
-      const s = `${r.category}:${r.componentName || "unknown"}`;
-      t.set(s, (t.get(s) || 0) + 1);
-      const i = this.extractMessagePattern(r.message);
-      t.set(i, (t.get(i) || 0) + 1);
-    }
-    return Array.from(t.entries()).map(([r, s]) => ({
-      pattern: r,
-      count: s,
-      severity: s > 10 ? "high" : s > 5 ? "medium" : "low"
-    })).sort((r, s) => s.count - r.count);
-  }
-  /**
-   * Extract pattern from error message
-   */
-  extractMessagePattern(e) {
-    return e.replace(/\d+/g, "N").replace(/['"]/g, "").replace(/\s+/g, " ").toLowerCase();
-  }
-  /**
-   * Detect cascading errors (errors that happen close together)
-   */
-  detectCascadingErrors(e) {
-    const t = [];
-    for (let s = 0; s < e.length; s++) {
-      const i = [e[s]];
-      for (let a = s + 1; a < e.length && e[a].timestamp - e[s].timestamp <= 1e3; a++)
-        i.push(e[a]);
-      i.length > 1 && (t.push(i), s += i.length - 1);
-    }
-    return t;
-  }
-  /**
-   * Detect error correlations
-   */
-  detectErrorCorrelations(e) {
-    const t = [], r = new Set(e.map((s) => s.message));
-    for (const s of r)
-      for (const i of r) {
-        if (s >= i) continue;
-        const a = this.calculateCorrelation(e, s, i);
-        a > 0.5 && t.push({ error1: s, error2: i, correlation: a });
-      }
-    return t.sort((s, i) => i.correlation - s.correlation);
-  }
-  /**
-   * Calculate correlation between two error types
-   */
-  calculateCorrelation(e, t, r) {
-    const i = /* @__PURE__ */ new Map();
-    for (const l of e) {
-      const u = Math.floor(l.timestamp / 5e3), p = i.get(u) || { type1: !1, type2: !1 };
-      l.message === t && (p.type1 = !0), l.message === r && (p.type2 = !0), i.set(u, p);
-    }
-    const a = Array.from(i.values()), o = a.filter((l) => l.type1 && l.type2).length, c = a.filter((l) => l.type1 || l.type2).length;
-    return c > 0 ? o / c : 0;
-  }
-}
-class Fe {
-  /**
-   * Analyze stack trace
-   */
-  analyzeStackTrace(e) {
-    if (!e.stack)
-      return {
-        frames: [],
-        affectedComponents: [],
-        suggestedFixes: []
-      };
-    const t = this.parseStackTrace(e.stack), r = this.identifyRootCause(t, e), s = this.extractAffectedComponents(t), i = this.generateSuggestedFixes(e, t);
-    return {
-      frames: t,
-      rootCause: r,
-      affectedComponents: s,
-      suggestedFixes: i
-    };
-  }
-  /**
-   * Parse stack trace into frames
-   */
-  parseStackTrace(e) {
-    const t = e.split(`
-`).slice(1), r = [];
-    for (const s of t) {
-      const i = s.match(/at\s+(.+?)\s+\((.+?):(\d+):(\d+)\)/) || s.match(/at\s+(.+?):(\d+):(\d+)/);
-      i && (i.length === 5 ? r.push({
-        function: i[1] || "anonymous",
-        file: i[2],
-        line: parseInt(i[3]),
-        column: parseInt(i[4])
-      }) : i.length === 4 && r.push({
-        function: "anonymous",
-        file: i[1],
-        line: parseInt(i[2]),
-        column: parseInt(i[3])
-      }));
-    }
-    return r;
-  }
-  /**
-   * Identify root cause from stack trace
-   */
-  identifyRootCause(e, t) {
-    const r = e.filter(
-      (s) => s.file.includes("tachui") || s.function.includes("Component") || s.function.includes("render")
-    );
-    if (r.length > 0) {
-      const s = r[0];
-      return `Error in ${s.function} at ${s.file}:${s.line}`;
-    }
-    if (e.length > 0)
-      return `Error in ${e[0].function}`;
-  }
-  /**
-   * Extract affected components from stack trace
-   */
-  extractAffectedComponents(e) {
-    const t = /* @__PURE__ */ new Set();
-    for (const r of e) {
-      const s = r.function.match(/(\w+Component)|(\w+\.render)/);
-      s && t.add(s[1] || s[2].replace(".render", ""));
-    }
-    return Array.from(t);
-  }
-  /**
-   * Generate suggested fixes
-   */
-  generateSuggestedFixes(e, t) {
-    const r = [];
-    switch (e.category) {
-      case "component_error":
-        r.push("Check component props and state"), r.push("Verify component lifecycle methods"), t.some((s) => s.function.includes("render")) && r.push("Review render method for potential null/undefined values");
-        break;
-      case "reactive_error":
-        r.push("Check signal dependencies and computed values"), r.push("Verify effect cleanup functions");
-        break;
-      case "render_error":
-        r.push("Check DOM element references"), r.push("Verify element properties and attributes");
-        break;
-      case "validation_error":
-        r.push("Review input validation logic"), r.push("Check data types and required fields");
-        break;
-      case "network_error":
-        r.push("Check network connectivity"), r.push("Verify API endpoints and request format"), r.push("Implement proper error handling for network requests");
-        break;
-    }
-    return (e.message.includes("null") || e.message.includes("undefined")) && r.push("Add null/undefined checks before accessing properties"), e.message.includes("TypeError") && r.push("Verify variable types and method availability"), r;
-  }
-}
-class Le {
-  /**
-   * Analyze performance impact of errors
-   */
-  analyzePerformanceImpact(e) {
-    const t = e.length, r = [...new Set(e.map((o) => o.componentId).filter(Boolean))], s = this.calculateAverageRenderTime(r), i = this.calculateMemoryUsage(r), a = this.calculatePerformanceDegradation(e);
-    return {
-      errorCount: t,
-      averageRenderTime: s,
-      memoryUsage: i,
-      affectedComponents: r,
-      performanceDegradation: a
-    };
-  }
-  /**
-   * Calculate average render time for affected components
-   */
-  calculateAverageRenderTime(e) {
-    return e.length * 2.5;
-  }
-  /**
-   * Calculate memory usage impact
-   */
-  calculateMemoryUsage(e) {
-    return e.length * 1024 * 10;
-  }
-  /**
-   * Calculate performance degradation percentage
-   */
-  calculatePerformanceDegradation(e) {
-    const t = { low: 1, medium: 3, high: 5, critical: 10 }, r = e.reduce((s, i) => s + t[i.severity], 0);
-    return Math.min(r * 2, 100);
-  }
-}
-const nr = {
-  /**
-   * Generate comprehensive error report
-   */
-  generateErrorReport() {
-    const n = y.getErrors(), e = H.getAggregations(), t = y.getStatistics(), s = new Ue().analyzePatterns(n), i = Object.entries(t.errorsByCategory).map(([o, c]) => ({
-      category: o,
-      trend: "stable",
-      // Would calculate from historical data
-      change: 0
-    })), a = this.generateRecommendations(n, e, s);
-    return {
-      totalErrors: t.totalErrors,
-      errorsByCategory: t.errorsByCategory,
-      errorsBySeverity: t.errorsBySeverity,
-      topErrors: e.slice(0, 10),
-      recentErrors: n.slice(-10),
-      errorTrends: i,
-      recommendations: a
-    };
-  },
-  /**
-   * Generate recommendations based on error analysis
-   */
-  generateRecommendations(n, e, t) {
-    const r = [];
-    return n.length > 50 && (r.push("Consider implementing error boundaries to contain errors"), r.push("Review error handling strategies across components")), n.filter((a) => a.category === "component_error").length > 10 && (r.push("Review component lifecycle methods and state management"), r.push("Add prop validation to prevent runtime errors")), n.filter((a) => a.category === "network_error").length > 5 && (r.push("Implement retry logic for network requests"), r.push("Add proper error handling for API calls")), t.cascadingErrors.length > 0 && r.push("Investigate cascading errors that may indicate systemic issues"), r;
-  },
-  /**
-   * Debug specific error
-   */
-  debugError(n) {
-    const e = y.getErrors().find((c) => c.id === n);
-    if (!e) return null;
-    const t = new Fe(), r = new Le(), s = t.analyzeStackTrace(e), i = this.findRelatedErrors(e), a = r.analyzePerformanceImpact([
-      e,
-      ...i
-    ]), o = this.generateErrorSuggestions(e, s, i);
-    return {
-      error: e,
-      stackTrace: s,
-      relatedErrors: i,
-      performanceImpact: a,
-      suggestions: o
-    };
-  },
-  /**
-   * Find related errors
-   */
-  findRelatedErrors(n) {
-    const e = y.getErrors(), t = 5e3;
-    return e.filter(
-      (r) => r.id !== n.id && Math.abs(r.timestamp - n.timestamp) <= t && (r.componentId === n.componentId || r.category === n.category)
-    );
-  },
-  /**
-   * Generate error-specific suggestions
-   */
-  generateErrorSuggestions(n, e, t) {
-    const r = [...e.suggestedFixes];
-    return t.length > 0 && r.push("Multiple related errors detected - check for common root cause"), n.retryCount > 0 && r.push("Error has been retried - consider implementing circuit breaker"), r;
-  },
-  /**
-   * Log error analysis to console
-   */
-  logErrorAnalysis() {
-    const n = this.generateErrorReport();
-    console.group("🚨 TachUI Error Analysis"), console.log(`Total Errors: ${n.totalErrors}`), console.log("Errors by Category:", n.errorsByCategory), console.log("Errors by Severity:", n.errorsBySeverity), n.topErrors.length > 0 && (console.group("Top Errors"), n.topErrors.forEach((e) => {
-      console.log(`${e.message} (${e.count} times)`);
-    }), console.groupEnd()), n.recommendations.length > 0 && (console.group("Recommendations"), n.recommendations.forEach((e) => console.log(`• ${e}`)), console.groupEnd()), console.groupEnd();
-  },
-  /**
-   * Export error data for external analysis
-   */
-  exportErrorData() {
-    return {
-      errors: y.getErrors(),
-      logs: q.getEntries(),
-      aggregations: H.getAggregations(),
-      analysis: this.generateErrorReport(),
-      timestamp: Date.now()
-    };
-  },
-  /**
-   * Simulate error for testing
-   */
-  simulateError(n = "component_error", e = "medium", t = "Test error") {
-    const r = y.createTachUIError(new Error(t), {
-      category: n,
-      severity: e,
-      componentId: "test-component"
-    });
-    y.reportError(r);
-  },
-  /**
-   * Clear all error data
-   */
-  clearAllErrorData() {
-    y.clear(), q.clear(), H.clear(), console.log("All error data cleared");
-  }
-}, sr = {
-  /**
-   * Enable enhanced error debugging
-   */
-  enableEnhancedDebugging() {
-    y.configure({
-      development: !0,
-      captureConsoleErrors: !0,
-      captureUnhandledPromises: !0,
-      enableStackTrace: !0
-    }), q.addDestination({
-      name: "enhanced-console",
-      async send(n) {
-        n.forEach((e) => {
-          "level" in e && ["error", "fatal"].includes(e.level) && console.error(`🚨 [${e.level.toUpperCase()}]`, e.message, e.context);
-        });
-      },
-      isEnabled: () => !0
-    }), console.log("🛠️ Enhanced error debugging enabled");
-  },
-  /**
-   * Setup error monitoring dashboard
-   */
-  setupErrorDashboard() {
-    const n = j(0), e = j([]), [t, r] = n, [s, i] = e;
-    y.addHandler((a) => {
-      const o = y.getErrors();
-      r(o.length), i(o.slice(-5));
-    }), b(() => {
-      const a = t(), o = s();
-      a > 0 && (console.group(`📊 Error Dashboard (${a} total errors)`), o.forEach((c) => {
-        console.log(`${c.category}: ${c.message}`);
-      }), console.groupEnd());
-    });
-  }
-};
-class ir {
-  // Placeholder implementation
-}
-function ar() {
-}
-function or() {
-}
-function cr() {
-}
-function lr() {
-}
-function ur(n) {
-  return typeof n == "string" ? Ge(n) : new I({
-    family: n.family,
-    size: n.size,
-    weight: n.weight,
-    style: n.style
-  });
-}
-function Ge(n) {
-  const e = {
-    ".largeTitle": { size: 34, weight: 400 },
-    ".title": { size: 28, weight: 400 },
-    ".title2": { size: 22, weight: 400 },
-    ".title3": { size: 20, weight: 400 },
-    ".headline": { size: 17, weight: 600 },
-    ".subheadline": { size: 15, weight: 400 },
-    ".body": { size: 17, weight: 400 },
-    ".callout": { size: 16, weight: 400 },
-    ".footnote": { size: 13, weight: 400 },
-    ".caption": { size: 12, weight: 400 },
-    ".caption2": { size: 11, weight: 400 }
-  }, t = e[n];
-  return t ? new I(t) : (console.warn(`Unknown font preset: ${n}. Using default body font.`), new I(e[".body"]));
-}
-function pr(n) {
-  let e;
-  switch (n.design) {
-    case "serif":
-      e = "ui-serif, Georgia, serif";
-      break;
-    case "rounded":
-      e = "ui-rounded, system-ui, -apple-system, sans-serif";
-      break;
-    case "monospaced":
-      e = "ui-monospace, SFMono-Regular, Consolas, monospace";
-      break;
-    default:
-      e = "system-ui, -apple-system, BlinkMacSystemFont, sans-serif";
-  }
-  return new I({
-    family: e,
-    size: n.size,
-    weight: n.weight
-  });
-}
-function dr(n, e) {
-  return new I({
-    family: n,
-    size: e?.size,
-    weight: e?.weight,
-    style: e?.style
-  });
-}
-class fr {
-  /**
-   * Create a responsive grid with automatic column sizing
-   */
-  static autoFit(e) {
-    const t = {};
-    if (typeof e.minColumnWidth == "object") {
-      t.gridTemplateColumns = {};
-      for (const [r, s] of Object.entries(e.minColumnWidth)) {
-        const i = typeof s == "number" ? `${s}px` : s, a = e.maxColumns && typeof e.maxColumns == "object" ? e.maxColumns[r] || "auto" : e.maxColumns || "auto";
-        t.gridTemplateColumns[r] = a === "auto" ? `repeat(auto-fit, minmax(${i}, 1fr))` : `repeat(${a}, minmax(${i}, 1fr))`;
-      }
-    } else {
-      const r = typeof e.minColumnWidth == "number" ? `${e.minColumnWidth}px` : e.minColumnWidth, s = e.maxColumns || "auto";
-      t.gridTemplateColumns = s === "auto" ? `repeat(auto-fit, minmax(${r}, 1fr))` : `repeat(${s}, minmax(${r}, 1fr))`;
-    }
-    return e.gap && (t.gap = e.gap), t.display = "grid", h(t);
-  }
-  /**
-   * Create a responsive grid with explicit column counts
-   */
-  static columns(e, t) {
-    const r = {
-      display: "grid",
-      gridTemplateColumns: typeof e == "object" ? Object.fromEntries(
-        Object.entries(e).map(([s, i]) => [s, `repeat(${i}, 1fr)`])
-      ) : `repeat(${e}, 1fr)`
-    };
-    return t?.gap && (r.gap = t.gap), t?.rowGap && (r.rowGap = t.rowGap), t?.autoRows && (r.gridAutoRows = t.autoRows), h(r);
-  }
-  /**
-   * Create responsive masonry-style grid
-   */
-  static masonry(e) {
-    const t = {
-      display: "grid",
-      gridTemplateColumns: typeof e.columns == "object" ? Object.fromEntries(
-        Object.entries(e.columns).map(([r, s]) => [r, `repeat(${s}, 1fr)`])
-      ) : `repeat(${e.columns}, 1fr)`,
-      gridAutoRows: "max-content"
-    };
-    return e.gap && (t.gap = e.gap), h(t);
-  }
-}
-class hr {
-  /**
-   * Create a responsive flex container that stacks on mobile, flows horizontally on desktop
-   */
-  static stackToRow(e) {
-    const r = {
-      display: "flex",
-      flexDirection: {
-        base: "column",
-        [e?.stackBreakpoint || "md"]: "row"
-      }
-    };
-    return e?.gap && (r.gap = e.gap), e?.align && (r.alignItems = e.align), e?.justify && (r.justifyContent = e.justify), h(r);
-  }
-  /**
-   * Create a responsive flex container with wrapping behavior
-   */
-  static wrap(e) {
-    const t = {
-      display: "flex",
-      flexWrap: "wrap",
-      ...e
-    };
-    return h(t);
-  }
-  /**
-   * Create centered flex layout
-   */
-  static center(e = "row") {
-    return h({
-      display: "flex",
-      flexDirection: e,
-      justifyContent: "center",
-      alignItems: "center"
-    });
-  }
-  /**
-   * Create space-between flex layout
-   */
-  static spaceBetween(e = "row") {
-    return h({
-      display: "flex",
-      flexDirection: e,
-      justifyContent: "space-between",
-      alignItems: "center"
-    });
-  }
-}
-class mr {
-  /**
-   * Create a responsive container with max-width constraints
-   */
-  static container(e) {
-    const t = {
-      width: "100%",
-      marginLeft: "auto",
-      marginRight: "auto"
-    };
-    return e?.maxWidth ? t.maxWidth = e.maxWidth : t.maxWidth = {
-      sm: "640px",
-      md: "768px",
-      lg: "1024px",
-      xl: "1280px",
-      "2xl": "1536px"
-    }, e?.padding && (t.paddingLeft = e.padding, t.paddingRight = e.padding), e?.margin && (t.marginTop = e.margin, t.marginBottom = e.margin), h(t);
-  }
-  /**
-   * Create a full-width container that breaks out of constraints
-   */
-  static fullWidth() {
-    return h({
-      width: "100vw",
-      marginLeft: "calc(-50vw + 50%)",
-      marginRight: "calc(-50vw + 50%)"
-    });
-  }
-  /**
-   * Create a section container with responsive padding
-   */
-  static section(e) {
-    const t = {};
-    return e?.paddingY && (t.paddingTop = e.paddingY, t.paddingBottom = e.paddingY), e?.paddingX && (t.paddingLeft = e.paddingX, t.paddingRight = e.paddingX), e?.maxWidth && (t.maxWidth = e.maxWidth, t.marginLeft = "auto", t.marginRight = "auto"), h(t);
-  }
-}
-class gr {
-  /**
-   * Show element only on specific breakpoints
-   */
-  static showOn(e) {
-    const t = {
-      display: {}
-      // Start with empty object
-    };
-    for (const r of e)
-      t.display[r] = "block";
-    return h(t);
-  }
-  /**
-   * Hide element only on specific breakpoints
-   */
-  static hideOn(e) {
-    const t = {
-      display: {}
-      // Start with empty object
-    };
-    for (const r of e)
-      t.display[r] = "none";
-    return h(t);
-  }
-  /**
-   * Show on mobile, hide on desktop
-   */
-  static mobileOnly() {
-    return h({
-      display: {
-        base: "block",
-        md: "none"
-      }
-    });
-  }
-  /**
-   * Hide on mobile, show on desktop
-   */
-  static desktopOnly() {
-    return h({
-      display: {
-        base: "none",
-        md: "block"
-      }
-    });
-  }
-  /**
-   * Show only on tablet breakpoint
-   */
-  static tabletOnly() {
-    return h({
-      display: {
-        base: "none",
-        md: "block",
-        lg: "none"
-      }
-    });
-  }
-}
-class yr {
-  /**
-   * Create responsive padding
-   */
-  static padding(e) {
-    const t = {};
-    return e.all && (t.padding = e.all), e.horizontal && (t.paddingLeft = e.horizontal, t.paddingRight = e.horizontal), e.vertical && (t.paddingTop = e.vertical, t.paddingBottom = e.vertical), e.top && (t.paddingTop = e.top), e.right && (t.paddingRight = e.right), e.bottom && (t.paddingBottom = e.bottom), e.left && (t.paddingLeft = e.left), h(t);
-  }
-  /**
-   * Create responsive margin
-   */
-  static margin(e) {
-    const t = {};
-    return e.all && (t.margin = e.all), e.horizontal && (t.marginLeft = e.horizontal, t.marginRight = e.horizontal), e.vertical && (t.marginTop = e.vertical, t.marginBottom = e.vertical), e.top && (t.marginTop = e.top), e.right && (t.marginRight = e.right), e.bottom && (t.marginBottom = e.bottom), e.left && (t.marginLeft = e.left), h(t);
-  }
-  /**
-   * Create responsive gap (for flexbox and grid)
-   */
-  static gap(e) {
-    const t = {};
-    return e.all && (t.gap = e.all), e.column && (t.columnGap = e.column), e.row && (t.rowGap = e.row), h(t);
-  }
-}
-class br {
-  /**
-   * Create responsive font scale
-   */
-  static scale(e) {
-    const t = {
-      fontSize: e.base
-    };
-    if (e.scale && typeof e.scale == "object") {
-      t.fontSize = {};
-      for (const [r, s] of Object.entries(e.scale)) {
-        const i = typeof e.base == "number" ? e.base : parseFloat(e.base);
-        t.fontSize[r] = `${i * s}px`;
-      }
-    }
-    return e.lineHeight && (t.lineHeight = e.lineHeight), h(t);
-  }
-  /**
-   * Create fluid typography that scales smoothly
-   */
-  static fluid(e) {
-    const t = e.minBreakpoint || "320px", r = e.maxBreakpoint || "1200px", s = typeof e.minSize == "number" ? `${e.minSize}px` : e.minSize, i = typeof e.maxSize == "number" ? `${e.maxSize}px` : e.maxSize;
-    return h({
-      fontSize: `clamp(${s}, calc(${s} + (${i} - ${s}) * ((100vw - ${t}) / (${r} - ${t}))), ${i})`
-    });
-  }
-}
-class k {
-  /**
-   * Create a responsive value resolver with custom logic
-   */
-  static createResponsiveResolver(e, t = []) {
-    const r = E();
-    return b(() => {
-      t.forEach((a) => a());
-      const s = r(), i = R();
-      return e(s, i);
-    });
-  }
-  /**
-   * Create responsive value that interpolates between breakpoints
-   */
-  static createInterpolatedValue(e, t = {}) {
-    const { smoothing: r = "linear", clamp: s = !0 } = t;
-    return b(() => {
-      const a = R().width, o = ye(), c = [];
-      for (const [f, g] of Object.entries(e))
-        if (g !== void 0) {
-          const W = f === "base" ? 0 : parseInt(o[f] || "0");
-          c.push({ width: W, value: g });
-        }
-      if (c.sort((f, g) => f.width - g.width), c.length === 0) return 0;
-      if (c.length === 1) return c[0].value;
-      let l = c[0], u = c[c.length - 1];
-      for (let f = 0; f < c.length - 1; f++)
-        if (a >= c[f].width && a <= c[f + 1].width) {
-          l = c[f], u = c[f + 1];
-          break;
-        }
-      if (s) {
-        if (a <= l.width) return l.value;
-        if (a >= u.width) return u.value;
-      }
-      const p = (a - l.width) / (u.width - l.width);
-      let d = p;
-      switch (r) {
-        case "ease":
-          d = 0.5 - 0.5 * Math.cos(p * Math.PI);
-          break;
-        case "ease-in":
-          d = p * p;
-          break;
-        case "ease-out":
-          d = 1 - (1 - p) * (1 - p);
-          break;
-        case "linear":
-        default:
-          d = p;
-          break;
-      }
-      return l.value + (u.value - l.value) * d;
-    });
-  }
-  /**
-   * Create conditional responsive behavior
-   */
-  static createConditionalResponsive(e, t, r) {
-    const s = E();
-    return b(() => {
-      const i = R(), o = e(i) ? t : r;
-      return this.resolveResponsiveValue(o, s());
-    });
-  }
-  /**
-   * Resolve responsive value at specific breakpoint
-   */
-  static resolveResponsiveValue(e, t) {
-    if (!ne(e))
-      return e;
-    const r = e, s = ["base", "sm", "md", "lg", "xl", "2xl"], i = s.indexOf(t);
-    for (let a = i; a >= 0; a--) {
-      const o = s[a];
-      if (r[o] !== void 0)
-        return r[o];
-    }
-    for (const a of s)
-      if (r[a] !== void 0)
-        return r[a];
-    throw new Error("No responsive value found");
-  }
-}
-class He {
-  /**
-   * Hook for responsive arrays (e.g., responsive grid columns data)
-   */
-  static useResponsiveArray(e) {
-    const t = E();
-    return b(() => {
-      const r = t();
-      return k.resolveResponsiveValue(e, r) || [];
-    });
-  }
-  /**
-   * Hook for responsive object selection
-   */
-  static useResponsiveObject(e) {
-    const t = E();
-    return b(() => {
-      const r = t();
-      try {
-        return k.resolveResponsiveValue(e, r);
-      } catch {
-        return null;
-      }
-    });
-  }
-  /**
-   * Hook for responsive function selection and execution
-   */
-  static useResponsiveFunction(e) {
-    const t = E();
-    return b(() => {
-      const r = t();
-      try {
-        return k.resolveResponsiveValue(e, r);
-      } catch {
-        return null;
-      }
-    });
-  }
-  /**
-   * Hook for responsive state management
-   */
-  static useResponsiveState(e) {
-    const [t, r] = j(e), s = E();
-    return [b(() => {
-      const o = t(), c = s();
-      try {
-        return k.resolveResponsiveValue(o, c);
-      } catch {
-        return;
-      }
-    }), (o) => {
-      ne(o) ? r(o) : r({ [s()]: o });
-    }];
-  }
-  /**
-   * Hook for responsive computations with memoization
-   */
-  static useResponsiveComputation(e, t = []) {
-    return ve(() => {
-      t.forEach((s) => s());
-      const r = R();
-      return e(r);
-    });
-  }
-  /**
-   * Hook for responsive side effects
-   */
-  static useResponsiveEffect(e, t = []) {
-    let r, s;
-    v(() => {
-      t.forEach((o) => o());
-      const i = R();
-      r && (r(), r = void 0);
-      const a = e(i, s);
-      typeof a == "function" && (r = a), s = i;
-    });
-  }
-}
-class qe {
-  /**
-   * Execute callback only on specific breakpoints
-   */
-  static onBreakpoints(e, t) {
-    let r;
-    return v(() => {
-      const s = R();
-      if (e.includes(s.current)) {
-        r && (r(), r = void 0);
-        const i = t(s);
-        typeof i == "function" && (r = i);
-      }
-    }), () => {
-      r && r();
-    };
-  }
-  /**
-   * Execute callback when breakpoint changes
-   */
-  static onBreakpointChange(e) {
-    let t;
-    return v(() => {
-      const r = R(), s = r.current;
-      t && t !== s && e(s, t, r), t = s;
-    }), () => {
-    };
-  }
-  /**
-   * Execute callback when entering/leaving specific breakpoint ranges
-   */
-  static onBreakpointRange(e, t, r) {
-    let s = !1, i, a;
-    return v(() => {
-      const o = R(), c = G(o.current), l = G(e), u = G(t), p = c >= l && c <= u;
-      if (p && !s) {
-        if (r.onEnter) {
-          const d = r.onEnter(o);
-          typeof d == "function" && (a = d);
-        }
-        s = !0;
-      } else !p && s && (a && (a(), a = void 0), i && (i(), i = void 0), r.onLeave && r.onLeave(o), s = !1);
-      if (p && r.onWithin) {
-        i && (i(), i = void 0);
-        const d = r.onWithin(o);
-        typeof d == "function" && (i = d);
-      }
-    }), () => {
-      a && a(), i && i();
-    };
-  }
-}
-class Ke {
-  /**
-   * Create responsive pagination
-   */
-  static createResponsivePagination(e, t) {
-    const [r, s] = j(1), i = E(), a = b(() => {
-      const g = i();
-      return k.resolveResponsiveValue(t, g);
-    }), o = b(() => Math.ceil(e.length / a())), c = b(() => {
-      const g = a(), J = (r() - 1) * g, ge = J + g;
-      return e.slice(J, ge);
-    }), l = b(() => r() < o()), u = b(() => r() > 1), p = (g) => {
-      const W = o();
-      s(Math.max(1, Math.min(g, W)));
-    }, d = () => {
-      l() && s(r() + 1);
-    }, f = () => {
-      u() && s(r() - 1);
-    };
-    return v(() => {
-      a(), s(1);
-    }), {
-      currentPage: r,
-      totalPages: o,
-      currentItems: c,
-      setPage: p,
-      nextPage: d,
-      prevPage: f,
-      hasNext: l,
-      hasPrev: u
-    };
-  }
-  /**
-   * Create responsive filtering
-   */
-  static createResponsiveFilter(e, t) {
-    const r = E();
-    return b(() => {
-      const s = r(), i = k.resolveResponsiveValue(t, s);
-      return i ? e.filter(i) : e;
-    });
-  }
-  /**
-   * Create responsive sorting
-   */
-  static createResponsiveSort(e, t) {
-    const r = E();
-    return b(() => {
-      const s = r(), i = k.resolveResponsiveValue(t, s);
-      return i ? [...e].sort(i) : e;
-    });
-  }
-}
-const Cr = {
-  Breakpoints: k,
-  Hooks: He,
-  Targeting: qe,
-  Data: Ke
-};
-var Xe = Object.defineProperty, Ye = (n, e, t) => e in n ? Xe(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, x = (n, e, t) => Ye(n, typeof e != "symbol" ? e + "" : e, t);
-class Je extends z {
-  constructor(e, t) {
-    super({ span: e, start: t }), x(this, "type", "grid-column-span"), x(this, "priority", 200);
-  }
-  apply(e, t) {
-    const r = t.element || e.element;
-    if (!r)
-      return;
-    const { span: s, start: i } = this.properties;
-    i !== void 0 ? r.style.gridColumn = `${i} / span ${s}` : r.style.gridColumn = `span ${s}`;
-  }
-}
-class Ze extends z {
-  constructor(e, t) {
-    super({ span: e, start: t }), x(this, "type", "grid-row-span"), x(this, "priority", 200);
-  }
-  apply(e, t) {
-    const r = t.element || e.element;
-    if (!r)
-      return;
-    const { span: s, start: i } = this.properties;
-    i !== void 0 ? r.style.gridRow = `${i} / span ${s}` : r.style.gridRow = `span ${s}`;
-  }
-}
-class Qe extends z {
-  constructor(e) {
-    super({ area: e }), x(this, "type", "grid-area"), x(this, "priority", 200);
-  }
-  apply(e, t) {
-    const r = t.element || e.element;
-    r && (r.style.gridArea = this.properties.area);
-  }
-}
-class et extends z {
-  constructor(e, t) {
-    const r = {};
-    (t === "horizontal" || t === "both" || t === void 0) && (r.justifySelf = e), (t === "vertical" || t === "both" || t === void 0) && (r.alignSelf = e), super(r), x(this, "type", "grid-cell-alignment"), x(this, "priority", 200);
-  }
-  apply(e, t) {
-    const r = t.element || e.element;
-    if (!r)
-      return;
-    const { justifySelf: s, alignSelf: i } = this.properties;
-    s && (r.style.justifySelf = s), i && (r.style.alignSelf = i);
-  }
-}
-class tt extends z {
-  constructor() {
-    super(...arguments), x(this, "type", "grid-item-config"), x(this, "priority", 200);
-  }
-  apply(e, t) {
-    const r = t.element || e.element;
-    if (!r)
-      return;
-    const { columnSpan: s, rowSpan: i, columnStart: a, rowStart: o, area: c, alignment: l } = this.properties, u = r.style;
-    s !== void 0 ? a !== void 0 ? u.gridColumn = `${a} / span ${s}` : u.gridColumn = `span ${s}` : a !== void 0 && (u.gridColumnStart = a.toString()), i !== void 0 ? o !== void 0 ? u.gridRow = `${o} / span ${i}` : u.gridRow = `span ${i}` : o !== void 0 && (u.gridRowStart = o.toString()), c && (u.gridArea = c), l && (u.justifySelf = l, u.alignSelf = l);
-  }
-}
-function rt(n, e) {
-  return new Je(n, e);
-}
-function nt(n, e) {
-  return new Ze(n, e);
-}
-function vr(n) {
-  return new Qe(n);
-}
-function st(n, e) {
-  return new et(n, e);
-}
-function wr(n) {
-  return new tt(n);
-}
-const Sr = rt, xr = nt, Er = st;
-var it = Object.defineProperty, at = (n, e, t) => e in n ? it(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, Q = (n, e, t) => at(n, typeof e != "symbol" ? e + "" : e, t);
-const K = {
-  /**
-   * Check if a value is a reactive signal
-   */
-  isReactive(n) {
-    return T(n);
-  },
-  /**
-   * Resolve a potentially reactive value
-   */
-  resolveValue(n) {
-    return T(n) ? n() : n;
-  },
-  /**
-   * Create a reactive effect for a value
-   */
-  createReactiveEffect(n, e) {
-    if (T(n)) {
-      const t = v(() => {
-        const r = n();
-        e(r);
-      });
-      return () => t.dispose();
-    }
-    return null;
-  },
-  /**
-   * Merge modifier properties
-   */
-  mergeProperties(n, e) {
-    const t = { ...n };
-    for (const [r, s] of Object.entries(e))
-      s !== void 0 && (t[r] = s);
-    return t;
-  },
-  /**
-   * Convert a CSS property name to camelCase
-   */
-  toCamelCase(n) {
-    return n.replace(/-([a-z])/g, (e, t) => t.toUpperCase());
-  },
-  /**
-   * Convert a camelCase property to CSS kebab-case
-   */
-  toKebabCase(n) {
-    return n.replace(/([A-Z])/g, "-$1").toLowerCase();
-  },
-  /**
-   * Normalize a CSS value
-   */
-  normalizeCSSValue(n) {
-    return typeof n == "number" ? `${n}px` : typeof n == "string" ? n : String(n);
-  }
-};
-function P(n, e, t) {
-  class r extends z {
-    constructor() {
-      super(...arguments), Q(this, "type", n), Q(this, "priority", e);
-    }
-    apply(i, a) {
-      return t(i, a, this.properties);
-    }
-  }
-  return (s) => new r(s);
-}
-function _r(n, e = "combined", t = 999) {
-  return P(e, t, (r, s, i) => {
-    let a = r;
-    for (const o of n) {
-      const c = o.apply(a, s);
-      c && typeof c == "object" && "type" in c && (a = c);
-    }
-    return a;
-  })({});
-}
-function Or(n, e) {
-  return P(
-    `conditional-${e.type}`,
-    e.priority,
-    (t, r, s) => {
-      if (K.resolveValue(n))
-        return e.apply(t, r);
-      if (T(n)) {
-        const a = v(() => {
-          const o = n();
-          r.element && o && e.apply(t, r);
-        });
-        if (!t.dispose)
-          t.dispose = () => a.dispose();
-        else {
-          const o = t.dispose;
-          t.dispose = () => {
-            a.dispose(), o();
-          };
-        }
-      }
-      return t;
-    }
-  )({});
-}
-function kr(n, e) {
-  return P("state", 500, (t, r, s) => {
-    let i = t;
-    const a = (c) => {
-      const l = e[c] || [];
-      for (const u of l) {
-        const p = u.apply(i, r);
-        p && typeof p == "object" && "type" in p && (i = p);
-      }
-    };
-    a(n());
-    const o = v(() => {
-      const c = n();
-      a(c);
-    });
-    if (!t.dispose)
-      t.dispose = () => o.dispose();
-    else {
-      const c = t.dispose;
-      t.dispose = () => {
-        o.dispose(), c();
-      };
-    }
-    return i;
-  })({});
-}
-function Rr(n, e = []) {
-  return P("responsive", 100, (t, r, s) => {
-    let i = t;
-    const a = () => {
-      const l = window.innerWidth;
-      let u = e;
-      for (const [p, d] of Object.entries(n)) {
-        const f = parseInt(p);
-        l >= f && (u = d);
-      }
-      for (const p of u) {
-        const d = p.apply(i, r);
-        d && typeof d == "object" && "type" in d && (i = d);
-      }
-    };
-    a();
-    const o = () => a();
-    window.addEventListener("resize", o);
-    const c = () => window.removeEventListener("resize", o);
-    if (!t.dispose)
-      t.dispose = c;
-    else {
-      const l = t.dispose;
-      t.dispose = () => {
-        c(), l();
-      };
-    }
-    return i;
-  })({});
-}
-function Tr(n) {
-  return P("class", 50, (e, t, r) => {
-    if (!t.element) return e;
-    const s = (i) => {
-      const a = Array.isArray(i) ? i : i.split(" ").filter(Boolean);
-      t.element instanceof HTMLElement && t.element.classList.add(...a);
-    };
-    if (T(n)) {
-      let i = [];
-      const a = v(() => {
-        const o = n(), c = Array.isArray(o) ? o : o.split(" ").filter(Boolean);
-        t.element instanceof HTMLElement && (t.element.classList.remove(...i), t.element.classList.add(...c), i = c);
-      });
-      if (!e.dispose)
-        e.dispose = () => a.dispose();
-      else {
-        const o = e.dispose;
-        e.dispose = () => {
-          a.dispose(), o();
-        };
-      }
-    } else
-      s(n);
-    return e;
-  })({});
-}
-function Mr(n) {
-  return P("style", 200, (e, t, r) => {
-    if (!t.element) return e;
-    const s = (i) => {
-      if (t.element instanceof HTMLElement)
-        for (const [a, o] of Object.entries(i)) {
-          const c = K.toKebabCase(a), l = K.normalizeCSSValue(o);
-          t.element.style.setProperty(c, l);
-        }
-    };
-    if (T(n)) {
-      const i = v(() => {
-        const a = n();
-        s(a);
-      });
-      if (!e.dispose)
-        e.dispose = () => i.dispose();
-      else {
-        const a = e.dispose;
-        e.dispose = () => {
-          i.dispose(), a();
-        };
-      }
-    } else
-      s(n);
-    return e;
-  })({});
-}
-function jr(n) {
-  return P("event", 300, (e, t, r) => {
-    if (!t.element) return e;
-    const s = [];
-    for (const [a, o] of Object.entries(n))
-      t.element.addEventListener(a, o), s.push(() => {
-        t.element?.removeEventListener(a, o);
-      });
-    const i = () => s.forEach((a) => a());
-    if (!e.dispose)
-      e.dispose = i;
-    else {
-      const a = e.dispose;
-      e.dispose = () => {
-        i(), a();
-      };
-    }
-    return e;
-  })({});
-}
-function Pr() {
-  return {
-    combineClasses(...n) {
-      const e = [];
-      return n.forEach((t) => {
-        if (t) {
-          const r = A.processClasses(t);
-          e.push(...r);
-        }
-      }), A.deduplicateClasses(e).join(" ");
-    },
-    conditionalClasses(n) {
-      return Object.entries(n).filter(([e, t]) => t).map(([e, t]) => e);
-    },
-    mergeClassProps(...n) {
-      const e = [];
-      return n.forEach((t) => {
-        if (t?.css) {
-          const r = A.processClasses(t.css);
-          e.push(...r);
-        }
-      }), e.length === 0 ? {} : {
-        css: A.deduplicateClasses(e)
-      };
-    },
-    extractClasses(n) {
-      return A.processClasses(n);
-    },
-    validateClassNames(n) {
-      const e = [], t = [];
-      return n.forEach((r) => {
-        A.sanitizeClassName(r) === r.toLowerCase() ? e.push(r) : t.push(r);
-      }), { valid: e, invalid: t };
-    }
-  };
-}
-class ot {
-  /**
-   * Apply CSS classes to a DOM element
-   */
-  applyCSSClasses(e, t) {
-    if (!t) return;
-    const s = (Array.isArray(t) ? t : [t]).filter(Boolean);
-    s.length > 0 && (e.className = s.join(" "));
-  }
-  /**
-   * Apply reactive CSS classes to a DOM element
-   */
-  applyReactiveCSSClasses(e, t) {
-    const r = require("../reactive").createEffect;
-    return r(() => {
-      const i = t();
-      e.className = i;
-    });
-  }
-  /**
-   * Update CSS classes on an existing element
-   */
-  updateCSSClasses(e, t) {
-    this.applyCSSClasses(e, t);
-  }
-  /**
-   * Remove CSS classes from an element
-   */
-  removeCSSClasses(e, t) {
-    if (!t) return;
-    const r = Array.isArray(t) ? t : [t], i = e.className.split(" ").filter((a) => !r.includes(a));
-    e.className = i.join(" ");
-  }
-  /**
-   * Merge CSS classes with existing classes on an element
-   */
-  mergeCSSClasses(e, t) {
-    if (!t) return;
-    const r = Array.isArray(t) ? t : [t], i = [...e.className ? e.className.split(" ") : [], ...r.filter(Boolean)], a = [...new Set(i)];
-    e.className = a.join(" ");
-  }
-}
-const Ar = new ot();
-function $r(n, e = {}, t = [], r) {
-  const i = {
-    ...{
-      type: "element",
-      tag: n,
-      props: e,
-      children: t
-    }
-  };
-  return r && (Array.isArray(r) ? i.cssClasses = r : i.reactiveClasses = r), i;
-}
-function Vr(n) {
-  return {
-    static: n.cssClasses || [],
-    reactive: n.reactiveClasses
-  };
-}
-const ee = {
-  /**
-   * Apply CSS classes to an element during creation
-   */
-  applyCSSClasses(n, e) {
-    if (e.cssClasses && e.cssClasses.length > 0) {
-      const t = e.cssClasses.join(" ");
-      n.className = t;
-    }
-    if (e.reactiveClasses && T(e.reactiveClasses)) {
-      const t = e.reactiveClasses();
-      n.className = t, v(() => {
-        const r = e.reactiveClasses();
-        n.className = r;
-      });
-    }
-  },
-  /**
-   * Process className prop and CSS classes together
-   */
-  processElementClasses(n, e) {
-    let t = [];
-    if (e.props?.className) {
-      const r = typeof e.props.className == "string" ? e.props.className.split(" ").filter(Boolean) : [];
-      t.push(...r);
-    }
-    if (e.cssClasses && t.push(...e.cssClasses), t.length > 0) {
-      const r = [...new Set(t)];
-      n.className = r.join(" ");
-    }
-    e.reactiveClasses && T(e.reactiveClasses) && v(() => {
-      const r = e.reactiveClasses();
-      if (t.length > 0) {
-        const s = t.join(" ");
-        n.className = `${s} ${r}`.trim();
-      } else
-        n.className = r;
-    });
-  }
-};
-function zr(n) {
-  const e = n.createElement.bind(n), t = (r) => {
-    const s = e(r), i = r;
-    return (i.cssClasses || i.reactiveClasses) && ee.processElementClasses(s, i), s;
-  };
-  return n.createElement = t, Object.assign(n, ee);
-}
-function Dr(n, e = {}, t = [], r) {
-  const s = {
-    type: "element",
-    tag: n,
-    props: e,
-    children: t
-  };
-  return r && (Array.isArray(r) ? s.cssClasses = r : s.reactiveClasses = r), s;
-}
-function Br(n) {
-  const e = n;
-  return !!(e.cssClasses || e.reactiveClasses);
-}
-class ct extends se {
-  constructor(e, t) {
-    super(e), this.definitions = t;
-  }
-  resolve() {
-    const e = this.getCurrentTheme(), t = this.definitions[e] || this.definitions.light;
-    return be(t);
-  }
-  getCurrentTheme() {
-    return typeof window < "u" && window.matchMedia && window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
-  }
-}
-function Ir(n) {
-  return new ct("gradient-asset", n);
-}
-var lt = Object.defineProperty, ut = (n, e, t) => e in n ? lt(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, U = (n, e, t) => ut(n, typeof e != "symbol" ? e + "" : e, t);
-class F extends se {
-  constructor(e, t, r) {
-    super(e), this.reactiveDefinition = t, U(this, "currentGradient"), U(this, "subscriptions", []), U(this, "updateCallback"), this.updateCallback = r, this.currentGradient = this.resolveStaticGradient(), this.setupSignalSubscriptions();
-  }
-  /**
-   * Resolve current gradient to CSS
-   */
-  resolve() {
-    return this.gradientToCSS(this.currentGradient);
-  }
-  /**
-   * Get current static gradient (resolved from signals)
-   */
-  getCurrentGradient() {
-    return this.currentGradient;
-  }
-  /**
-   * Update the reactive definition and re-subscribe to signals
-   */
-  updateDefinition(e) {
-    this.cleanup(), this.reactiveDefinition = e, this.currentGradient = this.resolveStaticGradient(), this.setupSignalSubscriptions(), this.notifyUpdate();
-  }
-  /**
-   * Clean up signal subscriptions
-   */
-  cleanup() {
-    this.subscriptions.forEach((e) => e()), this.subscriptions = [];
-  }
-  resolveStaticGradient() {
-    const { type: e, options: t } = this.reactiveDefinition;
-    switch (e) {
-      case "linear":
-        return xe(this.resolveLinearOptions(t));
-      case "radial":
-        return Se(this.resolveRadialOptions(t));
-      case "angular":
-      case "conic":
-        return we(this.resolveAngularOptions(t));
-      default:
-        throw new Error(`Unsupported reactive gradient type: ${e}`);
-    }
-  }
-  resolveLinearOptions(e) {
-    return {
-      colors: e.colors.map((t) => this.resolveValue(t)),
-      stops: e.stops?.map((t) => this.resolveValue(t)),
-      startPoint: this.resolveValue(e.startPoint),
-      endPoint: this.resolveValue(e.endPoint),
-      angle: e.angle ? this.resolveValue(e.angle) : void 0
-    };
-  }
-  resolveRadialOptions(e) {
-    return {
-      colors: e.colors.map((t) => this.resolveValue(t)),
-      stops: e.stops?.map((t) => this.resolveValue(t)),
-      center: this.resolveValue(e.center),
-      startRadius: this.resolveValue(e.startRadius),
-      endRadius: this.resolveValue(e.endRadius),
-      shape: e.shape ? this.resolveValue(e.shape) : void 0
-    };
-  }
-  resolveAngularOptions(e) {
-    return {
-      colors: e.colors.map((t) => this.resolveValue(t)),
-      stops: e.stops?.map((t) => this.resolveValue(t)),
-      center: this.resolveValue(e.center),
-      startAngle: this.resolveValue(e.startAngle),
-      endAngle: this.resolveValue(e.endAngle)
-    };
-  }
-  resolveValue(e) {
-    return this.isSignal(e) ? e.value : e;
-  }
-  isSignal(e) {
-    return e !== null && typeof e == "object" && "value" in e && "subscribe" in e;
-  }
-  setupSignalSubscriptions() {
-    this.subscribeToSignalsInOptions(this.reactiveDefinition.options);
-  }
-  subscribeToSignalsInOptions(e) {
-    for (const [t, r] of Object.entries(e))
-      if (Array.isArray(r))
-        r.forEach((s) => {
-          if (this.isSignal(s)) {
-            const i = s.subscribe(() => this.handleSignalChange());
-            this.subscriptions.push(i);
-          }
-        });
-      else if (this.isSignal(r)) {
-        const s = r.subscribe(() => this.handleSignalChange());
-        this.subscriptions.push(s);
-      }
-  }
-  handleSignalChange() {
-    this.currentGradient = this.resolveStaticGradient(), this.notifyUpdate();
-  }
-  notifyUpdate() {
-    this.updateCallback && this.updateCallback();
-  }
-  gradientToCSS(e) {
-    const { gradientToCSS: t } = require("./css-generator");
-    return t(e);
-  }
-}
-class w extends Ce {
-  constructor(e, t, r) {
-    const s = w.resolveStateOptions(t);
-    super(e, s), this.reactiveStateGradients = t, this.updateCallback = r, U(this, "reactiveSubscriptions", []), this.setupStateSignalSubscriptions();
-  }
-  /**
-   * Update reactive state configuration
-   */
-  updateReactiveState(e) {
-    this.cleanupStateSubscriptions(), this.reactiveStateGradients = e;
-    const t = w.resolveStateOptions(e);
-    this.updateStateGradients(t), this.setupStateSignalSubscriptions(), this.notifyStateUpdate();
-  }
-  /**
-   * Clean up signal subscriptions
-   */
-  cleanupStateSubscriptions() {
-    this.reactiveSubscriptions.forEach((e) => e()), this.reactiveSubscriptions = [];
-  }
-  static resolveStateOptions(e) {
-    const t = {
-      default: w.resolveValue(e.default),
-      animation: e.animation
-    };
-    return e.hover && (t.hover = w.resolveValue(e.hover)), e.active && (t.active = w.resolveValue(e.active)), e.focus && (t.focus = w.resolveValue(e.focus)), e.disabled && (t.disabled = w.resolveValue(e.disabled)), t;
-  }
-  static resolveValue(e) {
-    return e !== null && typeof e == "object" && "value" in e && "subscribe" in e ? e.value : e;
-  }
-  static isSignal(e) {
-    return e !== null && typeof e == "object" && "value" in e && "subscribe" in e;
-  }
-  setupStateSignalSubscriptions() {
-    Object.entries(this.reactiveStateGradients).forEach(([e, t]) => {
-      if (e !== "animation" && w.isSignal(t)) {
-        const r = t.subscribe(() => this.handleStateSignalChange());
-        this.reactiveSubscriptions.push(r);
-      }
-    });
-  }
-  handleStateSignalChange() {
-    const e = w.resolveStateOptions(this.reactiveStateGradients);
-    this.updateStateGradients(e), this.notifyStateUpdate();
-  }
-  notifyStateUpdate() {
-    this.updateCallback && this.updateCallback();
-  }
-}
-const L = {
-  /**
-   * Create a reactive linear gradient
-   */
-  linear: (n, e) => new F(
-    "reactive-linear",
-    { type: "linear", options: n, __reactive: !0 },
-    e
-  ),
-  /**
-   * Create a reactive radial gradient
-   */
-  radial: (n, e) => new F(
-    "reactive-radial",
-    { type: "radial", options: n, __reactive: !0 },
-    e
-  ),
-  /**
-   * Create a reactive angular gradient
-   */
-  angular: (n, e) => new F(
-    "reactive-angular",
-    { type: "angular", options: n, __reactive: !0 },
-    e
-  ),
-  /**
-   * Create a reactive state gradient
-   */
-  state: (n, e, t) => new w(n, e, t)
-}, Nr = {
-  /**
-   * Create an animated gradient that cycles through colors
-   */
-  createAnimatedGradient: (n, e = 3e3) => {
-    const t = {
-      value: n[0],
-      subscribe: (r) => () => {
-      }
-    };
-    return L.linear({
-      colors: [t, n[1]],
-      startPoint: "top",
-      endPoint: "bottom"
-    });
-  },
-  /**
-   * Create a progress gradient that fills based on a signal
-   */
-  createProgressGradient: (n, e = "#007AFF") => L.linear({
-    colors: [e, "transparent"],
-    stops: [n, n],
-    // Both stops use the same signal
-    startPoint: "leading",
-    endPoint: "trailing"
-  }),
-  /**
-   * Create a data-driven gradient that reflects numeric values
-   */
-  createDataGradient: (n, e, t, r = ["#ff0000", "#ffff00", "#00ff00"]) => L.linear({
-    colors: r,
-    startPoint: "top",
-    endPoint: "bottom"
-  })
-}, Wr = {
-  /**
-   * Check if a background value is reactive
-   */
-  isReactiveBackground: (n) => n instanceof F || n instanceof w,
-  /**
-   * Create a reactive background from a signal
-   */
-  fromSignal: (n) => L.state("signal-background", {
-    default: n
-  })
-};
-function X(n, e = {}) {
-  const { fallback: t, errorFallback: r, timeout: s = 1e4, preload: i = "never" } = e;
-  let a = !1, o = null, c = !1, l = null, u = null;
-  const p = async () => {
-    a || c || o || u || (a = !0, c = !0, l = null, u = (async () => {
-      try {
-        const d = await Promise.race([
-          n(),
-          new Promise(
-            (f, g) => setTimeout(() => g(new Error("Component load timeout")), s)
-          )
-        ]);
-        o = "default" in d ? d.default : d;
-      } catch (d) {
-        const f = d;
-        (typeof process > "u" || process.env.NODE_ENV !== "test") && console.error("Failed to load lazy component:", f), l = f;
-      } finally {
-        c = !1, u = null;
-      }
-    })(), await u);
-  };
-  return i === "idle" && typeof requestIdleCallback < "u" ? requestIdleCallback(() => {
-    p().catch(() => {
-    });
-  }) : i === "idle" ? setTimeout(() => {
-    p().catch(() => {
-    });
-  }, 100) : i === "immediate" && p().catch(() => {
-  }), (d) => {
-    if (!a && !c && !o && p().catch(() => {
-    }), l)
-      return r ? r(l) : te(l);
-    if (c || !o)
-      return t || dt();
-    try {
-      return typeof o == "function" ? o(d) : o;
-    } catch (f) {
-      const g = f;
-      return (typeof process > "u" || process.env.NODE_ENV !== "test") && console.error("Error rendering lazy component:", g), te(g);
-    }
-  };
-}
-function Ur(n) {
-  return {
-    type: "component",
-    render: () => ({
-      type: "element",
-      tag: "div",
-      props: { class: "tachui-suspense" },
-      children: n.children.map(() => ({
-        type: "element",
-        tag: "div",
-        children: []
-      }))
-    }),
-    props: n,
-    id: `suspense-${Math.random().toString(36).substr(2, 9)}`
-  };
-}
-function pt(n) {
-  return n().then((e) => e && typeof e == "object" && "default" in e ? e.default : e);
-}
-function Fr(n, e = {}) {
-  const t = {};
-  for (const [r, s] of Object.entries(n))
-    t[r] = X(s, e);
-  return t;
-}
-function Lr(n) {
-  const e = Object.entries(n).map(
-    async ([t, r]) => [t, await pt(r)]
-  );
-  return Promise.all(e).then((t) => {
-    const r = {};
-    for (const [s, i] of t)
-      r[s] = i;
-    return r;
-  });
-}
-function dt() {
-  return {
-    type: "element",
-    tag: "div",
-    props: {
-      class: "tachui-lazy-loading",
-      style: "padding: 16px; color: #666; text-align: center;"
-    },
-    children: [
-      {
-        type: "text",
-        text: "Loading component..."
-      }
-    ]
-  };
-}
-function te(n) {
-  return {
-    type: "element",
-    tag: "div",
-    props: {
-      class: "tachui-lazy-error",
-      style: "padding: 16px; color: #d32f2f; border: 1px solid #d32f2f; border-radius: 4px; background: #ffeaea;"
-    },
-    children: [
-      {
-        type: "text",
-        text: `Failed to load component: ${n.message}`
-      }
-    ]
-  };
-}
-function Gr(n, e = {}) {
-  const { rootMargin: t = "50px", threshold: r = 0.1, ...s } = e;
-  return s.preload === "visible" && typeof IntersectionObserver < "u" ? (i) => {
-    const a = X(n, { ...s, preload: "never" });
-    return setTimeout(() => {
-      a(i);
-    }, 100), a(i);
-  } : X(n, s);
-}
-var ft = Object.defineProperty, ht = (n, e, t) => e in n ? ft(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, M = (n, e, t) => ht(n, typeof e != "symbol" ? e + "" : e, t);
-class mt {
-  constructor(e) {
-    M(this, "_signal"), M(this, "_setter"), M(this, "_subscribers", /* @__PURE__ */ new Set());
-    const [t, r] = j(e);
-    this._signal = t, this._setter = r;
-  }
-  get value() {
-    return this._signal();
-  }
-  set value(e) {
-    this._setter(e), this.notifySubscribers();
-  }
-  /**
-   * Update a property of the environment object
-   */
-  updateProperty(e, t) {
-    const s = { ...this._signal(), [e]: t };
-    this._setter(s), this.notifySubscribers();
-  }
-  /**
-   * Subscribe to changes
-   */
-  subscribe(e) {
-    return this._subscribers.add(e), () => this._subscribers.delete(e);
-  }
-  notifySubscribers() {
-    for (const e of this._subscribers)
-      try {
-        e();
-      } catch (t) {
-        console.error("Error in environment object subscriber:", t);
-      }
-  }
-  /**
-   * Create a reactive effect that runs when this object changes
-   */
-  onChange(e) {
-    const t = v(() => {
-      e(this._signal());
-    });
-    return () => t.dispose();
-  }
-}
-class fe {
-  constructor(e, t) {
-    M(this, "key"), M(this, "componentContext"), M(this, "_cachedValue"), M(this, "_subscriptionCleanup"), this.key = e, this.componentContext = t, t.onCleanup(() => {
-      this._subscriptionCleanup && this._subscriptionCleanup();
-    });
-  }
-  get wrappedValue() {
-    if (this._cachedValue === void 0 && (this._cachedValue = Oe(this.key), this._cachedValue && typeof this._cachedValue == "object" && "subscribe" in this._cachedValue)) {
-      const e = this._cachedValue;
-      typeof e.subscribe == "function" && (this._subscriptionCleanup = e.subscribe(() => {
-        this.componentContext.setState(`_env_${this.key.name}_trigger`, Date.now());
-      }));
-    }
-    return this._cachedValue;
-  }
-  get projectedValue() {
-    return this;
-  }
-}
-function gt(n) {
-  const e = Ee();
-  return new fe(n, e);
-}
-function yt(n, e) {
-  _e(n, e);
-}
-function Hr(n, e) {
-  return new mt(e);
-}
-function qr(n) {
-  return n && typeof n == "object" && "wrappedValue" in n && "key" in n && "componentContext" in n && n instanceof fe;
-}
-const Kr = {
-  /**
-   * Application theme
-   */
-  Theme: D("Theme", {
-    mode: "light",
-    primaryColor: "#007AFF",
-    secondaryColor: "#5856D6"
-  }),
-  /**
-   * Localization service
-   */
-  Localization: D("Localization"),
-  /**
-   * Navigation service
-   */
-  Navigation: D("Navigation"),
-  /**
-   * Application configuration
-   */
-  Config: D("Config"),
-  /**
-   * User authentication
-   */
-  Auth: D("Auth")
-};
-var bt = Object.defineProperty, Ct = (n, e, t) => e in n ? bt(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, V = (n, e, t) => Ct(n, typeof e != "symbol" ? e + "" : e, t);
-class he {
-  constructor() {
-    V(this, "_objectWillChange"), V(this, "_notifyCount", 0);
-    const [e, t] = j(void 0);
-    this._objectWillChange = {
-      getValue: e,
-      peek: e
-    }, this._notifySetter = t;
-  }
-  get objectWillChange() {
-    return this._objectWillChange;
-  }
-  /**
-   * Notify observers that the object has changed
-   * Call this method whenever properties of the object change
-   */
-  notifyChange() {
-    this._notifyCount++;
-    const e = this._notifySetter;
-    e && e(void 0);
-  }
-  /**
-   * Get the current notification count (for debugging)
-   */
-  get notificationCount() {
-    return this._notifyCount;
-  }
-}
-class vt {
-  constructor(e, t, r, s = {}) {
-    V(this, "_object"), V(this, "_metadata"), V(this, "_effectCleanup"), this._object = e, this._metadata = {
-      type: "ObservedObject",
-      propertyName: r,
-      componentId: t.id,
-      options: s
-    }, this.setupObservation();
-    const i = ie();
-    i && i.cleanups.push(() => {
-      this.cleanup();
-    });
-  }
-  get wrappedValue() {
-    return this._object;
-  }
-  get projectedValue() {
-    return this;
-  }
-  /**
-   * Get property wrapper metadata
-   */
-  get metadata() {
-    return this._metadata;
-  }
-  /**
-   * Set up reactive observation of the object
-   */
-  setupObservation() {
-    const e = v(() => {
-      this._object.objectWillChange();
-    });
-    this._effectCleanup = () => e.dispose();
-  }
-  /**
-   * Cleanup observation
-   */
-  cleanup() {
-    this._effectCleanup && (this._effectCleanup(), this._effectCleanup = void 0);
-  }
-  /**
-   * Replace the observed object (advanced usage)
-   */
-  updateObject(e) {
-    this.cleanup(), this._object = e, this.setupObservation();
-  }
-}
-const wt = (n, e = {}) => {
-  const t = xt(), r = Et() || "observedObject";
-  return new vt(n, t, r, e);
-};
-function St(n, e = {}) {
-  const t = new he();
-  return new Proxy(n, {
-    set(s, i, a) {
-      const o = s[i], c = Reflect.set(s, i, a);
-      return c && o !== a && e.autoNotify !== !1 && t.notifyChange(), c;
-    },
-    get(s, i) {
-      return i === "objectWillChange" ? t.objectWillChange : i === "notifyChange" ? () => t.notifyChange() : i === "notificationCount" ? t.notificationCount : Reflect.get(s, i);
-    }
-  });
-}
-function Xr(n = {}) {
-  return (e) => class extends e {
-    constructor(...t) {
-      super(...t), V(this, "_observableBase", new he()), n.autoNotify !== !1 && this.setupAutoNotification();
-    }
-    get objectWillChange() {
-      return this._observableBase.objectWillChange;
-    }
-    get notificationCount() {
-      return this._observableBase.notificationCount;
-    }
-    notifyChange() {
-      this._observableBase.notifyChange();
-    }
-    setupAutoNotification() {
-      const t = Object.getOwnPropertyNames(this);
-      for (const r of t) {
-        if (r.startsWith("_") || typeof this[r] == "function")
-          continue;
-        let s = this[r];
-        Object.defineProperty(this, r, {
-          get: () => s,
-          set: (i) => {
-            s !== i && (s = i, this.notifyChange());
-          },
-          enumerable: !0,
-          configurable: !0
-        });
-      }
-    }
-  };
-}
-function xt() {
-  const n = ie();
-  if (!n?.context.has(re))
-    throw new Error("@ObservedObject can only be used within a component context");
-  return n.context.get(re);
-}
-function Et() {
-  try {
-    const n = new Error().stack;
-    if (n)
-      return n.match(/at (\w+)\./)?.[1] || null;
-  } catch {
-  }
-  return null;
-}
-const re = Symbol("TachUI.ComponentContext");
-function _t(n) {
-  return n && typeof n == "object" && "objectWillChange" in n && "notifyChange" in n;
-}
-function Yr(n) {
-  return n && typeof n == "object" && "wrappedValue" in n && "projectedValue" in n && _t(n.wrappedValue);
-}
-function Jr(n, e = {}) {
-  return St({ ...n }, e);
-}
-const Zr = wt;
-var Ot = Object.defineProperty, kt = (n, e, t) => e in n ? Ot(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, O = (n, e, t) => kt(n, typeof e != "symbol" ? e + "" : e, t);
-class Rt {
-  constructor(e) {
-    this.componentContext = e, O(this, "states", /* @__PURE__ */ new Map()), O(this, "bindings", /* @__PURE__ */ new Map()), O(this, "observedObjects", /* @__PURE__ */ new Map()), O(this, "environmentObjects", /* @__PURE__ */ new Map()), O(this, "registry"), this.registry = new Tt();
-  }
-  /**
-   * Register a @State property wrapper
-   */
-  registerState(e, t = {}) {
-    const r = e.metadata;
-    if (r) {
-      const s = `${r.componentId}_${r.propertyName}`;
-      this.states.set(s, e), this.registry.register(r), process.env.NODE_ENV === "development" && this.setupStateDebugging(e, r);
-    }
-  }
-  /**
-   * Register a @Binding property wrapper
-   */
-  registerBinding(e, t = {}) {
-    const r = `${this.componentContext.id}_${t.name || "binding"}_${Date.now()}`;
-    this.bindings.set(r, e);
-    const s = {
-      type: "Binding",
-      propertyName: t.name || "binding",
-      componentId: this.componentContext.id,
-      options: t
-    };
-    this.registry.register(s);
-  }
-  /**
-   * Register an @ObservedObject property wrapper
-   */
-  registerObservedObject(e, t = {}) {
-    const r = e.metadata;
-    if (r) {
-      const s = `${r.componentId}_${r.propertyName}`;
-      this.observedObjects.set(s, e), this.registry.register(r), process.env.NODE_ENV === "development" && this.setupObservedObjectDebugging(e, r);
-    }
-  }
-  /**
-   * Register an @EnvironmentObject property wrapper
-   */
-  registerEnvironmentObject(e, t) {
-    const r = e.metadata;
-    if (r) {
-      const s = `${r.componentId}_${r.propertyName}`;
-      this.environmentObjects.set(s, e), this.registry.register(r);
-    }
-  }
-  /**
-   * Clean up all property wrappers for this component
-   */
-  cleanup() {
-    this.states.clear(), this.bindings.clear(), this.observedObjects.clear(), this.environmentObjects.clear(), this.registry.cleanup(this.componentContext.id);
-  }
-  /**
-   * Get all registered states (for debugging)
-   */
-  getStates() {
-    return new Map(this.states);
-  }
-  /**
-   * Get all registered bindings (for debugging)
-   */
-  getBindings() {
-    return new Map(this.bindings);
-  }
-  /**
-   * Get all registered observed objects (for debugging)
-   */
-  getObservedObjects() {
-    return new Map(this.observedObjects);
-  }
-  /**
-   * Get all registered environment objects (for debugging)
-   */
-  getEnvironmentObjects() {
-    return new Map(this.environmentObjects);
-  }
-  /**
-   * Get property wrapper registry
-   */
-  getRegistry() {
-    return this.registry;
-  }
-  /**
-   * Set up debugging for @State property wrappers
-   */
-  setupStateDebugging(e, t) {
-    if (typeof window < "u") {
-      const r = window.__TACHUI_DEBUG__ || {};
-      r.states || (r.states = {}), r.states[`${t.componentId}_${t.propertyName}`] = {
-        state: e,
-        metadata: t,
-        getValue: () => e.wrappedValue,
-        setValue: (s) => {
-          e.projectedValue.set(s);
-        },
-        getBinding: () => e.projectedValue
-      }, window.__TACHUI_DEBUG__ = r;
-    }
-  }
-  /**
-   * Set up debugging for @ObservedObject property wrappers
-   */
-  setupObservedObjectDebugging(e, t) {
-    if (typeof window < "u") {
-      const r = window.__TACHUI_DEBUG__ || {};
-      r.observedObjects || (r.observedObjects = {}), r.observedObjects[`${t.componentId}_${t.propertyName}`] = {
-        observedObject: e,
-        metadata: t,
-        getObject: () => e.wrappedValue,
-        getNotificationCount: () => e.wrappedValue.notificationCount || 0,
-        triggerChange: () => e.wrappedValue.notifyChange()
-      }, window.__TACHUI_DEBUG__ = r;
-    }
-  }
-}
-class Tt {
-  constructor() {
-    O(this, "metadata", /* @__PURE__ */ new Map());
-  }
-  /**
-   * Register property wrapper metadata
-   */
-  register(e) {
-    const t = e.componentId, r = this.metadata.get(t) || [];
-    r.push(e), this.metadata.set(t, r);
-  }
-  /**
-   * Unregister a specific property wrapper
-   */
-  unregister(e, t) {
-    const s = (this.metadata.get(e) || []).filter((i) => i.propertyName !== t);
-    s.length > 0 ? this.metadata.set(e, s) : this.metadata.delete(e);
-  }
-  /**
-   * Clean up all metadata for a component
-   */
-  cleanup(e) {
-    this.metadata.delete(e);
-  }
-  /**
-   * Get all metadata for a component
-   */
-  getMetadata(e) {
-    return this.metadata.get(e) || [];
-  }
-  /**
-   * Get all registered metadata (for debugging)
-   */
-  getAllMetadata() {
-    return new Map(this.metadata);
-  }
-}
-function Qr(n) {
-  return new Rt(n);
-}
-const me = class B {
-  constructor() {
-    O(this, "managers", /* @__PURE__ */ new Map());
-  }
-  static getInstance() {
-    return B.instance || (B.instance = new B()), B.instance;
-  }
-  register(e, t) {
-    this.managers.set(e, t);
-  }
-  unregister(e) {
-    this.managers.delete(e);
-  }
-  getManager(e) {
-    return this.managers.get(e);
-  }
-  getAllManagers() {
-    return new Map(this.managers);
-  }
-  /**
-   * Get debugging information for all components
-   */
-  getDebugInfo() {
-    const e = {};
-    for (const [t, r] of this.managers)
-      e[t] = {
-        states: r.getStates().size,
-        bindings: r.getBindings().size,
-        observedObjects: r.getObservedObjects().size,
-        environmentObjects: r.getEnvironmentObjects().size,
-        metadata: r.getRegistry().getMetadata(t)
-      };
-    return e;
-  }
-};
-O(me, "instance");
-let N = me;
-function en(n, e) {
-  N.getInstance().register(n, e);
-}
-function tn(n) {
-  N.getInstance().unregister(n);
-}
-function Mt(n) {
-  return N.getInstance().getManager(n);
-}
-function jt() {
-  return N.getInstance().getAllManagers();
-}
-function Pt() {
-  return N.getInstance().getDebugInfo();
-}
-function rn() {
-  if (typeof window < "u" && process.env.NODE_ENV === "development") {
-    const n = window.__TACHUI_DEBUG__ || {};
-    n.stateManagers = {
-      getAll: jt,
-      getDebugInfo: Pt,
-      getManager: Mt
-    }, window.__TACHUI_DEBUG__ = n, console.log(
-      "TachUI State Management debugging enabled. Use window.__TACHUI_DEBUG__.stateManagers"
-    );
-  }
-}
-const nn = yt;
-function sn(n) {
-  return console.warn("useEnvironmentObject is deprecated, use EnvironmentObject instead"), gt(n);
-}
-const an = {
-  /**
-   * Check if a value is any kind of property wrapper
-   */
-  isPropertyWrapper(n) {
-    return n && typeof n == "object" && "wrappedValue" in n && "projectedValue" in n;
-  },
-  /**
-   * Extract the wrapped value from any property wrapper
-   */
-  unwrap(n) {
-    return this.isPropertyWrapper(n) ? n.wrappedValue : n;
-  },
-  /**
-   * Create a debug snapshot of all property wrappers in a component
-   */
-  createDebugSnapshot(n) {
-    if (typeof window < "u") {
-      const e = window.__TACHUI_DEBUG__;
-      if (e)
-        return {
-          states: e.states ? Object.keys(e.states).filter((t) => t.startsWith(n)).reduce((t, r) => (t[r] = e.states[r].getValue(), t), {}) : {},
-          observedObjects: e.observedObjects ? Object.keys(e.observedObjects).filter((t) => t.startsWith(n)).reduce((t, r) => (t[r] = {
-            notificationCount: e.observedObjects[r].getNotificationCount(),
-            object: e.observedObjects[r].getObject()
-          }, t), {}) : {}
-        };
-    }
-    return null;
-  }
-}, on = "0.1.0";
-export {
-  kr as $,
-  dr as A,
-  Ze as B,
-  Gt as C,
-  Qe as D,
-  et as E,
-  Zt as F,
-  Je as G,
-  tt as H,
-  rt as I,
-  nt as J,
-  vr as K,
-  Qt as L,
-  st as M,
-  wr as N,
-  Sr as O,
-  xr as P,
-  Er as Q,
-  Tr as R,
-  Ve as S,
-  Jt as T,
-  _r as U,
-  on as V,
-  Or as W,
-  P as X,
-  jr as Y,
-  K as Z,
-  Rr as _,
-  qt as a,
-  rn as a$,
-  Mr as a0,
-  fr as a1,
-  hr as a2,
-  mr as a3,
-  gr as a4,
-  yr as a5,
-  br as a6,
-  k as a7,
-  He as a8,
-  qe as a9,
-  ot as aA,
-  Ar as aB,
-  $r as aC,
-  Vr as aD,
-  ee as aE,
-  zr as aF,
-  Dr as aG,
-  Br as aH,
-  nn as aI,
-  sn as aJ,
-  an as aK,
-  Kr as aL,
-  Hr as aM,
-  gt as aN,
-  qr as aO,
-  yt as aP,
-  Jr as aQ,
-  _t as aR,
-  Yr as aS,
-  St as aT,
-  he as aU,
-  Zr as aV,
-  Xr as aW,
-  Qr as aX,
-  jt as aY,
-  Mt as aZ,
-  Pt as a_,
-  Ke as aa,
-  Cr as ab,
-  ct as ac,
-  Ir as ad,
-  F as ae,
-  w as af,
-  L as ag,
-  Nr as ah,
-  Wr as ai,
-  ue as aj,
-  de as ak,
-  Be as al,
-  pe as am,
-  rr as an,
-  tr as ao,
-  sr as ap,
-  Ue as aq,
-  nr as ar,
-  Le as as,
-  Fe as at,
-  ir as au,
-  ar as av,
-  or as aw,
-  cr as ax,
-  lr as ay,
-  Pr as az,
-  Xt as b,
-  en as b0,
-  Rt as b1,
-  tn as b2,
-  Kt as c,
-  ae as d,
-  oe as e,
-  Y as f,
-  ce as g,
-  ke as h,
-  Ht as i,
-  Re as j,
-  Te as k,
-  je as l,
-  Yt as m,
-  le as n,
-  Pe as o,
-  Ae as p,
-  er as q,
-  Me as r,
-  Fr as s,
-  Gr as t,
-  X as u,
-  pt as v,
-  Lr as w,
-  Ur as x,
-  ur as y,
-  pr as z
-};