@buoy-gg/license 1.7.2

package/lib/module/api.js

@@ -0,0 +1,187 @@
+"use strict";
+
+/**
+ * Keygen REST API client for React Buoy
+ */
+
+import { KEYGEN_CONFIG } from "./config.js";
+const {
+  accountId,
+  productToken,
+  apiUrl
+} = KEYGEN_CONFIG;
+
+/**
+ * Base headers for Keygen API requests (without auth)
+ */
+function getBaseHeaders() {
+  return {
+    "Content-Type": "application/vnd.api+json",
+    Accept: "application/vnd.api+json"
+  };
+}
+
+/**
+ * Headers for license-authenticated API requests (machine operations)
+ * Uses the license key itself for authentication
+ */
+function getLicenseAuthHeaders(licenseKey) {
+  return {
+    ...getBaseHeaders(),
+    Authorization: `License ${licenseKey}`
+  };
+}
+
+/**
+ * Validate a license key with Keygen
+ */
+export async function validateLicense(licenseKey, fingerprint) {
+  // Include license.machines to get the machine count in the response
+  const url = `${apiUrl}/${accountId}/licenses/actions/validate-key?include=license.machines`;
+  const body = {
+    meta: {
+      key: licenseKey
+    }
+  };
+
+  // Include fingerprint if provided (for machine-scoped validation)
+  if (fingerprint) {
+    body.meta.scope = {
+      fingerprint
+    };
+  }
+
+  // Note: validate-key endpoint doesn't need Authorization header
+  // The license key in the body is the authentication
+  const response = await fetch(url, {
+    method: "POST",
+    headers: getBaseHeaders(),
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const errorData = await response.json();
+    const errorMessage = errorData.errors?.[0]?.detail || `HTTP ${response.status}`;
+    throw new Error(errorMessage);
+  }
+  return await response.json();
+}
+
+/**
+ * Activate a machine for a license
+ */
+export async function activateMachine(licenseId, licenseKey, fingerprint, name, metadata) {
+  const url = `${apiUrl}/${accountId}/machines`;
+  const body = {
+    data: {
+      type: "machines",
+      attributes: {
+        fingerprint,
+        name,
+        metadata: metadata || {}
+      },
+      relationships: {
+        license: {
+          data: {
+            type: "licenses",
+            id: licenseId
+          }
+        }
+      }
+    }
+  };
+  const response = await fetch(url, {
+    method: "POST",
+    headers: getLicenseAuthHeaders(licenseKey),
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const errorData = await response.json();
+    const errorCode = errorData.errors?.[0]?.code;
+    const errorMessage = errorData.errors?.[0]?.detail || `HTTP ${response.status}`;
+
+    // Check if machine limit reached
+    if (errorCode === "MACHINE_LIMIT_EXCEEDED" || errorMessage.includes("machine limit")) {
+      throw new Error("MACHINE_LIMIT_EXCEEDED");
+    }
+
+    // Check if fingerprint already exists
+    if (errorCode === "FINGERPRINT_TAKEN" || errorMessage.includes("fingerprint")) {
+      throw new Error("FINGERPRINT_TAKEN");
+    }
+    throw new Error(errorMessage);
+  }
+  return response.json();
+}
+
+/**
+ * Deactivate a machine from a license
+ */
+export async function deactivateMachine(machineId, licenseKey) {
+  const url = `${apiUrl}/${accountId}/machines/${machineId}`;
+  const response = await fetch(url, {
+    method: "DELETE",
+    headers: getLicenseAuthHeaders(licenseKey)
+  });
+  if (!response.ok && response.status !== 404) {
+    const errorData = await response.json();
+    const errorMessage = errorData.errors?.[0]?.detail || `HTTP ${response.status}`;
+    throw new Error(errorMessage);
+  }
+}
+
+/**
+ * Get all machines for a license
+ */
+export async function getLicenseMachines(licenseId, licenseKey) {
+  const url = `${apiUrl}/${accountId}/licenses/${licenseId}/machines`;
+  const response = await fetch(url, {
+    method: "GET",
+    headers: getLicenseAuthHeaders(licenseKey)
+  });
+  if (!response.ok) {
+    const errorData = await response.json();
+    const errorMessage = errorData.errors?.[0]?.detail || `HTTP ${response.status}`;
+    throw new Error(errorMessage);
+  }
+  const data = await response.json();
+  return data.data || [];
+}
+
+/**
+ * Parse validation response into a simpler result
+ * Note: response.data can be null when license is invalid (e.g., NOT_FOUND)
+ */
+export function parseValidationResult(response) {
+  const {
+    meta,
+    data
+  } = response;
+  return {
+    valid: meta.valid,
+    code: meta.code,
+    detail: meta.detail,
+    // data can be null for invalid licenses
+    metadata: data?.attributes?.metadata
+  };
+}
+
+/**
+ * Check if a validation code indicates the license needs machine activation
+ */
+export function needsMachineActivation(code) {
+  return code === "NO_MACHINE" || code === "NO_MACHINES";
+}
+
+/**
+ * Check if a validation code indicates too many machines
+ */
+export function hasTooManyMachines(code) {
+  return code === "TOO_MANY_MACHINES";
+}
+
+/**
+ * Check if a validation code indicates a fatal error (license invalid)
+ */
+export function isFatalLicenseError(code) {
+  return ["NOT_FOUND", "SUSPENDED", "EXPIRED", "BANNED", "PRODUCT_SCOPE_MISMATCH"].includes(code);
+}

package/lib/module/config.js

@@ -0,0 +1,22 @@
+"use strict";
+
+/**
+ * Keygen configuration for React Buoy
+ */
+
+export const KEYGEN_CONFIG = {
+  accountId: "b0eba0e8-e904-4906-b644-38f9aab57bed",
+  productId: "1037431d-b2fe-48db-aca9-10c5e9c4d944",
+  // Product token - read-only, safe to embed in SDK
+  productToken: "prod-4467c14b75b715e91884945cd3e69705846ccbce7dd5e380236a1ab3bc03139fv3",
+  apiUrl: "https://api.keygen.sh/v1/accounts"
+};
+
+// Cache duration: 30 days in milliseconds
+export const LICENSE_CACHE_DURATION = 30 * 24 * 60 * 60 * 1000;
+
+// How often to revalidate when app is active (4 hours)
+export const LICENSE_REVALIDATION_INTERVAL = 4 * 60 * 60 * 1000;
+
+// Storage key for cached license
+export const LICENSE_STORAGE_KEY = "@buoy-gg/license";

package/lib/module/device-info.js

@@ -0,0 +1,87 @@
+"use strict";
+
+/**
+ * Pure JS device info utilities
+ *
+ * No native module dependencies - uses only React Native core APIs.
+ * Device fingerprint is a generated UUID stored alongside license data.
+ */
+
+import { Platform } from "react-native";
+
+/**
+ * Generate a UUID v4
+ */
+export function generateUUID() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, c => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 0x3 | 0x8;
+    return v.toString(16);
+  });
+}
+
+/**
+ * Check if running on a simulator/emulator using Platform constants
+ */
+export function isSimulator() {
+  if (Platform.OS === "ios") {
+    // On iOS simulator, we can check various indicators
+    const constants = Platform.constants;
+
+    // Check for simulator interface idiom
+    if (constants?.interfaceIdiom === "simulator") {
+      return true;
+    }
+
+    // Check if running in a testing environment
+    if ("isTesting" in Platform && Platform.isTesting) {
+      return true;
+    }
+    return false;
+  }
+  if (Platform.OS === "android") {
+    const constants = Platform.constants;
+    const brand = String(constants?.Brand || "").toLowerCase();
+    const model = String(constants?.Model || "").toLowerCase();
+    const fingerprint = String(constants?.Fingerprint || "").toLowerCase();
+    const isEmulator = brand.includes("generic") || model.includes("sdk") || model.includes("emulator") || model.includes("android sdk") || fingerprint.includes("generic");
+    return isEmulator;
+  }
+  return false;
+}
+
+/**
+ * Get basic device metadata from Platform APIs
+ */
+export function getDeviceMetadata() {
+  const metadata = {
+    platform: Platform.OS,
+    osVersion: String(Platform.Version),
+    isSimulator: String(isSimulator())
+  };
+
+  // Add Android-specific constants if available
+  if (Platform.OS === "android") {
+    const constants = Platform.constants;
+    if (constants?.Brand) metadata.brand = String(constants.Brand);
+    if (constants?.Model) metadata.model = String(constants.Model);
+    if (constants?.Manufacturer) metadata.manufacturer = String(constants.Manufacturer);
+  }
+
+  // Add iOS-specific constants if available
+  if (Platform.OS === "ios") {
+    const constants = Platform.constants;
+    if (constants?.systemName) metadata.systemName = String(constants.systemName);
+    if (constants?.interfaceIdiom) metadata.interfaceIdiom = String(constants.interfaceIdiom);
+  }
+  return metadata;
+}
+
+/**
+ * Get a default device name suggestion based on platform
+ */
+export function getDefaultDeviceName() {
+  const platformName = Platform.OS === "ios" ? "iOS" : Platform.OS === "android" ? "Android" : Platform.OS;
+  const sim = isSimulator() ? " Simulator" : "";
+  return `My ${platformName} Device${sim}`;
+}

package/lib/module/fingerprint.js

@@ -0,0 +1,10 @@
+"use strict";
+
+/**
+ * Device fingerprint utilities for license activation
+ *
+ * The fingerprint is a generated UUID that is stored alongside the license.
+ * It's created when the user registers their device and persists with the license data.
+ */
+
+export { generateUUID, isSimulator, getDeviceMetadata, getDefaultDeviceName } from "./device-info.js";

package/lib/module/hooks.js

@@ -0,0 +1,208 @@
+"use strict";
+
+/**
+ * React hooks for license management
+ */
+
+import { useState, useEffect, useCallback, useRef } from "react";
+import { LicenseManager } from "./LicenseManager.js";
+/**
+ * Hook to access the current license state
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { isPro, isValidating, error } = useLicense();
+ *
+ *   if (isValidating) return <Loading />;
+ *   if (isPro) return <ProFeature />;
+ *   return <UpgradePrompt />;
+ * }
+ * ```
+ */
+export function useLicense() {
+  const [state, setState] = useState(LicenseManager.getState());
+  useEffect(() => {
+    // Initialize on first mount
+    LicenseManager.initialize();
+
+    // Subscribe to license changes
+    const unsubscribe = LicenseManager.subscribe(event => {
+      setState(LicenseManager.getState());
+    });
+
+    // Get initial state after initialization
+    setState(LicenseManager.getState());
+    return unsubscribe;
+  }, []);
+  const setLicenseKey = useCallback(async key => {
+    const result = await LicenseManager.setLicenseKey(key);
+    setState(LicenseManager.getState());
+    return result;
+  }, []);
+  const validateLicenseKey = useCallback(async key => {
+    const result = await LicenseManager.validateLicenseKey(key);
+    const newState = LicenseManager.getState();
+    setState(newState);
+    return result;
+  }, []);
+  const registerDevice = useCallback(async deviceName => {
+    const result = await LicenseManager.registerDevice(deviceName);
+    setState(LicenseManager.getState());
+    return result;
+  }, []);
+  const claimDevice = useCallback(async (machineId, existingDevices) => {
+    const result = await LicenseManager.claimDevice(machineId, existingDevices);
+    setState(LicenseManager.getState());
+    return result;
+  }, []);
+  const clearLicense = useCallback(async () => {
+    await LicenseManager.clearLicense();
+    setState(LicenseManager.getState());
+  }, []);
+  const clearCacheAndRevalidate = useCallback(async () => {
+    const result = await LicenseManager.clearCacheAndRevalidate();
+    setState(LicenseManager.getState());
+    return result;
+  }, []);
+  return {
+    ...state,
+    setLicenseKey,
+    validateLicenseKey,
+    registerDevice,
+    claimDevice,
+    clearLicense,
+    clearCacheAndRevalidate
+  };
+}
+
+/**
+ * Hook to check if a feature is available based on license
+ */
+export function useFeatureAccess(featureCode) {
+  const {
+    isPro,
+    isInitialized,
+    isValidating
+  } = useLicense();
+  const hasAccess = isPro;
+  const isLoading = !isInitialized || isValidating;
+  return {
+    hasAccess,
+    isPro,
+    isLoading
+  };
+}
+
+/**
+ * Hook to get seat/machine information
+ */
+export function useSeats() {
+  const [seats, setSeats] = useState(LicenseManager.getSeatsInfo());
+  useEffect(() => {
+    const unsubscribe = LicenseManager.subscribe(() => {
+      setSeats(LicenseManager.getSeatsInfo());
+    });
+    return unsubscribe;
+  }, []);
+  return {
+    ...seats,
+    remaining: seats.total !== null ? seats.total - seats.used : null
+  };
+}
+
+/**
+ * Hook that returns true only when Pro and not loading
+ */
+export function useIsPro() {
+  const {
+    isPro,
+    isInitialized
+  } = useLicense();
+  return isInitialized && isPro;
+}
+
+/**
+ * Hook for device management
+ */
+export function useDevices() {
+  const [devices, setDevices] = useState([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const {
+    isPro,
+    machineId
+  } = useLicense();
+  const refreshDevices = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const deviceList = await LicenseManager.getRegisteredDevices();
+      setDevices(deviceList);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to load devices");
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  // Use ref to avoid infinite loop risk if refreshDevices dependencies change
+  const refreshDevicesRef = useRef(refreshDevices);
+  refreshDevicesRef.current = refreshDevices;
+  const registerDevice = useCallback(async deviceName => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await LicenseManager.registerDevice(deviceName);
+      if (result.success) {
+        await refreshDevices();
+      } else if (result.error) {
+        setError(result.error);
+      }
+      return result;
+    } catch (err) {
+      const error = err instanceof Error ? err.message : "Failed to register device";
+      setError(error);
+      return {
+        success: false,
+        error
+      };
+    } finally {
+      setIsLoading(false);
+    }
+  }, [refreshDevices]);
+  const deactivateDevice = useCallback(async machineIdToDeactivate => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await LicenseManager.deactivateDevice(machineIdToDeactivate);
+      if (result) {
+        await refreshDevices();
+      }
+      return result;
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to deactivate device");
+      return false;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [refreshDevices]);
+  useEffect(() => {
+    if (isPro) {
+      refreshDevicesRef.current();
+    } else {
+      setDevices([]);
+    }
+  }, [isPro]);
+  return {
+    devices,
+    isLoading,
+    error,
+    refreshDevices,
+    registerDevice,
+    deactivateDevice,
+    isCurrentDeviceRegistered: machineId !== null
+  };
+}
+
+// Re-export types for convenience

package/lib/module/index.js

@@ -0,0 +1,43 @@
+"use strict";
+
+/**
+ * @buoy-gg/license
+ *
+ * License validation for React Buoy Pro features
+ */
+
+// Main manager
+export { LicenseManager } from "./LicenseManager.js";
+
+// React hooks
+export { useLicense, useFeatureAccess, useSeats, useIsPro, useDevices } from "./hooks.js";
+
+// Types
+
+// Utilities (for advanced use cases)
+export { generateUUID, isSimulator, getDeviceMetadata, getDefaultDeviceName } from "./fingerprint.js";
+
+// Convenience function for setting license key
+export async function setLicenseKey(key) {
+  const {
+    LicenseManager: LM
+  } = await import("./LicenseManager");
+  await LM.initialize();
+  return LM.setLicenseKey(key);
+}
+
+// Convenience function for checking Pro status
+export function isPro() {
+  const {
+    LicenseManager: LM
+  } = require("./LicenseManager");
+  return LM.isPro();
+}
+
+// Convenience function for checking entitlement
+export function hasEntitlement(code) {
+  const {
+    LicenseManager: LM
+  } = require("./LicenseManager");
+  return LM.hasEntitlement(code);
+}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/module/types.js

@@ -0,0 +1 @@
+"use strict";

package/lib/typescript/commonjs/LicenseManager.d.ts

@@ -0,0 +1,132 @@
+/**
+ * LicenseManager - Singleton for managing React Buoy Pro licenses
+ *
+ * Handles license validation, machine activation, caching, and state management.
+ *
+ * New flow:
+ * 1. validateLicenseKey() - Check if license is valid, returns existing devices
+ * 2. registerDevice(deviceName) - Register new device with user-provided name
+ * 3. claimDevice(machineId) - Re-claim an existing device after storage clear
+ */
+import type { LicenseState, LicenseListener, RegisteredDevice } from "./types";
+/**
+ * Result of license validation - indicates what action is needed
+ */
+export interface LicenseValidationResult {
+    valid: boolean;
+    needsDeviceRegistration: boolean;
+    existingDevices: RegisteredDevice[];
+    error?: string;
+    maxDevices?: number;
+    currentDeviceCount?: number;
+}
+/**
+ * Result of device registration
+ */
+export interface DeviceRegistrationResult {
+    success: boolean;
+    error?: string;
+}
+declare class LicenseManagerImpl {
+    private state;
+    private listeners;
+    private revalidationTimer;
+    private cachedLicense;
+    private pendingLicenseId;
+    private validationInProgress;
+    private registrationInProgress;
+    private initPromise;
+    /**
+     * Initialize the license manager and load cached license
+     */
+    initialize(): Promise<void>;
+    /**
+     * Internal initialization logic
+     */
+    private _doInitialize;
+    /**
+     * Validate a license key and check what action is needed
+     * Returns info about whether device registration is needed
+     */
+    validateLicenseKey(licenseKey: string): Promise<LicenseValidationResult>;
+    /**
+     * Register a new device with a user-provided name
+     */
+    registerDevice(deviceName: string): Promise<DeviceRegistrationResult>;
+    /**
+     * Claim an existing device (use its fingerprint)
+     * This is for when the user wants to re-use a device slot after clearing storage
+     */
+    claimDevice(machineId: string, existingDevices: RegisteredDevice[]): Promise<boolean>;
+    /**
+     * Legacy method - validates and auto-registers if needed (for backward compatibility)
+     * Note: This won't work well with the new flow - use validateLicenseKey + registerDevice instead
+     */
+    setLicenseKey(licenseKey: string): Promise<boolean>;
+    /**
+     * Check if an error is a network error (not an API validation error)
+     */
+    private isNetworkError;
+    /**
+     * Clear the current license
+     */
+    clearLicense(): Promise<void>;
+    /**
+     * Check if the user has Pro features
+     */
+    isPro(): boolean;
+    /**
+     * Check if a specific entitlement is available
+     */
+    hasEntitlement(code: string): boolean;
+    /**
+     * Get current license state
+     */
+    getState(): Readonly<LicenseState>;
+    /**
+     * Get seat information
+     */
+    getSeatsInfo(): {
+        used: number;
+        total: number | null;
+    };
+    /**
+     * Subscribe to license events
+     */
+    subscribe(listener: LicenseListener): () => void;
+    /**
+     * Get all registered devices for the current license
+     */
+    getRegisteredDevices(): Promise<RegisteredDevice[]>;
+    /**
+     * Deactivate a specific device by machine ID
+     */
+    deactivateDevice(machineId: string): Promise<boolean>;
+    /**
+     * Register the current device for the license (legacy - use registerDevice instead)
+     */
+    registerCurrentDevice(): Promise<boolean>;
+    /**
+     * Check if the current device is registered
+     */
+    isCurrentDeviceRegistered(): boolean;
+    private emit;
+    private countMachines;
+    private isCacheValid;
+    private loadCachedLicense;
+    private saveLicenseToCache;
+    private clearCachedLicense;
+    private validateInBackground;
+    private startRevalidationTimer;
+    /**
+     * Stop the revalidation timer
+     */
+    stopRevalidationTimer(): void;
+    /**
+     * Clear cache and revalidate
+     */
+    clearCacheAndRevalidate(): Promise<boolean>;
+}
+export declare const LicenseManager: LicenseManagerImpl;
+export {};
+//# sourceMappingURL=LicenseManager.d.ts.map

package/lib/typescript/commonjs/LicenseManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LicenseManager.d.ts","sourceRoot":"","sources":["../../../src/LicenseManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AA0DH,OAAO,KAAK,EAEV,YAAY,EAEZ,eAAe,EAEf,gBAAgB,EACjB,MAAM,SAAS,CAAC;AAEjB;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,OAAO,CAAC;IACf,uBAAuB,EAAE,OAAO,CAAC;IACjC,eAAe,EAAE,gBAAgB,EAAE,CAAC;IACpC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,cAAM,kBAAkB;IACtB,OAAO,CAAC,KAAK,CAUX;IAEF,OAAO,CAAC,SAAS,CAAmC;IACpD,OAAO,CAAC,iBAAiB,CAA+C;IACxE,OAAO,CAAC,aAAa,CAA8B;IAGnD,OAAO,CAAC,gBAAgB,CAAuB;IAG/C,OAAO,CAAC,oBAAoB,CAAS;IAGrC,OAAO,CAAC,sBAAsB,CAAS;IAGvC,OAAO,CAAC,WAAW,CAA8B;IAEjD;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAUjC;;OAEG;YACW,aAAa;IAoC3B;;;OAGG;IACG,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAoM9E;;OAEG;IACG,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAwF3E;;;OAGG;IACG,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,eAAe,EAAE,gBAAgB,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;IAyD3F;;;OAGG;IACG,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAiBzD;;OAEG;IACH,OAAO,CAAC,cAAc;IAkBtB;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAwBnC;;OAEG;IACH,KAAK,IAAI,OAAO;IAIhB;;OAEG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAOrC;;OAEG;IACH,QAAQ,IAAI,QAAQ,CAAC,YAAY,CAAC;IAIlC;;OAEG;IACH,YAAY,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE;IAOtD;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,IAAI;IAKhD;;OAEG;IACG,oBAAoB,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;IA4BzD;;OAEG;IACG,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAkD3D;;OAEG;IACG,qBAAqB,IAAI,OAAO,CAAC,OAAO,CAAC;IAU/C;;OAEG;IACH,yBAAyB,IAAI,OAAO;IAMpC,OAAO,CAAC,IAAI;IAYZ,OAAO,CAAC,aAAa;IAqBrB,OAAO,CAAC,YAAY;YAkBN,iBAAiB;YAajB,kBAAkB;YAoClB,kBAAkB;IAWhC,OAAO,CAAC,oBAAoB;IAsB5B,OAAO,CAAC,sBAAsB;IAiB9B;;OAEG;IACH,qBAAqB,IAAI,IAAI;IAO7B;;OAEG;IACG,uBAAuB,IAAI,OAAO,CAAC,OAAO,CAAC;CAalD;AAGD,eAAO,MAAM,cAAc,oBAA2B,CAAC"}