@moontra/moonui-pro 2.37.17 → 3.0.0

package/dist/index.d.ts

@@ -146,32 +146,13 @@ interface AuthContextType extends AuthState {
     refreshAuth: () => Promise<void>;
     clearAuth: () => void;
 }
-interface MoonUIAuthProviderProps {
-    children: ReactNode;
-    /**
-     * Environment mode - defaults to 'development' if not provided
-     * In Next.js: environment={process.env.NODE_ENV}
-     * In Vite: environment={import.meta.env.MODE}
-     * In CRA: environment={process.env.NODE_ENV}
-     */
-    environment?: 'development' | 'production' | 'test';
-    /**
-     * License key for production environments
-     * In Next.js: licenseKey={process.env.NEXT_PUBLIC_MOONUI_LICENSE_KEY}
-     * In Vite: licenseKey={import.meta.env.VITE_MOONUI_LICENSE_KEY}
-     * In CRA: licenseKey={process.env.REACT_APP_MOONUI_LICENSE_KEY}
-     */
-    licenseKey?: string;
-    /**
-     * Force production mode (useful for testing)
-     */
-    forceProduction?: boolean;
-}
 /**
  * MoonUI Auth Provider - Centralized authentication state
  * This provider ensures only ONE API call is made for all components
  */
-declare function MoonUIAuthProvider({ children, environment, licenseKey, forceProduction }: MoonUIAuthProviderProps): react_jsx_runtime.JSX.Element;
+declare function MoonUIAuthProvider({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
 /**
  * Hook to use auth context
  * Falls back to direct API call if context is not available
@@ -395,7 +376,7 @@ declare const MoonUIAvatarFallbackPro: React$1.ForwardRefExoticComponent<Omit<Av
  * Dark ve light modda uyumlu, erişilebilir ve çeşitli varyantlar sunar.
  */
 declare const moonUIBadgeVariantsPro: (props?: ({
-    variant?: "primary" | "secondary" | "success" | "warning" | "ghost" | "outline" | "destructive" | "pro" | "admin" | null | undefined;
+    variant?: "pro" | "primary" | "secondary" | "success" | "warning" | "ghost" | "outline" | "destructive" | "admin" | null | undefined;
     size?: "sm" | "md" | "lg" | null | undefined;
     radius?: "default" | "none" | "sm" | "lg" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
@@ -4386,7 +4367,7 @@ declare const statusVariants: (props?: ({
 declare const badgeVariants: (props?: ({
     size?: "sm" | "md" | "lg" | "xl" | "2xl" | "xs" | "3xl" | null | undefined;
     position?: "top-left" | "top-right" | "bottom-left" | "bottom-right" | null | undefined;
-    variant?: "lifetime" | "default" | "success" | "warning" | "info" | "destructive" | "pro" | null | undefined;
+    variant?: "pro" | "lifetime" | "default" | "success" | "warning" | "info" | "destructive" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 declare const iconBadgeMap: {
     crown: React$1.ForwardRefExoticComponent<Omit<lucide_react.LucideProps, "ref"> & React$1.RefAttributes<SVGSVGElement>>;

package/dist/index.mjs

@@ -2114,16 +2114,39 @@ var AUTH_CONFIG = {
     session: "x-moonui-session-id"
   }
 };
+
+// src/lib/client-token-verifier.ts
+function verifyBuildToken() {
+  try {
+    const token = process.env.MOONUI_BUILD_TOKEN;
+    if (!token) {
+      console.log("[MoonUI] No build token found");
+      return null;
+    }
+    const decoded = JSON.parse(Buffer.from(token, "base64").toString());
+    const payload = {
+      licenseKey: decoded.licenseKey || "validated",
+      domain: decoded.domain || window.location.hostname,
+      timestamp: decoded.timestamp || Date.now(),
+      expiresAt: decoded.expiresAt || Date.now() + 7 * 24 * 60 * 60 * 1e3,
+      hasProAccess: decoded.hasProAccess !== false,
+      plan: decoded.plan || "pro"
+    };
+    if (payload.expiresAt < Date.now()) {
+      console.warn("[MoonUI] Build token expired, rebuild required");
+      return null;
+    }
+    return payload;
+  } catch (error) {
+    console.error("[MoonUI] Error verifying build token:", error);
+    return null;
+  }
+}
 var AuthContext = createContext(void 0);
 var authPromise = null;
 var lastFetchTime = 0;
 var FETCH_COOLDOWN = 5e3;
-function MoonUIAuthProvider({
-  children,
-  environment = "development",
-  licenseKey,
-  forceProduction = false
-}) {
+function MoonUIAuthProvider({ children }) {
   const [state, setState] = useState({
     isLoading: true,
     hasProAccess: false,
@@ -2164,6 +2187,23 @@ function MoonUIAuthProvider({
       console.log("[MoonUI Auth] Using ongoing request");
       return authPromise;
     }
+    const buildToken = verifyBuildToken();
+    if (buildToken && buildToken.hasProAccess) {
+      console.log("[MoonUI Auth] Using build-time token - Pro access granted");
+      const tokenState = {
+        isLoading: false,
+        hasProAccess: true,
+        isAuthenticated: true,
+        subscriptionPlan: buildToken.plan === "lifetime" ? "lifetime" : "free",
+        subscription: {
+          status: "active",
+          plan: buildToken.plan === "lifetime" ? "lifetime" : "free"
+        },
+        isAdmin: false
+      };
+      setState(tokenState);
+      return tokenState;
+    }
     if (!forceRefresh2) {
       const cached = readValidationFromCookie();
       if (cached && cached.valid) {
@@ -2190,16 +2230,30 @@ function MoonUIAuthProvider({
     authPromise = (async () => {
       try {
         lastFetchTime = now;
-        const isProduction = forceProduction || environment === "production";
-        const isDevelopment = !isProduction;
-        const hasLicenseKey = !!licenseKey;
-        console.log("[MoonUI Auth] Environment Detection:", {
-          environment,
-          forceProduction,
-          hasLicenseKey,
-          isProduction,
-          isDevelopment
-        });
+        let isProduction = false;
+        let isDevelopment = true;
+        let environmentInfo = {};
+        try {
+          const envResponse = await fetch("/api/environment", {
+            method: "GET",
+            cache: "no-store"
+          });
+          if (envResponse.ok) {
+            environmentInfo = await envResponse.json();
+            isProduction = environmentInfo.isProduction;
+            isDevelopment = environmentInfo.isDevelopment;
+            console.log("[MoonUI Auth] Runtime Environment Detection:", {
+              ...environmentInfo.debug,
+              environment: environmentInfo.environment,
+              isProduction,
+              isDevelopment
+            });
+          } else {
+            console.warn("[MoonUI Auth] Failed to fetch environment info, falling back to development mode");
+          }
+        } catch (error) {
+          console.warn("[MoonUI Auth] Error fetching environment info:", error);
+        }
         if (isDevelopment) {
           let response;
           const authServerUrl = typeof window !== "undefined" ? process.env.NEXT_PUBLIC_MOONUI_AUTH_SERVER || "http://localhost:7878" : "http://localhost:7878";
@@ -2239,47 +2293,63 @@ function MoonUIAuthProvider({
             console.log('[MoonUI Auth] Auth server not available in development. Run "moonui dev" to enable Pro features.');
           }
         }
-        if (isProduction && licenseKey) {
-          console.log("[MoonUI Auth] Production mode - License key provided");
-          const cachedValidation = readValidationFromCookie();
-          if (cachedValidation && cachedValidation.valid && cachedValidation.hasProAccess) {
-            console.log("[MoonUI Auth] Using cached server validation");
-            const newState2 = {
-              isLoading: false,
-              hasProAccess: cachedValidation.hasProAccess,
-              isAuthenticated: true,
-              subscriptionPlan: "lifetime",
-              subscription: {
-                status: "active",
-                plan: "lifetime"
-              },
-              isAdmin: false
-            };
-            if (isMounted.current) {
-              setState(newState2);
+        if (isProduction) {
+          const licenseKey = environmentInfo.hasLicenseKey ? process.env.NEXT_PUBLIC_MOONUI_LICENSE_KEY || process.env.MOONUI_LICENSE_KEY || process.env.VITE_MOONUI_LICENSE_KEY || process.env.REACT_APP_MOONUI_LICENSE_KEY || "check-server" : null;
+          if (licenseKey) {
+            console.log("[MoonUI Auth] Production mode - validating license key...");
+            try {
+              const currentDomain = typeof window !== "undefined" ? window.location.hostname : process.env.VERCEL_URL || process.env.NEXT_PUBLIC_VERCEL_URL || "";
+              const apiUrl = "https://moonui.dev/api/v1/license/validate";
+              const validationResponse = await fetch(apiUrl, {
+                method: "POST",
+                headers: {
+                  "Content-Type": "application/json"
+                },
+                body: JSON.stringify({
+                  licenseKey,
+                  domain: currentDomain
+                })
+              });
+              if (validationResponse.ok) {
+                const validationData = await validationResponse.json();
+                if (validationData.valid && validationData.hasProAccess) {
+                  console.log("[MoonUI Auth] License key validated successfully");
+                  const newState = {
+                    isLoading: false,
+                    hasProAccess: validationData.hasProAccess,
+                    isAuthenticated: true,
+                    subscriptionPlan: validationData.plan === "lifetime" ? "lifetime" : "free",
+                    subscription: {
+                      status: validationData.hasProAccess ? "active" : "inactive",
+                      plan: validationData.plan === "lifetime" ? "lifetime" : "free"
+                    },
+                    isAdmin: false
+                  };
+                  if (typeof document !== "undefined" && validationData.cacheDuration) {
+                    const cacheData = {
+                      valid: true,
+                      hasProAccess: validationData.hasProAccess,
+                      timestamp: Date.now()
+                    };
+                    document.cookie = `moonui_pro_status=${encodeURIComponent(
+                      JSON.stringify(cacheData)
+                    )}; max-age=${Math.floor(validationData.cacheDuration / 1e3)}; path=/; SameSite=Strict`;
+                  }
+                  if (isMounted.current) {
+                    setState(newState);
+                  }
+                  authPromise = null;
+                  return newState;
+                } else {
+                  console.warn("[MoonUI Auth] License key validation failed:", validationData.error || "Invalid license");
+                }
+              } else {
+                console.error("[MoonUI Auth] License validation request failed:", validationResponse.status);
+              }
+            } catch (error) {
+              console.error("[MoonUI Auth] License validation error:", error);
             }
-            authPromise = null;
-            return newState2;
-          }
-          console.log("[MoonUI Auth] License key detected - granting Pro access");
-          console.log("[MoonUI Auth] Note: Actual license validation should be done server-side");
-          const newState = {
-            isLoading: false,
-            hasProAccess: true,
-            // Grant access since license key is provided
-            isAuthenticated: true,
-            subscriptionPlan: "lifetime",
-            subscription: {
-              status: "active",
-              plan: "lifetime"
-            },
-            isAdmin: false
-          };
-          if (isMounted.current) {
-            setState(newState);
           }
-          authPromise = null;
-          return newState;
         }
         const freeState = {
           isLoading: false,

package/dist/lib/build-time-validator.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Build-time license validation and token generation
+ * This runs during build process, not in browser
+ */
+interface TokenPayload {
+    licenseKey: string;
+    domain: string;
+    timestamp: number;
+    expiresAt: number;
+    hasProAccess: boolean;
+    plan: string;
+}
+/**
+ * Validate license key at build time
+ * Makes server-side request to avoid CORS
+ */
+declare function validateLicenseAtBuildTime(licenseKey: string | undefined, domain?: string): Promise<string | null>;
+/**
+ * Verify and decrypt token on client-side
+ */
+declare function verifyAndDecryptToken(token: string): TokenPayload | null;
+/**
+ * Generate a webpack DefinePlugin config with the token
+ */
+declare function generateWebpackDefineConfig(token: string | null): {
+    'process.env.MOONUI_BUILD_TOKEN': string;
+    'process.env.MOONUI_BUILD_TIME': string;
+};
+
+export { generateWebpackDefineConfig, validateLicenseAtBuildTime, verifyAndDecryptToken };

package/dist/lib/build-time-validator.mjs

@@ -0,0 +1,117 @@
+import crypto from 'crypto';
+
+/**
+ * @moontra/moonui-pro v2.0.9
+ * Premium UI components for MoonUI
+ * (c) 2025 MoonUI. All rights reserved.
+ * @license Commercial - https://moonui.dev/license
+ */
+
+var ENCRYPTION_KEY = "moonui-pro-2024-encryption-key-v1";
+var SIGNING_KEY = "moonui-pro-2024-signing-key-v1";
+async function validateLicenseAtBuildTime(licenseKey, domain) {
+  if (!licenseKey) {
+    console.log("[MoonUI Build] No license key provided");
+    return null;
+  }
+  try {
+    console.log("[MoonUI Build] Validating license key...");
+    const validationDomain = domain || process.env.VERCEL_URL || process.env.NEXT_PUBLIC_VERCEL_URL || process.env.DEPLOY_URL || "localhost";
+    const response = await fetch("https://moonui.dev/api/v1/license/validate", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Build-Time-Validation": "true",
+        "User-Agent": "MoonUI-Build-Validator/1.0"
+      },
+      body: JSON.stringify({
+        licenseKey,
+        domain: validationDomain
+      })
+    });
+    if (!response.ok) {
+      console.error("[MoonUI Build] License validation failed:", response.status);
+      return null;
+    }
+    const data = await response.json();
+    if (!data.valid || !data.hasProAccess) {
+      console.error("[MoonUI Build] Invalid license or no Pro access");
+      return null;
+    }
+    console.log("[MoonUI Build] License validated successfully");
+    const payload = {
+      licenseKey: licenseKey.substring(0, 8) + "...",
+      // Only store partial key
+      domain: validationDomain,
+      timestamp: Date.now(),
+      expiresAt: Date.now() + 7 * 24 * 60 * 60 * 1e3,
+      // 7 days
+      hasProAccess: data.hasProAccess,
+      plan: data.plan || "pro"
+    };
+    const token = encryptAndSignToken(payload);
+    return token;
+  } catch (error) {
+    console.error("[MoonUI Build] Error validating license:", error);
+    return null;
+  }
+}
+function encryptAndSignToken(payload) {
+  const payloadString = JSON.stringify(payload);
+  const iv = crypto.randomBytes(16);
+  const cipher = crypto.createCipheriv(
+    "aes-256-gcm",
+    crypto.scryptSync(ENCRYPTION_KEY, "salt", 32),
+    iv
+  );
+  let encrypted = cipher.update(payloadString, "utf8", "hex");
+  encrypted += cipher.final("hex");
+  const authTag = cipher.getAuthTag();
+  const hmac = crypto.createHmac("sha256", SIGNING_KEY);
+  hmac.update(encrypted);
+  const signature = hmac.digest("hex");
+  const token = Buffer.from(JSON.stringify({
+    encrypted,
+    authTag: authTag.toString("hex"),
+    signature,
+    iv: iv.toString("hex")
+  })).toString("base64");
+  return token;
+}
+function verifyAndDecryptToken(token) {
+  try {
+    const decoded = JSON.parse(Buffer.from(token, "base64").toString());
+    const hmac = crypto.createHmac("sha256", SIGNING_KEY);
+    hmac.update(decoded.encrypted);
+    const expectedSignature = hmac.digest("hex");
+    if (decoded.signature !== expectedSignature) {
+      console.error("[MoonUI] Invalid token signature");
+      return null;
+    }
+    const decipher = crypto.createDecipheriv(
+      "aes-256-gcm",
+      crypto.scryptSync(ENCRYPTION_KEY, "salt", 32),
+      Buffer.from(decoded.iv, "hex")
+    );
+    decipher.setAuthTag(Buffer.from(decoded.authTag, "hex"));
+    let decrypted = decipher.update(decoded.encrypted, "hex", "utf8");
+    decrypted += decipher.final("utf8");
+    const payload = JSON.parse(decrypted);
+    if (payload.expiresAt < Date.now()) {
+      console.error("[MoonUI] Token expired");
+      return null;
+    }
+    return payload;
+  } catch (error) {
+    console.error("[MoonUI] Error verifying token:", error);
+    return null;
+  }
+}
+function generateWebpackDefineConfig(token) {
+  return {
+    "process.env.MOONUI_BUILD_TOKEN": JSON.stringify(token),
+    "process.env.MOONUI_BUILD_TIME": JSON.stringify(Date.now())
+  };
+}
+
+export { generateWebpackDefineConfig, validateLicenseAtBuildTime, verifyAndDecryptToken };

package/dist/lib/client-token-verifier.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Client-side token verification
+ * This runs in the browser and verifies the build-time generated token
+ */
+interface TokenPayload {
+    licenseKey: string;
+    domain: string;
+    timestamp: number;
+    expiresAt: number;
+    hasProAccess: boolean;
+    plan: string;
+}
+/**
+ * Simple client-side token verification
+ * Note: Real decryption happens server-side, this is just a basic check
+ */
+declare function verifyBuildToken(): TokenPayload | null;
+/**
+ * Check if Pro features are enabled
+ */
+declare function hasProAccess(): boolean;
+/**
+ * Get subscription plan from token
+ */
+declare function getSubscriptionPlan(): string;
+
+export { getSubscriptionPlan, hasProAccess, verifyBuildToken };

package/dist/lib/client-token-verifier.mjs

@@ -0,0 +1,44 @@
+/**
+ * @moontra/moonui-pro v2.0.9
+ * Premium UI components for MoonUI
+ * (c) 2025 MoonUI. All rights reserved.
+ * @license Commercial - https://moonui.dev/license
+ */
+
+// src/lib/client-token-verifier.ts
+function verifyBuildToken() {
+  try {
+    const token = process.env.MOONUI_BUILD_TOKEN;
+    if (!token) {
+      console.log("[MoonUI] No build token found");
+      return null;
+    }
+    const decoded = JSON.parse(Buffer.from(token, "base64").toString());
+    const payload = {
+      licenseKey: decoded.licenseKey || "validated",
+      domain: decoded.domain || window.location.hostname,
+      timestamp: decoded.timestamp || Date.now(),
+      expiresAt: decoded.expiresAt || Date.now() + 7 * 24 * 60 * 60 * 1e3,
+      hasProAccess: decoded.hasProAccess !== false,
+      plan: decoded.plan || "pro"
+    };
+    if (payload.expiresAt < Date.now()) {
+      console.warn("[MoonUI] Build token expired, rebuild required");
+      return null;
+    }
+    return payload;
+  } catch (error) {
+    console.error("[MoonUI] Error verifying build token:", error);
+    return null;
+  }
+}
+function hasProAccess() {
+  const token = verifyBuildToken();
+  return token ? token.hasProAccess : false;
+}
+function getSubscriptionPlan() {
+  const token = verifyBuildToken();
+  return token ? token.plan : "free";
+}
+
+export { getSubscriptionPlan, hasProAccess, verifyBuildToken };

package/dist/server.d.ts

@@ -53,66 +53,6 @@ declare function performServerValidation(): Promise<{
     cached?: boolean;
 }>;
 
-/**
- * Server-side license validation helper
- * This should be used in API routes or server components to validate license keys
- * and set appropriate cookies for client-side caching
- */
-interface ValidateLicenseOptions {
-    licenseKey: string;
-    domain: string;
-}
-interface ValidationResponse {
-    valid: boolean;
-    hasProAccess: boolean;
-    plan?: 'lifetime' | 'monthly' | 'annual' | 'free';
-    error?: string;
-    cacheDuration?: number;
-}
-/**
- * Validate a MoonUI license key on the server
- * This function should be called from your API routes or server components
- *
- * @example Next.js API Route
- * ```typescript
- * // app/api/validate-license/route.ts
- * import { validateLicense } from '@moontra/moonui-pro/server';
- * import { NextResponse } from 'next/server';
- *
- * export async function POST(request: Request) {
- *   const { licenseKey } = await request.json();
- *   const domain = request.headers.get('host') || '';
- *
- *   const result = await validateLicense({ licenseKey, domain });
- *
- *   const response = NextResponse.json(result);
- *
- *   // Set cookie if validation successful
- *   if (result.valid && result.hasProAccess) {
- *     response.cookies.set('moonui_pro_status', JSON.stringify({
- *       valid: true,
- *       hasProAccess: result.hasProAccess,
- *       timestamp: Date.now()
- *     }), {
- *       httpOnly: false, // Must be accessible by client
- *       secure: process.env.NODE_ENV === 'production',
- *       sameSite: 'strict',
- *       maxAge: result.cacheDuration || 86400 // 24 hours default
- *     });
- *   }
- *
- *   return response;
- * }
- * ```
- */
-declare function validateLicense({ licenseKey, domain }: ValidateLicenseOptions): Promise<ValidationResponse>;
-/**
- * Helper to set MoonUI auth cookies
- * Use this after successful validation
- */
-declare function setAuthCookie(response: any, // Response object from your framework
-validationResult: ValidationResponse): void;
-
 /**
  * MoonUI Pro Authentication Configuration
  *
@@ -160,4 +100,4 @@ type AuthConfig = typeof AUTH_CONFIG;
 type CacheConfig = typeof AUTH_CONFIG.cache;
 type SecurityConfig = typeof AUTH_CONFIG.security;
 
-export { AUTH_CONFIG, AuthConfig, CacheConfig, SecurityConfig, clearValidationCookies, decryptData, encryptData, generateServerDeviceFingerprint, getValidationFromCookies, performServerValidation, setAuthCookie, setValidationInCookies, validateLicense, validateWithMoonUIServer };
+export { AUTH_CONFIG, AuthConfig, CacheConfig, SecurityConfig, clearValidationCookies, decryptData, encryptData, generateServerDeviceFingerprint, getValidationFromCookies, performServerValidation, setValidationInCookies, validateWithMoonUIServer };

package/dist/server.mjs

@@ -3148,67 +3148,6 @@ async function performServerValidation() {
   return { ...result, cached: false };
 }
 
-// src/lib/server-validate.ts
-async function validateLicense({
-  licenseKey,
-  domain
-}) {
-  try {
-    const response = await fetch("https://moonui.dev/api/v1/license/validate", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        // Add server-side headers to bypass CORS
-        "X-Server-Request": "true",
-        "X-Request-Domain": domain
-      },
-      body: JSON.stringify({
-        licenseKey,
-        domain
-      })
-    });
-    if (!response.ok) {
-      return {
-        valid: false,
-        hasProAccess: false,
-        error: `Validation failed: ${response.status}`
-      };
-    }
-    const data = await response.json();
-    return data;
-  } catch (error) {
-    console.error("[MoonUI Server Validate] Error:", error);
-    return {
-      valid: false,
-      hasProAccess: false,
-      error: error instanceof Error ? error.message : "Validation error"
-    };
-  }
-}
-function setAuthCookie(response, validationResult) {
-  if (validationResult.valid && validationResult.hasProAccess) {
-    const cookieData = {
-      valid: true,
-      hasProAccess: validationResult.hasProAccess,
-      timestamp: Date.now()
-    };
-    const maxAge = validationResult.cacheDuration || 86400;
-    if (typeof response.setHeader === "function") {
-      response.setHeader(
-        "Set-Cookie",
-        `moonui_pro_status=${encodeURIComponent(JSON.stringify(cookieData))}; Max-Age=${maxAge}; Path=/; SameSite=Strict; ${""}`
-      );
-    } else if (response.cookies && typeof response.cookies.set === "function") {
-      response.cookies.set("moonui_pro_status", JSON.stringify(cookieData), {
-        maxAge,
-        path: "/",
-        sameSite: "strict",
-        secure: false
-      });
-    }
-  }
-}
-
 // src/server.ts
 if (typeof window !== "undefined") {
   console.warn(
@@ -3216,4 +3155,4 @@ if (typeof window !== "undefined") {
   );
 }
 
-export { AUTH_CONFIG, clearValidationCookies, decryptData, encryptData, generateServerDeviceFingerprint, getValidationFromCookies, performServerValidation, setAuthCookie, setValidationInCookies, validateLicense, validateWithMoonUIServer };
+export { AUTH_CONFIG, clearValidationCookies, decryptData, encryptData, generateServerDeviceFingerprint, getValidationFromCookies, performServerValidation, setValidationInCookies, validateWithMoonUIServer };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@moontra/moonui-pro",
-    "version": "2.37.17",
+    "version": "3.0.0",
     "description": "Premium React components for MoonUI - Advanced UI library with 50+ pro components including performance, interactive, and gesture components",
     "type": "module",
     "main": "dist/index.mjs",