@tachui/core 0.7.0-alpha1 → 0.7.1-alpha

package/dist/binding-CmdpowkI.js

@@ -0,0 +1,2276 @@
+import { A as E, dN as I, dP as b } from "./concatenated-component-DPcl2TEO.js";
+import { C as f, I as W } from "./Spacer-BbteDQ9I.js";
+import { a as Q, n as X } from "./scheduler-7SvC3a21.js";
+import { c as Y } from "./effect-CytAc9em.js";
+import { j as q } from "./dom-bridge-Cx-s6Ihx.js";
+var tt = Object.defineProperty, et = (t, e, n) => e in t ? tt(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n, S = (t, e, n) => et(t, typeof e != "symbol" ? e + "" : e, n);
+class P extends E {
+  constructor(e, n = [], o = "", r = {}) {
+    super(o || e), S(this, "family"), S(this, "fallbacks"), S(this, "options"), S(this, "loaded", !1), S(this, "loadPromise", null), this.family = e, this.fallbacks = n, this.options = {
+      loading: "lazy",
+      fontDisplay: "swap",
+      preconnect: !0,
+      ...r
+    }, this.options.loading === "eager" && this.load();
+  }
+  /**
+   * Static factory method for SwiftUI-style initialization
+   */
+  static init(e, n = [], o, r = {}) {
+    return new P(e, n, o, r);
+  }
+  /**
+   * Get the full font-family CSS value including fallbacks
+   */
+  get value() {
+    return [this.family, ...this.fallbacks].map((n) => n.includes(" ") ? `"${n}"` : n).join(", ");
+  }
+  /**
+   * Load the font if not already loaded
+   */
+  async load() {
+    if (!(this.loaded || !this.options.fontUrl)) {
+      if (this.loadPromise)
+        return this.loadPromise;
+      this.loadPromise = this.loadFont(), await this.loadPromise, this.loaded = !0;
+    }
+  }
+  /**
+   * Internal font loading implementation
+   */
+  async loadFont() {
+    const { fontUrl: e, preconnect: n } = this.options;
+    if (e) {
+      if (n && typeof document < "u" && document.querySelector)
+        try {
+          const r = new URL(e).origin;
+          if (!document.querySelector(`link[rel="preconnect"][href="${r}"]`)) {
+            const i = document.createElement("link");
+            i.rel = "preconnect", i.href = r, i.crossOrigin = "anonymous", document.head.appendChild(i);
+          }
+        } catch {
+        }
+      if (e.endsWith(".css") || e.includes("fonts.googleapis.com") ? await this.loadFontCSS(e) : await this.loadFontFile(e), "fonts" in document)
+        try {
+          await document.fonts.ready;
+          const r = `16px ${this.family.includes(" ") ? `"${this.family}"` : this.family}`;
+          document.fonts.check(r) || console.warn(`⚠️ Font "${this.family}" may not have loaded correctly`);
+        } catch {
+        }
+    }
+  }
+  /**
+   * Load a CSS file containing @font-face rules
+   */
+  async loadFontCSS(e) {
+    return new Promise((n, o) => {
+      if (document.querySelector(`link[href="${e}"]`)) {
+        n();
+        return;
+      }
+      const i = document.createElement("link");
+      i.rel = "stylesheet", i.href = e, i.onload = () => {
+        n();
+      }, i.onerror = (s) => {
+        console.warn(`⚠️ Failed to load font CSS for ${this.family}:`, e), n();
+      }, document.head.appendChild(i);
+    });
+  }
+  /**
+   * Load a font file directly and create @font-face rule
+   */
+  async loadFontFile(e) {
+    const { fontFormat: n, fontDisplay: o, weightRange: r, widthRange: i } = this.options;
+    let s = "";
+    n ? s = `format('${n}')` : e.endsWith(".woff2") ? s = "format('woff2')" : e.endsWith(".woff") ? s = "format('woff')" : e.endsWith(".ttf") && (s = "format('truetype')");
+    let l = `
+      @font-face {
+        font-family: "${this.family}";
+        src: url("${e}") ${s};
+        font-display: ${o || "swap"};
+    `;
+    r && (l += `font-weight: ${r[0]} ${r[1]};
+`), i && (l += `font-stretch: ${i[0]}% ${i[1]}%;
+`), l += "}";
+    const d = document.createElement("style");
+    if (d.textContent = l, document.head.appendChild(d), "FontFace" in window)
+      try {
+        const p = new FontFace(this.family, `url(${e})`, {
+          display: o || "swap",
+          weight: r ? `${r[0]} ${r[1]}` : void 0,
+          stretch: i ? `${i[0]}% ${i[1]}%` : void 0
+        });
+        await p.load(), document.fonts.add(p);
+      } catch {
+      }
+  }
+  /**
+   * Create a CSS variable for this font
+   */
+  toCSSVariable(e) {
+    return `${e || `--font-${this.name.toLowerCase().replace(/\s+/g, "-")}`}: ${this.value};`;
+  }
+  /**
+   * Get debug information
+   */
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return `FontAsset(${this.family}, loaded: ${this.loaded})`;
+  }
+  /**
+   * Resolve the font value (required by Asset base class)
+   */
+  resolve() {
+    return this.options.loading === "lazy" && !this.loaded && this.options.fontUrl && this.load(), this.value;
+  }
+}
+const Mt = {
+  ultraCondensed: 50,
+  extraCondensed: 62.5,
+  condensed: 75,
+  semiCondensed: 87.5,
+  normal: 100,
+  semiExpanded: 112.5,
+  expanded: 125,
+  extraExpanded: 150,
+  ultraExpanded: 200
+}, O = {
+  sansSerif: ["system-ui", "-apple-system", "BlinkMacSystemFont", "Segoe UI", "Roboto", "Helvetica Neue", "Arial", "sans-serif"],
+  serif: ["Georgia", "Cambria", "Times New Roman", "Times", "serif"],
+  monospace: ["ui-monospace", "SFMono-Regular", "SF Mono", "Consolas", "Liberation Mono", "Menlo", "Courier", "monospace"],
+  cursive: ["cursive"],
+  fantasy: ["fantasy"]
+};
+function Tt(t = "sansSerif", e) {
+  return new P("", [...O[t]], e || `system-${t}`);
+}
+function Et(t, e = [400], n, o = {}) {
+  const r = e.join(";"), s = `https://fonts.googleapis.com/css2?family=${t.replace(/\s+/g, "+")}:wght@${r}&display=swap`;
+  return new P(
+    t,
+    [...O.sansSerif],
+    n || t.toLowerCase().replace(/\s+/g, "-"),
+    {
+      ...o,
+      fontUrl: s,
+      preconnect: !0
+    }
+  );
+}
+function Vt(t, e, n, o = [...O.sansSerif], r) {
+  const i = {};
+  return n.slant && (i.slnt = n.slant), n.optical && (i.opsz = n.optical), n.custom && Object.assign(i, n.custom), new P(t, o, r, {
+    fontUrl: e,
+    weightRange: n.weight,
+    widthRange: n.width,
+    variableAxes: i,
+    fontDisplay: "swap"
+  });
+}
+var nt = Object.defineProperty, ot = (t, e, n) => e in t ? nt(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n, rt = (t, e, n) => ot(t, e + "", n);
+class it {
+  constructor() {
+    rt(this, "assets", /* @__PURE__ */ new Map());
+  }
+  add(e, n) {
+    this.assets.set(e, n);
+  }
+  get(e) {
+    return this.assets.get(e);
+  }
+  getAll() {
+    return new Map(this.assets);
+  }
+  // Proxy handler for dot notation access
+  asProxy() {
+    return new Proxy(
+      {},
+      {
+        get: (e, n) => {
+          if (n === "toString" || n === "valueOf")
+            return () => "[Assets]";
+          const o = this.assets.get(n);
+          if (o)
+            return o instanceof f ? new Proxy(o, {
+              get: (r, i) => i === "light" || i === "dark" ? r[i] : i === "toString" || i === "valueOf" ? () => r.resolve() : r[i]
+            }) : o instanceof P ? new Proxy(o, {
+              get: (r, i) => i === "family" || i === "fallbacks" || i === "options" ? r[i] : i === "toString" || i === "valueOf" ? () => r.resolve() : r[i]
+            }) : o;
+        },
+        // Add ownKeys handler to support Object.keys() enumeration
+        ownKeys: (e) => Array.from(this.assets.keys()),
+        // Add has handler to support 'in' operator
+        has: (e, n) => this.assets.has(n)
+      }
+    );
+  }
+}
+const w = new it(), at = w.asProxy(), kt = at;
+function h(t, e) {
+  if (typeof t == "string" && e instanceof E)
+    w.add(t, e);
+  else if (t instanceof E && typeof e == "string")
+    w.add(e, t);
+  else if (t instanceof E && e === void 0)
+    w.add(t.name, t);
+  else
+    throw new Error("registerAsset requires either (name, asset), (asset), or (asset, overrideName)");
+}
+function It(t, e, n = "") {
+  return f.init({
+    default: t,
+    light: t,
+    dark: e,
+    name: n
+  });
+}
+function Bt(t, e, n, o = "", r) {
+  return W.init({
+    default: t,
+    light: e,
+    dark: n,
+    name: o,
+    options: r
+  });
+}
+function Dt(t, e = [], n = "", o) {
+  return P.init(t, e, n, o);
+}
+function Nt() {
+  const t = w.getAll(), e = [];
+  for (const [n, o] of t) {
+    let r = "custom";
+    o instanceof f ? r = "color" : o instanceof W ? r = "image" : o instanceof P && (r = "font"), e.push({
+      name: n,
+      type: r,
+      asset: o
+    });
+  }
+  return e.sort((n, o) => n.name.localeCompare(o.name));
+}
+function Lt() {
+  return Array.from(w.getAll().keys()).sort();
+}
+h(f.init({
+  default: "#007AFF",
+  light: "#007AFF",
+  dark: "#0A84FF",
+  name: "systemBlue"
+}));
+h(f.init({
+  default: "#34C759",
+  light: "#34C759",
+  dark: "#30D158",
+  name: "systemGreen"
+}));
+h(f.init({
+  default: "#FF3B30",
+  light: "#FF3B30",
+  dark: "#FF453A",
+  name: "systemRed"
+}));
+h(f.init({
+  default: "#FF9500",
+  light: "#FF9500",
+  dark: "#FF9F0A",
+  name: "systemOrange"
+}));
+h(f.init({
+  default: "#5856D6",
+  light: "#5856D6",
+  dark: "#5E5CE6",
+  name: "systemPurple"
+}));
+h(f.init({
+  default: "#FF2D55",
+  light: "#FF2D55",
+  dark: "#FF375F",
+  name: "systemPink"
+}));
+h(f.init({
+  default: "#8E8E93",
+  name: "systemGray"
+}));
+h(f.init({
+  default: "#000000",
+  name: "systemBlack"
+}));
+h(f.init({
+  default: "#FFFFFF",
+  name: "systemWhite"
+}));
+const m = {
+  // iOS-style colors
+  ios: {
+    blue: ["#007AFF", "#0051D2"],
+    green: ["#30D158", "#248A3D"],
+    red: ["#FF3B30", "#CC2E26"]
+  },
+  // Material Design colors
+  material: {
+    blue: ["#2196F3", "#1976D2"]
+  },
+  // Modern web gradients
+  modern: {
+    ocean: ["#667eea", "#764ba2"],
+    sunset: ["#ff7e5f", "#feb47b"],
+    aurora: ["#4facfe", "#00f2fe"]
+  },
+  // Neutral gradients
+  neutral: {
+    lightGray: ["#f8f9fa", "#e9ecef"],
+    darkGray: ["#495057", "#212529"]
+  }
+}, V = {
+  // Direction-based presets
+  vertical: (t) => a({
+    colors: t,
+    startPoint: "top",
+    endPoint: "bottom"
+  }),
+  horizontal: (t) => a({
+    colors: t,
+    startPoint: "leading",
+    endPoint: "trailing"
+  }),
+  diagonal: (t) => a({
+    colors: t,
+    startPoint: "topLeading",
+    endPoint: "bottomTrailing"
+  }),
+  diagonalReverse: (t) => a({
+    colors: t,
+    startPoint: "topTrailing",
+    endPoint: "bottomLeading"
+  }),
+  // Popular gradient patterns
+  iosBlue: () => a({
+    colors: [...m.ios.blue],
+    startPoint: "top",
+    endPoint: "bottom"
+  }),
+  materialBlue: () => a({
+    colors: [...m.material.blue],
+    startPoint: "top",
+    endPoint: "bottom"
+  }),
+  ocean: () => a({
+    colors: [...m.modern.ocean],
+    startPoint: "topLeading",
+    endPoint: "bottomTrailing"
+  }),
+  sunset: () => a({
+    colors: [...m.modern.sunset],
+    startPoint: "leading",
+    endPoint: "trailing"
+  }),
+  aurora: () => a({
+    colors: [...m.modern.aurora],
+    startPoint: "top",
+    endPoint: "bottom"
+  }),
+  // Multi-color gradients
+  rainbow: () => a({
+    colors: ["#ff0000", "#ff7f00", "#ffff00", "#00ff00", "#0000ff", "#8f00ff"],
+    startPoint: "leading",
+    endPoint: "trailing",
+    stops: [0, 16.66, 33.33, 50, 66.66, 83.33, 100]
+  }),
+  prism: () => a({
+    colors: ["#ff6b6b", "#4ecdc4", "#45b7d1", "#96ceb4", "#feca57"],
+    startPoint: "topLeading",
+    endPoint: "bottomTrailing"
+  }),
+  // Card and surface gradients
+  cardLight: () => a({
+    colors: [...m.neutral.lightGray],
+    startPoint: "top",
+    endPoint: "bottom"
+  }),
+  cardDark: () => a({
+    colors: [...m.neutral.darkGray],
+    startPoint: "top",
+    endPoint: "bottom"
+  }),
+  glass: () => a({
+    colors: ["rgba(255, 255, 255, 0.25)", "rgba(255, 255, 255, 0.05)"],
+    startPoint: "top",
+    endPoint: "bottom"
+  }),
+  frosted: () => a({
+    colors: ["rgba(255, 255, 255, 0.1)", "rgba(255, 255, 255, 0.3)"],
+    startPoint: "topLeading",
+    endPoint: "bottomTrailing"
+  })
+}, R = {
+  primaryButton: () => ({
+    default: V.iosBlue(),
+    hover: a({
+      colors: ["#1A8FFF", "#0062E3"],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    active: a({
+      colors: ["#0066CC", "#004499"],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    disabled: "#CCCCCC",
+    animation: {
+      duration: 150,
+      easing: "ease-out"
+    }
+  }),
+  secondaryButton: () => ({
+    default: V.cardLight(),
+    hover: a({
+      colors: ["#e9ecef", "#dee2e6"],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    active: a({
+      colors: ["#dee2e6", "#ced4da"],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    animation: {
+      duration: 100,
+      easing: "ease-out"
+    }
+  }),
+  dangerButton: () => ({
+    default: a({
+      colors: [...m.ios.red],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    hover: a({
+      colors: ["#FF5A52", "#D13029"],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    active: a({
+      colors: ["#E6342C", "#B32821"],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    disabled: "#CCCCCC",
+    animation: {
+      duration: 120,
+      easing: "ease-out"
+    }
+  }),
+  successButton: () => ({
+    default: a({
+      colors: [...m.ios.green],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    hover: a({
+      colors: ["#40D866", "#2C8F45"],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    active: a({
+      colors: ["#28B946", "#1F7A35"],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    disabled: "#CCCCCC",
+    animation: {
+      duration: 120,
+      easing: "ease-out"
+    }
+  }),
+  hoverCard: () => ({
+    default: "#FFFFFF",
+    hover: V.glass(),
+    animation: {
+      duration: 200,
+      easing: "ease"
+    }
+  }),
+  focusInput: () => ({
+    default: "#FFFFFF",
+    focus: a({
+      colors: ["#F0F8FF", "#E6F3FF"],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    disabled: "#F5F5F5",
+    animation: {
+      duration: 100,
+      easing: "ease-in-out"
+    }
+  })
+}, Ot = {
+  /**
+   * Create a theme-responsive gradient that switches between light and dark variants
+   */
+  createThemeGradient: (t, e) => t,
+  /**
+   * Auto-generate dark mode variant of a gradient
+   */
+  createDarkVariant: (t) => t
+}, Ht = {
+  /**
+   * Reverse the colors in a gradient
+   */
+  reverse: (t) => {
+    const e = { ...t };
+    return "colors" in e.options && (e.options = {
+      ...e.options,
+      colors: [...e.options.colors].reverse()
+    }), e;
+  },
+  /**
+   * Rotate a linear gradient by swapping start and end points
+   */
+  rotate: (t) => ({
+    ...t,
+    startPoint: t.endPoint,
+    endPoint: t.startPoint
+  }),
+  /**
+   * Add transparency to gradient colors
+   */
+  withOpacity: (t, e) => t,
+  /**
+   * Blend two gradients together
+   */
+  blend: (t, e, n = 0.5) => t
+};
+({
+  ...V,
+  ...R
+});
+const v = {
+  /**
+   * Check if value is a valid gradient definition
+   */
+  isGradientDefinition(t) {
+    if (!t || typeof t != "object") return !1;
+    const e = t;
+    return typeof e.type == "string" && ["linear", "radial", "angular", "conic", "repeating-linear", "repeating-radial", "elliptical"].includes(e.type) && e.options !== void 0 && typeof e.options == "object" && e.options !== null;
+  },
+  /**
+   * Check if value is a linear gradient
+   */
+  isLinearGradient(t) {
+    return this.isGradientDefinition(t) && t.type === "linear";
+  },
+  /**
+   * Check if value is a radial gradient
+   */
+  isRadialGradient(t) {
+    return this.isGradientDefinition(t) && t.type === "radial";
+  },
+  /**
+   * Check if value is an angular gradient
+   */
+  isAngularGradient(t) {
+    return this.isGradientDefinition(t) && t.type === "angular";
+  },
+  /**
+   * Check if value is a state gradient configuration
+   */
+  isStateGradientOptions(t) {
+    if (!t || typeof t != "object") return !1;
+    const e = t;
+    return "default" in e && e.default !== void 0;
+  },
+  /**
+   * Check if value is a stateful background value
+   */
+  isStatefulBackgroundValue(t) {
+    return !!(typeof t == "string" || this.isGradientDefinition(t) || this.isAsset(t) || this.isStateGradientOptions(t));
+  },
+  /**
+   * Check if value is an Asset
+   */
+  isAsset(t) {
+    return t !== null && typeof t == "object" && "resolve" in t && typeof t.resolve == "function";
+  },
+  /**
+   * Check if value is a valid gradient start point
+   */
+  isGradientStartPoint(t) {
+    return typeof t == "string" && [
+      "top",
+      "bottom",
+      "leading",
+      "trailing",
+      "center",
+      "topLeading",
+      "topTrailing",
+      "bottomLeading",
+      "bottomTrailing"
+    ].includes(t);
+  },
+  /**
+   * Check if value is a valid gradient center
+   */
+  isGradientCenter(t) {
+    return typeof t == "string" ? ["center", "top", "bottom", "leading", "trailing"].includes(t) : Array.isArray(t) ? t.length === 2 && typeof t[0] == "number" && typeof t[1] == "number" : !1;
+  }
+}, M = {
+  /**
+   * Validate color format (hex, rgb, rgba, hsl, hsla, named colors, CSS custom properties)
+   */
+  validateColor(t) {
+    return v.isAsset(t) ? { valid: !0 } : typeof t != "string" ? { valid: !1, error: "Color must be a string or Asset" } : /^(transparent|inherit|initial|unset|currentcolor)$/i.test(t) ? { valid: !0 } : /^#([0-9a-f]{3}|[0-9a-f]{4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(t) ? { valid: !0 } : /^rgba?\(\s*(\d+(?:\.\d+)?%?)\s*,\s*(\d+(?:\.\d+)?%?)\s*,\s*(\d+(?:\.\d+)?%?)\s*(?:,\s*(\d+(?:\.\d+)?%?))?\s*\)$/i.test(t) ? { valid: !0 } : /^hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?%)\s*,\s*(\d+(?:\.\d+)?%)\s*(?:,\s*(\d+(?:\.\d+)?%?))?\s*\)$/i.test(t) ? { valid: !0 } : /^var\(--[a-zA-Z][a-zA-Z0-9-]*\)$/.test(t) ? { valid: !0 } : { valid: !1, error: `Invalid color format: ${t}` };
+  },
+  /**
+   * Validate gradient colors array
+   */
+  validateColors(t) {
+    const e = [];
+    return Array.isArray(t) ? t.length < 2 ? { valid: !1, errors: ["Gradient must have at least 2 colors"] } : (t.forEach((n, o) => {
+      const r = this.validateColor(n);
+      r.valid || e.push(`Color at index ${o}: ${r.error}`);
+    }), { valid: e.length === 0, errors: e }) : { valid: !1, errors: ["Colors must be an array"] };
+  },
+  /**
+   * Validate color stops array
+   */
+  validateStops(t, e) {
+    if (!Array.isArray(t))
+      return { valid: !1, error: "Stops must be an array" };
+    if (t.length !== e)
+      return { valid: !1, error: "Stops array length must match colors array length" };
+    for (let n = 0; n < t.length; n++) {
+      const o = t[n];
+      if (typeof o != "number")
+        return { valid: !1, error: `Stop at index ${n} must be a number` };
+      if (o < 0 || o > 100)
+        return { valid: !1, error: `Stop at index ${n} must be between 0 and 100` };
+      if (n > 0 && o < t[n - 1])
+        return { valid: !1, error: `Stops must be in ascending order. Stop at index ${n} (${o}) is less than previous stop (${t[n - 1]})` };
+    }
+    return { valid: !0 };
+  },
+  /**
+   * Validate linear gradient options
+   */
+  validateLinearGradient(t) {
+    const e = [], n = this.validateColors(t.colors);
+    if (n.valid || e.push(...n.errors), t.stops) {
+      const o = this.validateStops(t.stops, t.colors.length);
+      o.valid || e.push(o.error);
+    }
+    return v.isGradientStartPoint(t.startPoint) || e.push(`Invalid startPoint: ${t.startPoint}`), v.isGradientStartPoint(t.endPoint) || e.push(`Invalid endPoint: ${t.endPoint}`), t.angle !== void 0 && (typeof t.angle != "number" ? e.push("Angle must be a number") : (t.angle < 0 || t.angle > 360) && e.push("Angle must be between 0 and 360 degrees")), { valid: e.length === 0, errors: e };
+  },
+  /**
+   * Validate radial gradient options
+   */
+  validateRadialGradient(t) {
+    const e = [], n = this.validateColors(t.colors);
+    if (n.valid || e.push(...n.errors), t.stops) {
+      const o = this.validateStops(t.stops, t.colors.length);
+      o.valid || e.push(o.error);
+    }
+    return v.isGradientCenter(t.center) || e.push(`Invalid center: ${t.center}`), (typeof t.startRadius != "number" || t.startRadius < 0) && e.push("startRadius must be a non-negative number"), (typeof t.endRadius != "number" || t.endRadius < 0) && e.push("endRadius must be a non-negative number"), t.startRadius >= t.endRadius && e.push("endRadius must be greater than startRadius"), t.shape && !["circle", "ellipse"].includes(t.shape) && e.push(`Invalid shape: ${t.shape}. Must be 'circle' or 'ellipse'`), { valid: e.length === 0, errors: e };
+  },
+  /**
+   * Validate angular gradient options
+   */
+  validateAngularGradient(t) {
+    const e = [], n = this.validateColors(t.colors);
+    return n.valid || e.push(...n.errors), v.isGradientCenter(t.center) || e.push(`Invalid center: ${t.center}`), typeof t.startAngle != "number" && e.push("startAngle must be a number"), typeof t.endAngle != "number" && e.push("endAngle must be a number"), { valid: e.length === 0, errors: e };
+  },
+  /**
+   * Validate animation options
+   */
+  validateAnimationOptions(t) {
+    const e = [];
+    return t.duration !== void 0 && (typeof t.duration != "number" || t.duration < 0) && e.push("Duration must be a non-negative number"), t.delay !== void 0 && (typeof t.delay != "number" || t.delay < 0) && e.push("Delay must be a non-negative number"), t.easing !== void 0 && typeof t.easing != "string" && e.push("Easing must be a string"), { valid: e.length === 0, errors: e };
+  },
+  /**
+   * Validate state gradient options
+   */
+  validateStateGradientOptions(t) {
+    const e = [];
+    if (t.default || e.push("Default state is required"), ["default", "hover", "active", "focus", "disabled"].forEach((o) => {
+      const r = t[o];
+      r && !v.isStatefulBackgroundValue(r) && e.push(`Invalid ${o} state value`);
+    }), t.animation) {
+      const o = this.validateAnimationOptions(t.animation);
+      o.valid || e.push(...o.errors.map((r) => `Animation: ${r}`));
+    }
+    return { valid: e.length === 0, errors: e };
+  },
+  /**
+   * Comprehensive gradient validation
+   */
+  validateGradient(t) {
+    if (!v.isGradientDefinition(t))
+      return { valid: !1, errors: ["Invalid gradient definition structure"] };
+    switch (t.type) {
+      case "linear":
+        return this.validateLinearGradient(t.options);
+      case "radial":
+        return this.validateRadialGradient(t.options);
+      case "angular":
+      case "conic":
+        return this.validateAngularGradient(t.options);
+      default:
+        return { valid: !1, errors: [`Unsupported gradient type: ${t.type}`] };
+    }
+  }
+}, jt = (t) => {
+  const e = M.validateGradient(t);
+  if (!e.valid)
+    throw new Error(`Invalid gradient: ${e.errors.join(", ")}`);
+  return t;
+}, Ut = (t) => {
+  const e = M.validateStateGradientOptions(t);
+  if (!e.valid)
+    throw new Error(`Invalid state gradient: ${e.errors.join(", ")}`);
+  return t;
+}, Wt = {
+  /**
+   * Assert gradient is valid (throws in development, no-op in production)
+   */
+  assertValidGradient(t) {
+    if (process.env.NODE_ENV === "development") {
+      const e = M.validateGradient(t);
+      if (!e.valid)
+        throw console.error("Invalid gradient:", t), console.error("Validation errors:", e.errors), new Error(`Invalid gradient: ${e.errors.join(", ")}`);
+    }
+  },
+  /**
+   * Warn about potential gradient issues
+   */
+  warnGradientIssues(t) {
+    process.env.NODE_ENV === "development" && "colors" in t.options && t.options.colors.length > 5 && console.warn("Gradient has many colors which may impact performance:", t);
+  }
+}, c = {
+  /**
+   * Parse hex color to RGB components
+   */
+  hexToRgb: (t) => {
+    const e = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(t);
+    return e ? {
+      r: parseInt(e[1], 16),
+      g: parseInt(e[2], 16),
+      b: parseInt(e[3], 16)
+    } : null;
+  },
+  /**
+   * Convert RGB to hex
+   */
+  rgbToHex: (t, e, n) => "#" + ((1 << 24) + (t << 16) + (e << 8) + n).toString(16).slice(1),
+  /**
+   * Add transparency to a color
+   */
+  withAlpha: (t, e) => {
+    if (t.startsWith("#")) {
+      const n = c.hexToRgb(t);
+      if (n)
+        return `rgba(${n.r}, ${n.g}, ${n.b}, ${e})`;
+    }
+    return t.startsWith("rgb(") ? t.replace("rgb(", "rgba(").replace(")", `, ${e})`) : t.startsWith("rgba(") ? t.replace(/,\s*[\d.]+\)$/, `, ${e})`) : t;
+  },
+  /**
+   * Blend two colors
+   */
+  blendColors: (t, e, n = 0.5) => {
+    const o = c.hexToRgb(t), r = c.hexToRgb(e);
+    if (!o || !r) return t;
+    const i = Math.round(o.r * (1 - n) + r.r * n), s = Math.round(o.g * (1 - n) + r.g * n), l = Math.round(o.b * (1 - n) + r.b * n);
+    return c.rgbToHex(i, s, l);
+  },
+  /**
+   * Generate color variations (lighter/darker)
+   */
+  lighten: (t, e = 0.2) => c.blendColors(t, "#ffffff", e),
+  darken: (t, e = 0.2) => c.blendColors(t, "#000000", e),
+  /**
+   * Generate complementary color
+   */
+  complement: (t) => {
+    const e = c.hexToRgb(t);
+    return e ? c.rgbToHex(255 - e.r, 255 - e.g, 255 - e.b) : t;
+  },
+  /**
+   * Get contrast ratio between two colors
+   */
+  getContrastRatio: (t, e) => {
+    const n = (l) => {
+      const d = c.hexToRgb(l);
+      if (!d) return 0;
+      const [p, H, Z] = [d.r, d.g, d.b].map((F) => (F = F / 255, F <= 0.03928 ? F / 12.92 : Math.pow((F + 0.055) / 1.055, 2.4)));
+      return 0.2126 * p + 0.7152 * H + 0.0722 * Z;
+    }, o = n(t), r = n(e), i = Math.max(o, r), s = Math.min(o, r);
+    return (i + 0.05) / (s + 0.05);
+  }
+}, N = {
+  /**
+   * Reverse gradient colors
+   */
+  reverse: (t) => {
+    const e = { ...t };
+    return "colors" in e.options && (e.options = {
+      ...e.options,
+      colors: [...e.options.colors].reverse(),
+      stops: e.options.stops ? [...e.options.stops].reverse() : void 0
+    }), e;
+  },
+  /**
+   * Rotate linear gradient direction
+   */
+  rotateLinear: (t, e) => {
+    if (t.type !== "linear") return t;
+    const n = t.options;
+    return {
+      ...t,
+      options: {
+        ...n,
+        angle: (n.angle || 0) + e
+      }
+    };
+  },
+  /**
+   * Scale radial gradient
+   */
+  scaleRadial: (t, e) => {
+    if (t.type !== "radial") return t;
+    const n = t.options;
+    return {
+      ...t,
+      options: {
+        ...n,
+        startRadius: n.startRadius * e,
+        endRadius: n.endRadius * e
+      }
+    };
+  },
+  /**
+   * Add transparency to entire gradient
+   */
+  withOpacity: (t, e) => {
+    const n = { ...t };
+    return "colors" in n.options && (n.options = {
+      ...n.options,
+      colors: n.options.colors.map(
+        (o) => typeof o == "string" ? c.withAlpha(o, e) : o
+      )
+    }), n;
+  },
+  /**
+   * Mirror a linear gradient (swap start and end points)
+   */
+  mirror: (t) => {
+    if (t.type !== "linear") return t;
+    const e = t.options;
+    return {
+      ...t,
+      options: {
+        ...e,
+        startPoint: e.endPoint,
+        endPoint: e.startPoint
+      }
+    };
+  },
+  /**
+   * Convert linear gradient to radial
+   */
+  toRadial: (t, e = 100) => {
+    if (t.type !== "linear") return t;
+    const n = t.options;
+    return _({
+      colors: n.colors,
+      stops: n.stops,
+      center: "center",
+      startRadius: 0,
+      endRadius: e
+    });
+  },
+  /**
+   * Convert to angular/conic gradient
+   */
+  toAngular: (t) => "colors" in t.options ? K({
+    colors: t.options.colors,
+    stops: t.options.stops,
+    center: "center",
+    startAngle: 0,
+    endAngle: 360
+  }) : t
+}, g = {
+  /**
+   * Get gradient color count
+   */
+  getColorCount: (t) => "colors" in t.options ? t.options.colors.length : 0,
+  /**
+   * Extract colors from gradient
+   */
+  extractColors: (t) => "colors" in t.options ? [...t.options.colors] : [],
+  /**
+   * Get gradient complexity score (for performance optimization)
+   */
+  getComplexityScore: (t) => {
+    let e = 0;
+    switch ("colors" in t.options && (e += t.options.colors.length * 2, e += t.options.stops ? t.options.stops.length : 0), t.type) {
+      case "linear":
+        e += 1;
+        break;
+      case "radial":
+        e += 3;
+        break;
+      case "angular":
+        e += 4;
+        break;
+      case "repeating-linear":
+        e += 5;
+        break;
+      case "repeating-radial":
+        e += 6;
+        break;
+    }
+    return e;
+  },
+  /**
+   * Check if gradient has transparency
+   */
+  hasTransparency: (t) => "colors" in t.options ? t.options.colors.some(
+    (e) => typeof e == "string" && (e.includes("rgba") || e.includes("transparent") || e.includes("hsla"))
+  ) : !1,
+  /**
+   * Estimate rendering performance impact
+   */
+  getPerformanceImpact: (t) => {
+    const e = g.getComplexityScore(t);
+    return e <= 5 ? "low" : e <= 10 ? "medium" : "high";
+  }
+}, st = {
+  /**
+   * Generate rainbow gradient
+   */
+  rainbow: (t = 6) => {
+    const e = [];
+    for (let n = 0; n < t; n++) {
+      const o = n * 360 / t;
+      e.push(`hsl(${o}, 100%, 50%)`);
+    }
+    return a({
+      colors: e,
+      startPoint: "leading",
+      endPoint: "trailing"
+    });
+  },
+  /**
+   * Generate monochromatic gradient
+   */
+  monochromatic: (t, e = 5) => {
+    const n = [];
+    for (let o = 0; o < e; o++) {
+      const r = o / (e - 1);
+      r < 0.5 ? n.push(c.lighten(t, 0.4 - r * 0.8)) : n.push(c.darken(t, (r - 0.5) * 0.8));
+    }
+    return a({
+      colors: n,
+      startPoint: "top",
+      endPoint: "bottom"
+    });
+  },
+  /**
+   * Generate analogous color gradient
+   */
+  analogous: (t, e = 60) => a({
+    colors: [t, c.lighten(t, 0.2), c.darken(t, 0.2)],
+    startPoint: "topLeading",
+    endPoint: "bottomTrailing"
+  }),
+  /**
+   * Generate complementary gradient
+   */
+  complementary: (t, e) => {
+    const n = e || c.complement(t);
+    return a({
+      colors: [t, n],
+      startPoint: "topLeading",
+      endPoint: "bottomTrailing"
+    });
+  },
+  /**
+   * Generate sunset gradient
+   */
+  sunset: () => a({
+    colors: ["#ff7e5f", "#feb47b", "#ff6b6b", "#c44569"],
+    startPoint: "top",
+    endPoint: "bottom"
+  }),
+  /**
+   * Generate ocean gradient
+   */
+  ocean: () => a({
+    colors: ["#667eea", "#764ba2", "#667eea"],
+    startPoint: "topLeading",
+    endPoint: "bottomTrailing"
+  })
+}, ct = {
+  /**
+   * Create hover effect gradient
+   */
+  createHoverEffect: (t, e = 0.1) => {
+    const n = N.withOpacity(
+      N.reverse(t),
+      1 - e
+    );
+    return {
+      default: t,
+      hover: n,
+      animation: {
+        duration: 200,
+        easing: "ease-out"
+      }
+    };
+  },
+  /**
+   * Create button gradient states
+   */
+  createButtonStates: (t, e = "primary") => {
+    const o = {
+      primary: { base: t, hover: c.lighten(t, 0.1), active: c.darken(t, 0.1) },
+      secondary: { base: "#f8f9fa", hover: "#e9ecef", active: "#dee2e6" },
+      danger: { base: "#dc3545", hover: c.lighten("#dc3545", 0.1), active: c.darken("#dc3545", 0.1) }
+    }[e];
+    return {
+      default: a({
+        colors: [o.base, c.darken(o.base, 0.05)],
+        startPoint: "top",
+        endPoint: "bottom"
+      }),
+      hover: a({
+        colors: [o.hover, c.darken(o.hover, 0.05)],
+        startPoint: "top",
+        endPoint: "bottom"
+      }),
+      active: a({
+        colors: [o.active, c.darken(o.active, 0.05)],
+        startPoint: "top",
+        endPoint: "bottom"
+      }),
+      disabled: "#cccccc",
+      animation: {
+        duration: 150,
+        easing: "ease-out"
+      }
+    };
+  },
+  /**
+   * Create card hover effect
+   */
+  createCardHover: (t = "#ffffff") => ({
+    default: t,
+    hover: a({
+      colors: [
+        c.withAlpha("#ffffff", 0.1),
+        c.withAlpha("#f8f9fa", 0.1)
+      ],
+      startPoint: "topLeading",
+      endPoint: "bottomTrailing"
+    }),
+    animation: {
+      duration: 200,
+      easing: "ease"
+    }
+  })
+}, lt = {
+  /**
+   * Generate CSS custom properties for gradient
+   */
+  toCustomProperties: (t, e = "gradient") => {
+    const n = I(t);
+    return {
+      [`--${e}-background`]: n
+    };
+  },
+  /**
+   * Generate fallback CSS for older browsers
+   */
+  withFallback: (t, e) => {
+    const n = I(t);
+    return `background: ${e}; background: ${n};`;
+  },
+  /**
+   * Optimize CSS for performance
+   */
+  optimize: (t) => t.replace(/\s+/g, " ").replace(/,\s+/g, ",").replace(/:\s+/g, ":").trim()
+}, u = {
+  ...c,
+  ...N,
+  ...g,
+  ...st,
+  ...ct,
+  ...lt,
+  /**
+   * Convert any background value to CSS
+   */
+  toCSS: (t) => typeof t == "string" ? t : "resolve" in t && typeof t.resolve == "function" ? t.resolve() : "type" in t && "options" in t ? I(t) : "default" in t ? u.toCSS(t.default) : "transparent",
+  /**
+   * Deep clone gradient definition
+   */
+  clone: (t) => JSON.parse(JSON.stringify(t)),
+  /**
+   * Compare two gradients for equality
+   */
+  equals: (t, e) => JSON.stringify(t) === JSON.stringify(e)
+}, G = {
+  /**
+   * iOS-style primary button
+   */
+  iosPrimary: () => ({
+    default: a({
+      colors: ["#007AFF", "#0051D2"],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    hover: a({
+      colors: ["#1A8FFF", "#0062E3"],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    active: a({
+      colors: ["#0066CC", "#004499"],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    disabled: "#CCCCCC",
+    animation: { duration: 150, easing: "ease-out" }
+  }),
+  /**
+   * Material Design raised button
+   */
+  materialRaised: () => ({
+    default: a({
+      colors: ["#2196F3", "#1976D2"],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    hover: a({
+      colors: ["#42A5F5", "#1E88E5"],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    active: a({
+      colors: ["#1565C0", "#0D47A1"],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    animation: { duration: 200, easing: "cubic-bezier(0.4, 0, 0.2, 1)" }
+  }),
+  /**
+   * Glass morphism button
+   */
+  glassMorphism: () => ({
+    default: a({
+      colors: ["rgba(255, 255, 255, 0.25)", "rgba(255, 255, 255, 0.05)"],
+      startPoint: "topLeading",
+      endPoint: "bottomTrailing"
+    }),
+    hover: a({
+      colors: ["rgba(255, 255, 255, 0.35)", "rgba(255, 255, 255, 0.15)"],
+      startPoint: "topLeading",
+      endPoint: "bottomTrailing"
+    }),
+    active: a({
+      colors: ["rgba(255, 255, 255, 0.15)", "rgba(255, 255, 255, 0.25)"],
+      startPoint: "topLeading",
+      endPoint: "bottomTrailing"
+    }),
+    animation: { duration: 250, easing: "ease" }
+  }),
+  /**
+   * Neon glow button
+   */
+  neonGlow: (t = "#00ff88") => ({
+    default: a({
+      colors: [t, u.darken(t, 0.3)],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    hover: _({
+      colors: [u.lighten(t, 0.2), t, u.darken(t, 0.4)],
+      center: "center",
+      startRadius: 0,
+      endRadius: 60
+    }),
+    active: a({
+      colors: [u.darken(t, 0.2), u.darken(t, 0.4)],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    animation: { duration: 300, easing: "ease-in-out" }
+  }),
+  /**
+   * Gradient call-to-action button
+   */
+  ctaButton: () => ({
+    default: a({
+      colors: ["#ff416c", "#ff4b2b"],
+      startPoint: "topLeading",
+      endPoint: "bottomTrailing"
+    }),
+    hover: a({
+      colors: ["#ff6b9d", "#ff6347"],
+      startPoint: "topLeading",
+      endPoint: "bottomTrailing"
+    }),
+    active: a({
+      colors: ["#e63946", "#d62828"],
+      startPoint: "topLeading",
+      endPoint: "bottomTrailing"
+    }),
+    animation: { duration: 175, easing: "ease-out" }
+  })
+}, C = {
+  /**
+   * Subtle card hover effect
+   */
+  subtleHover: () => ({
+    default: "#ffffff",
+    hover: a({
+      colors: ["#f8f9fa", "#ffffff"],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    animation: { duration: 200, easing: "ease" }
+  }),
+  /**
+   * Dark mode card
+   */
+  darkCard: () => ({
+    default: a({
+      colors: ["#2d3748", "#1a202c"],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    hover: a({
+      colors: ["#4a5568", "#2d3748"],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    animation: { duration: 250, easing: "ease-in-out" }
+  }),
+  /**
+   * Hero card with rich gradient
+   */
+  heroCard: () => a({
+    colors: [
+      "#667eea",
+      "#764ba2",
+      "rgba(118, 75, 162, 0.8)"
+    ],
+    startPoint: "topLeading",
+    endPoint: "bottomTrailing"
+  }),
+  /**
+   * Pricing card with accent
+   */
+  pricingCard: (t = "#007AFF") => a({
+    colors: [
+      "#ffffff",
+      "#f8f9fa",
+      u.withAlpha(t, 0.05)
+    ],
+    startPoint: "top",
+    endPoint: "bottom"
+  }),
+  /**
+   * Testimonial card
+   */
+  testimonialCard: () => a({
+    colors: [
+      "rgba(255, 255, 255, 0.9)",
+      "rgba(248, 249, 250, 0.9)",
+      "rgba(233, 236, 239, 0.9)"
+    ],
+    startPoint: "topLeading",
+    endPoint: "bottomTrailing"
+  })
+}, dt = {
+  /**
+   * App header gradient
+   */
+  appHeader: () => a({
+    colors: ["#667eea", "#764ba2"],
+    startPoint: "leading",
+    endPoint: "trailing"
+  }),
+  /**
+   * Tab bar gradient
+   */
+  tabBar: () => ({
+    default: a({
+      colors: ["#f8f9fa", "#e9ecef"],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    hover: a({
+      colors: ["#e9ecef", "#dee2e6"],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    animation: { duration: 150, easing: "ease-out" }
+  }),
+  /**
+   * Sidebar gradient
+   */
+  sidebar: () => a({
+    colors: [
+      "#2d3748",
+      "#1a202c",
+      "#171923"
+    ],
+    startPoint: "top",
+    endPoint: "bottom"
+  }),
+  /**
+   * Navigation breadcrumb
+   */
+  breadcrumb: () => ({
+    default: "transparent",
+    hover: a({
+      colors: ["rgba(0, 122, 255, 0.1)", "rgba(0, 122, 255, 0.05)"],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    animation: { duration: 100, easing: "ease-out" }
+  })
+}, x = {
+  /**
+   * Text input focus effect
+   */
+  textInputFocus: () => ({
+    default: "#ffffff",
+    focus: a({
+      colors: ["#f0f8ff", "#e6f3ff"],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    disabled: "#f5f5f5",
+    animation: { duration: 100, easing: "ease-in-out" }
+  }),
+  /**
+   * Form section background
+   */
+  formSection: () => a({
+    colors: [
+      "rgba(248, 249, 250, 0.8)",
+      "rgba(255, 255, 255, 0.8)",
+      "rgba(248, 249, 250, 0.8)"
+    ],
+    startPoint: "top",
+    endPoint: "bottom"
+  }),
+  /**
+   * Submit button gradient
+   */
+  submitButton: () => ({
+    default: a({
+      colors: ["#30d158", "#248a3d"],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    hover: a({
+      colors: ["#40d866", "#2c8f45"],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    active: a({
+      colors: ["#28b946", "#1f7a35"],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    animation: { duration: 120, easing: "ease-out" }
+  }),
+  /**
+   * Error state input
+   */
+  errorInput: () => ({
+    default: a({
+      colors: ["rgba(255, 59, 48, 0.1)", "rgba(255, 59, 48, 0.05)"],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    focus: a({
+      colors: ["rgba(255, 59, 48, 0.15)", "rgba(255, 59, 48, 0.08)"],
+      startPoint: "top",
+      endPoint: "bottom"
+    }),
+    animation: { duration: 150, easing: "ease-in-out" }
+  })
+}, ut = {
+  /**
+   * Metric card with positive trend
+   */
+  positiveMetric: () => a({
+    colors: ["#d4edda", "#c3e6cb", "#b8dacc"],
+    startPoint: "topLeading",
+    endPoint: "bottomTrailing"
+  }),
+  /**
+   * Metric card with negative trend
+   */
+  negativeMetric: () => a({
+    colors: ["#f8d7da", "#f5c6cb", "#f1b0b7"],
+    startPoint: "topLeading",
+    endPoint: "bottomTrailing"
+  }),
+  /**
+   * Chart background
+   */
+  chartBackground: () => a({
+    colors: [
+      "rgba(255, 255, 255, 0.95)",
+      "rgba(248, 249, 250, 0.95)",
+      "rgba(255, 255, 255, 0.95)"
+    ],
+    startPoint: "top",
+    endPoint: "bottom"
+  }),
+  /**
+   * Progress bar gradient
+   */
+  progressBar: (t = "#007AFF") => a({
+    colors: [
+      u.lighten(t, 0.1),
+      t,
+      u.darken(t, 0.1)
+    ],
+    startPoint: "top",
+    endPoint: "bottom"
+  }),
+  /**
+   * Status indicator gradients
+   */
+  statusSuccess: () => _({
+    colors: ["#30d158", "#248a3d", "rgba(36, 138, 61, 0.8)"],
+    center: "center",
+    startRadius: 0,
+    endRadius: 25
+  }),
+  statusWarning: () => _({
+    colors: ["#ff9500", "#cc7700", "rgba(204, 119, 0, 0.8)"],
+    center: "center",
+    startRadius: 0,
+    endRadius: 25
+  }),
+  statusError: () => _({
+    colors: ["#ff3b30", "#cc2e26", "rgba(204, 46, 38, 0.8)"],
+    center: "center",
+    startRadius: 0,
+    endRadius: 25
+  })
+}, ft = {
+  /**
+   * Shimmer loading effect
+   */
+  shimmer: () => a({
+    colors: [
+      "rgba(255, 255, 255, 0)",
+      "rgba(255, 255, 255, 0.4)",
+      "rgba(255, 255, 255, 0.8)",
+      "rgba(255, 255, 255, 0.4)",
+      "rgba(255, 255, 255, 0)"
+    ],
+    startPoint: "leading",
+    endPoint: "trailing",
+    stops: [0, 25, 50, 75, 100]
+  }),
+  /**
+   * Skeleton loading gradient
+   */
+  skeleton: () => a({
+    colors: ["#f6f7f8", "#edeef1", "#f6f7f8"],
+    startPoint: "leading",
+    endPoint: "trailing"
+  }),
+  /**
+   * Pulse animation gradient
+   */
+  pulse: (t = "#007AFF") => _({
+    colors: [
+      u.withAlpha(t, 0.8),
+      u.withAlpha(t, 0.4),
+      u.withAlpha(t, 0.1),
+      "transparent"
+    ],
+    center: "center",
+    startRadius: 0,
+    endRadius: 100
+  }),
+  /**
+   * Spinner gradient
+   */
+  spinner: () => K({
+    colors: [
+      "#007AFF",
+      "rgba(0, 122, 255, 0.8)",
+      "rgba(0, 122, 255, 0.4)",
+      "rgba(0, 122, 255, 0.1)",
+      "transparent",
+      "transparent",
+      "#007AFF"
+    ],
+    center: "center",
+    startAngle: 0,
+    endAngle: 360
+  })
+}, B = {
+  /**
+   * App background gradient
+   */
+  appBackground: () => a({
+    colors: [
+      "#f8f9fa",
+      "#ffffff",
+      "#f8f9fa"
+    ],
+    startPoint: "top",
+    endPoint: "bottom"
+  }),
+  /**
+   * Dark mode app background
+   */
+  darkAppBackground: () => a({
+    colors: [
+      "#1a1a1a",
+      "#0f0f0f",
+      "#1a1a1a"
+    ],
+    startPoint: "top",
+    endPoint: "bottom"
+  }),
+  /**
+   * Modal backdrop
+   */
+  modalBackdrop: () => _({
+    colors: [
+      "rgba(0, 0, 0, 0.4)",
+      "rgba(0, 0, 0, 0.6)",
+      "rgba(0, 0, 0, 0.8)"
+    ],
+    center: "center",
+    startRadius: 0,
+    endRadius: 300
+  }),
+  /**
+   * Hero section background
+   */
+  heroSection: () => a({
+    colors: [
+      "#667eea",
+      "#764ba2",
+      "#667eea"
+    ],
+    startPoint: "topLeading",
+    endPoint: "bottomTrailing"
+  }),
+  /**
+   * Footer gradient
+   */
+  footer: () => a({
+    colors: [
+      "#2d3748",
+      "#1a202c"
+    ],
+    startPoint: "top",
+    endPoint: "bottom"
+  })
+}, z = {
+  /**
+   * iOS theme gradients
+   */
+  ios: {
+    primary: G.iosPrimary,
+    secondary: () => R.secondaryButton(),
+    card: C.subtleHover,
+    input: x.textInputFocus,
+    background: B.appBackground
+  },
+  /**
+   * Material Design theme gradients
+   */
+  material: {
+    primary: G.materialRaised,
+    secondary: () => R.secondaryButton(),
+    card: C.subtleHover,
+    input: x.textInputFocus,
+    background: B.appBackground
+  },
+  /**
+   * Modern/Glass theme gradients
+   */
+  modern: {
+    primary: G.glassMorphism,
+    secondary: G.glassMorphism,
+    card: () => C.subtleHover(),
+    input: x.textInputFocus,
+    background: () => a({
+      colors: [
+        "rgba(255, 255, 255, 0.95)",
+        "rgba(248, 249, 250, 0.95)"
+      ],
+      startPoint: "top",
+      endPoint: "bottom"
+    })
+  }
+}, pt = (t = "ios") => {
+  const e = z[t];
+  return {
+    Button: {
+      primary: b("button-primary", e.primary()),
+      secondary: b("button-secondary", e.secondary()),
+      danger: b("button-danger", R.dangerButton()),
+      success: b("button-success", R.successButton())
+    },
+    Card: {
+      default: b("card-default", e.card()),
+      hero: b("card-hero", {
+        default: C.heroCard(),
+        hover: u.reverse(C.heroCard()),
+        animation: { duration: 300, easing: "ease-in-out" }
+      })
+    },
+    Input: {
+      default: b("input-default", e.input()),
+      error: b("input-error", x.errorInput())
+    },
+    Background: {
+      app: e.background(),
+      modal: B.modalBackdrop()
+    }
+  };
+}, qt = {
+  Button: G,
+  Card: C,
+  Navigation: dt,
+  Form: x,
+  Dashboard: ut,
+  Animation: ft,
+  Background: B,
+  Themed: z,
+  createComponentGradients: pt
+};
+var mt = Object.defineProperty, gt = (t, e, n) => e in t ? mt(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n, k = (t, e, n) => gt(t, typeof e != "symbol" ? e + "" : e, n);
+const J = class A {
+  constructor() {
+    k(this, "metrics", /* @__PURE__ */ new Map()), k(this, "enabled", process.env.NODE_ENV === "development"), k(this, "totalMetrics", {
+      totalGradients: 0,
+      totalResolutions: 0,
+      totalCacheHits: 0,
+      totalCacheMisses: 0,
+      averageComplexity: 0,
+      memoryPressure: 0
+    });
+  }
+  static getInstance() {
+    return A.instance || (A.instance = new A()), A.instance;
+  }
+  /**
+   * Enable or disable performance monitoring
+   */
+  setEnabled(e) {
+    this.enabled = e;
+  }
+  /**
+   * Track gradient creation
+   */
+  trackCreation(e, n) {
+    if (!this.enabled) return;
+    const o = performance.now(), r = g.getComplexityScore(n), s = {
+      creationTime: performance.now() - o,
+      resolutionTime: 0,
+      cssGenerationTime: 0,
+      memoryUsage: this.estimateMemoryUsage(n),
+      cacheHits: 0,
+      cacheMisses: 0,
+      complexityScore: r,
+      renderCount: 0
+    };
+    this.metrics.set(e, s), this.updateTotalMetrics();
+  }
+  /**
+   * Track gradient resolution (conversion to CSS)
+   */
+  trackResolution(e, n = !1) {
+    if (!this.enabled) return;
+    const o = performance.now(), r = this.metrics.get(e);
+    if (r) {
+      const i = performance.now();
+      r.resolutionTime += i - o, r.renderCount++, n ? (r.cacheHits++, this.totalMetrics.totalCacheHits++) : (r.cacheMisses++, this.totalMetrics.totalCacheMisses++), this.totalMetrics.totalResolutions++;
+    }
+  }
+  /**
+   * Track CSS generation time
+   */
+  trackCSSGeneration(e, n) {
+    if (!this.enabled) return;
+    const o = this.metrics.get(e);
+    o && (o.cssGenerationTime += n);
+  }
+  /**
+   * Get performance metrics for a specific gradient
+   */
+  getMetrics(e) {
+    return this.metrics.get(e);
+  }
+  /**
+   * Get overall performance summary
+   */
+  getSummary() {
+    const n = Array.from(this.metrics.entries()).sort((i, s) => {
+      const [, l] = i, [, d] = s, p = l.cacheHits / (l.cacheHits + l.cacheMisses + 1);
+      return d.cacheHits / (d.cacheHits + d.cacheMisses + 1) - p;
+    }), o = n.slice(0, 5).map(([i, s]) => ({ id: i, metrics: s })), r = n.slice(-5).map(([i, s]) => ({ id: i, metrics: s }));
+    return {
+      totalMetrics: this.totalMetrics,
+      topPerformers: o,
+      poorPerformers: r,
+      recommendations: this.generateRecommendations()
+    };
+  }
+  /**
+   * Reset all metrics
+   */
+  reset() {
+    this.metrics.clear(), this.totalMetrics = {
+      totalGradients: 0,
+      totalResolutions: 0,
+      totalCacheHits: 0,
+      totalCacheMisses: 0,
+      averageComplexity: 0,
+      memoryPressure: 0
+    };
+  }
+  /**
+   * Export metrics to JSON for analysis
+   */
+  exportMetrics() {
+    return JSON.stringify({
+      totalMetrics: this.totalMetrics,
+      gradientMetrics: Object.fromEntries(this.metrics),
+      timestamp: Date.now(),
+      environment: {
+        userAgent: typeof navigator < "u" ? navigator.userAgent : "Node.js",
+        memory: typeof performance < "u" && "memory" in performance ? performance.memory : null
+      }
+    }, null, 2);
+  }
+  estimateMemoryUsage(e) {
+    let n = 0;
+    n += 100, "colors" in e.options && (n += e.options.colors.length * 20, n += e.options.stops ? e.options.stops.length * 8 : 0);
+    const o = g.getComplexityScore(e);
+    return n += o * 10, n;
+  }
+  updateTotalMetrics() {
+    this.totalMetrics.totalGradients = this.metrics.size;
+    const e = Array.from(this.metrics.values()).map((o) => o.complexityScore);
+    this.totalMetrics.averageComplexity = e.length > 0 ? e.reduce((o, r) => o + r, 0) / e.length : 0;
+    const n = Array.from(this.metrics.values()).reduce((o, r) => o + r.memoryUsage, 0);
+    this.totalMetrics.memoryPressure = n;
+  }
+  generateRecommendations() {
+    const e = [];
+    this.totalMetrics.totalCacheHits / (this.totalMetrics.totalCacheHits + this.totalMetrics.totalCacheMisses) < 0.7 && e.push("Consider using StateGradientAsset for frequently used gradients to improve caching"), this.totalMetrics.averageComplexity > 8 && e.push("Average gradient complexity is high. Consider simplifying gradients or using presets"), this.totalMetrics.memoryPressure > 5e4 && e.push("High memory usage detected. Consider cleanup of unused gradients");
+    const o = Array.from(this.metrics.entries()).filter(([, r]) => r.renderCount > 100);
+    return o.length > 0 && e.push(`${o.length} gradients are rendered frequently. Ensure they use caching`), e;
+  }
+};
+k(J, "instance");
+let L = J;
+const j = {
+  /**
+   * Validate and debug a gradient configuration
+   */
+  debugGradient: (t) => {
+    const e = M.validateGradient(t), n = g.getComplexityScore(t), o = g.getPerformanceImpact(t), r = [];
+    n > 10 && r.push("High complexity gradient may impact performance"), g.hasTransparency(t) && r.push("Gradient uses transparency which may affect compositing performance"), g.getColorCount(t) > 5 && r.push("Many colors in gradient may cause banding on some devices");
+    const i = [];
+    o === "high" && (i.push("Consider simplifying the gradient or using a preset"), i.push("Cache this gradient if used frequently")), n > 15 && i.push("Consider breaking complex gradient into simpler components");
+    let s = "";
+    try {
+      s = I(t);
+    } catch (l) {
+      s = `Error generating CSS: ${l.message}`;
+    }
+    return {
+      isValid: e.valid,
+      errors: e.errors,
+      warnings: r,
+      performance: {
+        complexity: n,
+        impact: o,
+        recommendations: i
+      },
+      cssOutput: s
+    };
+  },
+  /**
+   * Debug state gradient configuration
+   */
+  debugStateGradient: (t) => {
+    const e = M.validateStateGradientOptions(t), n = [], o = {};
+    return Object.entries(t).forEach(([r, i]) => {
+      r !== "animation" && (o[r] = {
+        type: typeof i == "string" ? "string" : i && "type" in i ? "gradient" : "asset",
+        complexity: i && typeof i == "object" && "type" in i ? g.getComplexityScore(i) : 1
+      });
+    }), t.animation && (t.animation.duration && t.animation.duration > 500 && n.push("Long animation duration may feel sluggish"), t.animation.duration && t.animation.duration < 50 && n.push("Very short animation duration may not be noticeable")), {
+      isValid: e.valid,
+      errors: e.errors,
+      warnings: n,
+      stateAnalysis: o
+    };
+  },
+  /**
+   * Performance profiler for gradient operations
+   */
+  profileOperation: (t, e) => {
+    if (process.env.NODE_ENV !== "development")
+      return e();
+    const n = performance.now(), o = e(), r = performance.now();
+    return console.log(`Gradient operation "${t}" took ${(r - n).toFixed(2)}ms`), o;
+  },
+  /**
+   * CSS analyzer for generated gradients
+   */
+  analyzeCSS: (t) => {
+    const e = [], n = [];
+    let o = !1;
+    return t.includes("conic-gradient") && (e.push("Chrome 69+", "Firefox 83+", "Safari 12.1+"), o = !0), t.includes("linear-gradient") && e.push("All modern browsers"), t.includes("radial-gradient") && e.push("All modern browsers"), (t.match(/#[0-9a-f]{6}|rgb\([^)]+\)|hsl\([^)]+\)/gi) || []).length > 5 && n.push("Many colors may cause performance impact on low-end devices"), t.includes("repeating-") && n.push("Repeating gradients can be GPU-intensive"), {
+      browserSupport: e,
+      fallbackRecommended: o,
+      performanceNotes: n
+    };
+  }
+}, zt = {
+  /**
+   * Log gradient information to console (development only)
+   */
+  inspect: (t, e) => {
+    if (process.env.NODE_ENV === "development") {
+      if (console.group(`🎨 Gradient Inspector${e ? ` - ${e}` : ""}`), "type" in t) {
+        const n = j.debugGradient(t);
+        console.log("Type:", t.type), console.log("Valid:", n.isValid), console.log("Complexity:", n.performance.complexity), console.log("Performance Impact:", n.performance.impact), console.log("CSS:", n.cssOutput), n.errors.length > 0 && console.error("Errors:", n.errors), n.warnings.length > 0 && console.warn("Warnings:", n.warnings);
+      } else {
+        const n = j.debugStateGradient(t);
+        console.log("Type: State Gradient"), console.log("Valid:", n.isValid), console.log("States:", Object.keys(n.stateAnalysis)), console.table(n.stateAnalysis), n.errors.length > 0 && console.error("Errors:", n.errors), n.warnings.length > 0 && console.warn("Warnings:", n.warnings);
+      }
+      console.groupEnd();
+    }
+  },
+  /**
+   * Track gradient usage in components
+   */
+  trackUsage: (t, e) => {
+    if (process.env.NODE_ENV !== "development") return;
+    L.getInstance().trackCreation(`${t}-${e}`, {
+      type: "linear",
+      options: { colors: ["#000", "#fff"], startPoint: "top", endPoint: "bottom" }
+    });
+  },
+  /**
+   * Generate performance report
+   */
+  generateReport: () => {
+    if (process.env.NODE_ENV !== "development") return;
+    const e = L.getInstance().getSummary();
+    console.group("📊 Gradient Performance Report"), console.table(e.totalMetrics), e.recommendations.length > 0 && (console.group("💡 Recommendations"), e.recommendations.forEach((n) => console.log(`• ${n}`)), console.groupEnd()), e.poorPerformers.length > 0 && (console.group("⚠️ Poor Performers"), console.table(e.poorPerformers.map((n) => ({ id: n.id, ...n.metrics }))), console.groupEnd()), console.groupEnd();
+  }
+}, Jt = L.getInstance();
+function a(t) {
+  return {
+    type: "linear",
+    options: t
+  };
+}
+function _(t) {
+  return {
+    type: "radial",
+    options: t
+  };
+}
+function K(t) {
+  return {
+    type: "angular",
+    options: t
+  };
+}
+function Kt(t) {
+  return {
+    type: "conic",
+    options: t
+  };
+}
+function Zt(t) {
+  return {
+    type: "repeating-linear",
+    options: t
+  };
+}
+function Qt(t) {
+  return {
+    type: "repeating-radial",
+    options: t
+  };
+}
+function Xt(t) {
+  return {
+    type: "elliptical",
+    options: t
+  };
+}
+var ht = Object.defineProperty, bt = (t, e, n) => e in t ? ht(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n, T = (t, e, n) => bt(t, typeof e != "symbol" ? e + "" : e, n);
+class yt {
+  constructor(e, n, o, r = {}) {
+    T(this, "_accessor"), T(this, "_setter"), T(this, "_binding"), T(this, "_metadata");
+    const [i, s] = Q(e);
+    this._accessor = i, this._setter = s, this._binding = D(i, s, {
+      name: r.name || `${o}Binding`
+    }), this._metadata = {
+      type: "State",
+      propertyName: o,
+      componentId: n.id,
+      options: r
+    }, n.setState(o, e);
+    const l = X();
+    l && l.cleanups.push(() => {
+      this.cleanup();
+    }), r.resetOnMount && this.resetToInitialValue(e), r.persist && typeof window < "u" && this.setupPersistence(o, e);
+  }
+  get wrappedValue() {
+    return this._accessor();
+  }
+  set wrappedValue(e) {
+    this._setter(e);
+  }
+  get projectedValue() {
+    return this._binding;
+  }
+  /**
+   * Get the underlying signal accessor (for advanced usage)
+   */
+  get accessor() {
+    return this._accessor;
+  }
+  /**
+   * Get the underlying signal setter (for advanced usage)
+   */
+  get setter() {
+    return this._setter;
+  }
+  /**
+   * Get property wrapper metadata
+   */
+  get metadata() {
+    return this._metadata;
+  }
+  /**
+   * Reset to initial value
+   */
+  resetToInitialValue(e) {
+    this._setter(e);
+  }
+  /**
+   * Set up local storage persistence
+   */
+  setupPersistence(e, n) {
+    const o = `tachui_state_${this._metadata.componentId}_${e}`;
+    try {
+      const r = localStorage.getItem(o);
+      if (r != null && r !== "undefined") {
+        const i = JSON.parse(r);
+        this._setter(i);
+      }
+    } catch (r) {
+      console.warn(`Failed to load persisted state for ${e}:`, r);
+    }
+    Y(() => {
+      const r = this._accessor();
+      try {
+        localStorage.setItem(o, JSON.stringify(r));
+      } catch (i) {
+        console.warn(`Failed to persist state for ${e}:`, i);
+      }
+    });
+  }
+  /**
+   * Cleanup resources
+   */
+  cleanup() {
+  }
+}
+function D(t, e, n = {}) {
+  return new Pt(t, e, n);
+}
+let Pt = class {
+  constructor(e, n, o = {}) {
+    this._get = e, this._set = n, this._options = o;
+  }
+  get wrappedValue() {
+    return this._get();
+  }
+  set wrappedValue(e) {
+    this._set(e);
+  }
+  get projectedValue() {
+    return this;
+  }
+  get() {
+    return this._get();
+  }
+  set(e) {
+    this._set(e);
+  }
+  /**
+   * Create a derived binding with transformation
+   */
+  map(e, n) {
+    return D(() => e(this._get()), (i) => {
+      const s = this._get(), l = e(s), d = typeof i == "function" ? i(l) : i, p = n(d, s);
+      this._set(p);
+    }, {
+      name: `${this._options.name || "binding"}_mapped`
+    });
+  }
+  /**
+   * Create a constant binding (read-only)
+   */
+  constant() {
+    return D(
+      this._get,
+      () => (console.warn("Attempted to set value on constant binding"), this._get()),
+      { name: `${this._options.name || "binding"}_constant` }
+    );
+  }
+};
+const te = (t, e = {}) => {
+  const n = q(), o = vt() || "state";
+  return new yt(t, n, o, e);
+}, ee = D;
+function vt() {
+  try {
+    const t = new Error().stack;
+    if (t)
+      return t.match(/at (\w+)\./)?.[1] || null;
+  } catch {
+  }
+  return null;
+}
+function _t(t) {
+  return t && typeof t == "object" && "wrappedValue" in t && "projectedValue" in t;
+}
+function wt(t) {
+  return t && typeof t == "object" && "get" in t && "set" in t && "wrappedValue" in t;
+}
+function ne(t) {
+  return _t(t) || wt(t) ? t.wrappedValue : t;
+}
+var Ct = Object.defineProperty, Ft = (t, e, n) => e in t ? Ct(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n, $ = (t, e, n) => Ft(t, typeof e != "symbol" ? e + "" : e, n);
+class y {
+  constructor(e, n, o, r, i = {}) {
+    $(this, "_get"), $(this, "_set"), $(this, "_options"), $(this, "_componentContext"), $(this, "_propertyName"), this._get = e, this._set = n, this._componentContext = o, this._propertyName = r, this._options = i, o.setBinding(r, this);
+  }
+  get wrappedValue() {
+    return this._get();
+  }
+  set wrappedValue(e) {
+    this._set(e), this._componentContext.setState(`_binding_${this._propertyName}_trigger`, Date.now());
+  }
+  get projectedValue() {
+    return this;
+  }
+  get() {
+    return this._get();
+  }
+  set(e) {
+    this._set(e), this._componentContext.setState(`_binding_${this._propertyName}_trigger`, Date.now());
+  }
+  /**
+   * Create a derived binding with transformation
+   */
+  map(e, n) {
+    const o = () => e(this._get()), r = (i) => {
+      const s = this._get(), l = e(s), d = typeof i == "function" ? i(l) : i, p = n(d, s);
+      this._set(p), this._componentContext.setState(`_binding_${this._propertyName}_mapped_trigger`, Date.now());
+    };
+    return new y(
+      o,
+      r,
+      this._componentContext,
+      `${this._propertyName}_mapped`,
+      { name: `${this._options.name || "binding"}_mapped` }
+    );
+  }
+  /**
+   * Create a constant binding (read-only)
+   */
+  constant() {
+    const e = () => (console.warn("Attempted to set value on constant binding"), this._get());
+    return new y(
+      this._get,
+      e,
+      this._componentContext,
+      `${this._propertyName}_constant`,
+      { name: `${this._options.name || "binding"}_constant` }
+    );
+  }
+  /**
+   * Create a binding with validation
+   */
+  withValidation(e, n) {
+    const o = (r) => {
+      const i = typeof r == "function" ? r(this._get()) : r;
+      return e(i) ? (this._set(i), this._componentContext.setState(
+        `_binding_${this._propertyName}_validated_trigger`,
+        Date.now()
+      )) : console.warn(n || `Validation failed for binding ${this._propertyName}`), i;
+    };
+    return new y(
+      this._get,
+      o,
+      this._componentContext,
+      `${this._propertyName}_validated`,
+      { name: `${this._options.name || "binding"}_validated` }
+    );
+  }
+  /**
+   * Create a debounced binding
+   */
+  debounced(e = 300) {
+    let n = null;
+    const o = (r) => {
+      const i = typeof r == "function" ? r(this._get()) : r;
+      return n && clearTimeout(n), n = setTimeout(() => {
+        this._set(i), this._componentContext.setState(
+          `_binding_${this._propertyName}_debounced_trigger`,
+          Date.now()
+        ), n = null;
+      }, e), i;
+    };
+    return new y(
+      this._get,
+      o,
+      this._componentContext,
+      `${this._propertyName}_debounced`,
+      { name: `${this._options.name || "binding"}_debounced` }
+    );
+  }
+}
+function U(t, e, n = {}) {
+  const o = q(), r = St() || "binding";
+  return new y(t, e, o, r, n);
+}
+function St() {
+  try {
+    const t = new Error().stack;
+    if (t)
+      return t.match(/at (\w+)\./)?.[1] || null;
+  } catch {
+  }
+  return null;
+}
+function oe(t) {
+  return t && typeof t == "object" && "get" in t && "set" in t && "wrappedValue" in t && t instanceof y;
+}
+const re = {
+  /**
+   * Check if a binding is read-only
+   */
+  isReadOnly(t) {
+    if (t instanceof y)
+      try {
+        const e = t.get(), n = console.warn;
+        let o = !1;
+        return console.warn = (...r) => {
+          r[0] === "Attempted to set value on constant binding" && (o = !0);
+        }, t.set(e), console.warn = n, o;
+      } catch {
+        return !0;
+      }
+    return !1;
+  },
+  /**
+   * Create a computed binding from multiple sources
+   */
+  computed(t, e, n = {}) {
+    const o = () => {
+      const i = t.map((s) => s.get());
+      return e(...i);
+    };
+    return U(o, () => (console.warn("Cannot set computed binding value"), o()), n);
+  },
+  /**
+   * Chain multiple bindings together
+   */
+  chain(t, e = {}) {
+    const n = () => t.map((r) => r.get());
+    return U(n, (r) => {
+      const i = typeof r == "function" ? r(n()) : r;
+      return t.forEach((s, l) => {
+        l < i.length && s.set(i[l]);
+      }), i;
+    }, e);
+  }
+};
+export {
+  re as $,
+  kt as A,
+  Ut as B,
+  Kt as C,
+  Wt as D,
+  Xt as E,
+  P as F,
+  Ht as G,
+  G as H,
+  R as I,
+  C as J,
+  x as K,
+  a as L,
+  ut as M,
+  dt as N,
+  ft as O,
+  B as P,
+  z as Q,
+  _ as R,
+  te as S,
+  Ot as T,
+  pt as U,
+  qt as V,
+  L as W,
+  j as X,
+  zt as Y,
+  Jt as Z,
+  y as _,
+  oe as a,
+  D as a0,
+  ee as a1,
+  wt as a2,
+  It as b,
+  U as c,
+  Bt as d,
+  Dt as e,
+  Mt as f,
+  O as g,
+  Tt as h,
+  _t as i,
+  Et as j,
+  Vt as k,
+  Nt as l,
+  Lt as m,
+  K as n,
+  Zt as o,
+  Qt as p,
+  V as q,
+  h as r,
+  u as s,
+  c as t,
+  ne as u,
+  g as v,
+  ct as w,
+  v as x,
+  M as y,
+  jt as z
+};