@tachui/core 0.7.0-alpha1 → 0.7.1-alpha

package/dist/index-Nfi2SBQh.js

@@ -0,0 +1,3268 @@
+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
+};