@shohojdhara/atomix 0.3.0 → 0.3.1

package/src/lib/composables/useAtomixGlass.ts

@@ -14,6 +14,7 @@ import type {
   OverLightObjectConfig,
 } from '../types/components';
 import { ATOMIX_GLASS } from '../constants/components';
+import { globalMouseTracker } from './shared-mouse-tracker';
 import {
   calculateDistance,
   calculateElementCenter,
@@ -25,6 +26,125 @@ import {
 
 const { CONSTANTS } = ATOMIX_GLASS;
 
+// Module-level shared background detection cache using WeakMap
+// Automatically cleaned up when elements are removed from DOM
+interface BackgroundDetectionCacheEntry {
+  result: boolean;
+  timestamp: number;
+  config: OverLightConfig;
+  threshold: number;
+}
+
+const backgroundDetectionCache = new WeakMap<HTMLElement, BackgroundDetectionCacheEntry>();
+
+/**
+ * Compare two OverLightConfig values for equality
+ * Handles primitives (boolean, 'auto') and objects with deep comparison
+ */
+const compareOverLightConfig = (
+  config1: OverLightConfig,
+  config2: OverLightConfig
+): boolean => {
+  // Primitive comparison for boolean and 'auto'
+  if (typeof config1 !== 'object' || config1 === null) {
+    return config1 === config2;
+  }
+
+  // Both must be objects at this point
+  if (typeof config2 !== 'object' || config2 === null) {
+    return false;
+  }
+
+  const obj1 = config1 as OverLightObjectConfig;
+  const obj2 = config2 as OverLightObjectConfig;
+
+  // Deep comparison of object properties
+  // Compare all defined properties (threshold, opacity, contrast, brightness, saturationBoost)
+  const props: (keyof OverLightObjectConfig)[] = [
+    'threshold',
+    'opacity',
+    'contrast',
+    'brightness',
+    'saturationBoost',
+  ];
+
+  for (const prop of props) {
+    const val1 = obj1[prop];
+    const val2 = obj2[prop];
+
+    // If both are undefined, they're equal for this property
+    if (val1 === undefined && val2 === undefined) {
+      continue;
+    }
+
+    // If one is undefined and the other isn't, they're different
+    if (val1 === undefined || val2 === undefined) {
+      return false;
+    }
+
+    // Compare numeric values (handle NaN and floating point precision)
+    if (typeof val1 === 'number' && typeof val2 === 'number') {
+      // Use Number.isNaN for proper NaN comparison
+      if (Number.isNaN(val1) && Number.isNaN(val2)) {
+        continue;
+      }
+      if (Number.isNaN(val1) || Number.isNaN(val2)) {
+        return false;
+      }
+      // Compare with small epsilon for floating point numbers
+      if (Math.abs(val1 - val2) > Number.EPSILON) {
+        return false;
+      }
+    } else if (val1 !== val2) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+/**
+ * Get cached background detection result
+ */
+const getCachedBackgroundDetection = (
+  parentElement: HTMLElement | null,
+  overLightConfig: OverLightConfig
+): boolean | null => {
+  if (!parentElement) {
+    return null;
+  }
+  
+  const cached = backgroundDetectionCache.get(parentElement);
+  if (cached && compareOverLightConfig(cached.config, overLightConfig)) {
+    // Update timestamp for LRU-like behavior (though WeakMap doesn't support LRU)
+    cached.timestamp = Date.now();
+    return cached.result;
+  }
+  
+  return null;
+};
+
+/**
+ * Set cached background detection result
+ */
+const setCachedBackgroundDetection = (
+  parentElement: HTMLElement | null,
+  overLightConfig: OverLightConfig,
+  result: boolean,
+  threshold: number
+): void => {
+  if (!parentElement) {
+    return;
+  }
+  
+  backgroundDetectionCache.set(parentElement, {
+    result,
+    timestamp: Date.now(),
+    config: overLightConfig,
+    threshold,
+  });
+};
+
 interface UseAtomixGlassOptions extends Omit<AtomixGlassProps, 'children'> {
   glassRef: React.RefObject<HTMLDivElement>;
   contentRef: React.RefObject<HTMLDivElement>;
@@ -44,7 +164,7 @@ interface UseAtomixGlassReturn {
   detectedOverLight: boolean;
   globalMousePosition: MousePosition;
   mouseOffset: MousePosition;
-  
+
   // OverLight config
   overLightConfig: {
     isOverLight: boolean;
@@ -56,12 +176,12 @@ interface UseAtomixGlassReturn {
     shadowIntensity: number;
     borderOpacity: number;
   };
-  
+
   // Transform calculations
   elasticTranslation: { x: number; y: number };
   directionalScale: string;
   transformStyle: string;
-  
+
   // Event handlers
   handleMouseEnter: () => void;
   handleMouseLeave: () => void;
@@ -108,19 +228,21 @@ export function useAtomixGlass({
   const [userPrefersReducedMotion, setUserPrefersReducedMotion] = useState(false);
   const [userPrefersHighContrast, setUserPrefersHighContrast] = useState(false);
   const [detectedOverLight, setDetectedOverLight] = useState(false);
+  
+  // Use shared module-level cache (no per-instance cache needed)
 
   // Memoized derived values
   const effectiveCornerRadius = useMemo(() => {
     if (cornerRadius !== undefined) {
       const result = Math.max(0, cornerRadius);
-      if (debugCornerRadius) {
+      if (process.env.NODE_ENV !== 'production' && debugCornerRadius) {
         console.log('[AtomixGlass] Using manual cornerRadius prop:', result);
       }
       return result;
     }
 
     const result = Math.max(0, dynamicCornerRadius);
-    if (debugCornerRadius) {
+    if (process.env.NODE_ENV !== 'production' && debugCornerRadius) {
       console.log('[AtomixGlass] Using dynamic cornerRadius:', result);
     }
     return result;
@@ -180,21 +302,21 @@ export function useAtomixGlass({
         if (extractedRadius !== null && extractedRadius > 0) {
           setDynamicCornerRadius(extractedRadius);
 
-          if (debugCornerRadius) {
+          if (process.env.NODE_ENV !== 'production' && debugCornerRadius) {
             console.log('[AtomixGlass] Corner radius extracted:', {
               value: extractedRadius,
               source: extractionSource,
               timestamp: new Date().toISOString(),
             });
           }
-        } else if (debugCornerRadius) {
+        } else if (process.env.NODE_ENV !== 'production' && debugCornerRadius) {
           console.log(
             '[AtomixGlass] No corner radius found, using default:',
             CONSTANTS.DEFAULT_CORNER_RADIUS
           );
         }
       } catch (error) {
-        if (debugCornerRadius) {
+        if (process.env.NODE_ENV !== 'production' && debugCornerRadius) {
           console.error('[AtomixGlass] Error extracting corner radius:', error);
         }
       }
@@ -209,22 +331,31 @@ export function useAtomixGlass({
   useEffect(() => {
     // Only run auto-detection for 'auto' mode or object config (which uses auto-detection)
     const shouldDetect = (overLight === 'auto' || (typeof overLight === 'object' && overLight !== null));
-    
+
     if (shouldDetect && glassRef.current) {
+      const element = glassRef.current;
+      const parentElement = element.parentElement;
+      
+      // Check shared cache: skip detection if parent unchanged and config unchanged
+      const cachedResult = getCachedBackgroundDetection(parentElement, overLight);
+      if (cachedResult !== null) {
+        setDetectedOverLight(cachedResult);
+        return;
+      }
+
       const timeoutId = setTimeout(() => {
         try {
-          const element = glassRef.current;
           if (!element) {
             setDetectedOverLight(false);
             return;
           }
-          
+
           // Validate window context
           if (typeof window === 'undefined' || typeof window.getComputedStyle !== 'function') {
             setDetectedOverLight(false);
             return;
           }
-          
+
           let totalLuminance = 0;
           let validSamples = 0;
           let hasValidBackground = false;
@@ -233,7 +364,7 @@ export function useAtomixGlass({
           let depth = 0;
           const maxDepth = 20;
           const maxSamples = 10;
-          
+
           // Limit traversal depth to prevent infinite loops and performance issues
           while (currentElement && validSamples < maxSamples && depth < maxDepth) {
             try {
@@ -243,7 +374,7 @@ export function useAtomixGlass({
                 depth++;
                 continue;
               }
-              
+
               const bgColor = computedStyle.backgroundColor;
               const bgImage = computedStyle.backgroundImage;
 
@@ -254,11 +385,11 @@ export function useAtomixGlass({
                   const r = Number(rgb[0]);
                   const g = Number(rgb[1]);
                   const b = Number(rgb[2]);
-                  
+
                   // Validate RGB values are valid numbers
-                  if (!isNaN(r) && !isNaN(g) && !isNaN(b) && 
-                      isFinite(r) && isFinite(g) && isFinite(b) &&
-                      r >= 0 && r <= 255 && g >= 0 && g <= 255 && b >= 0 && b <= 255) {
+                  if (!isNaN(r) && !isNaN(g) && !isNaN(b) &&
+                    isFinite(r) && isFinite(g) && isFinite(b) &&
+                    r >= 0 && r <= 255 && g >= 0 && g <= 255 && b >= 0 && b <= 255) {
                     // Only consider if it's not pure black or very dark
                     if (r > 10 || g > 10 || b > 10) {
                       const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
@@ -271,7 +402,7 @@ export function useAtomixGlass({
                   }
                 }
               }
-              
+
               // Check for image backgrounds
               if (bgImage && bgImage !== 'none' && bgImage !== 'initial') {
                 // For image backgrounds, assume medium luminance
@@ -285,7 +416,7 @@ export function useAtomixGlass({
                 console.debug('AtomixGlass: Error getting computed style for element:', styleError);
               }
             }
-            
+
             // Move to parent element for next iteration
             if (currentElement) {
               currentElement = currentElement.parentElement;
@@ -300,25 +431,29 @@ export function useAtomixGlass({
             const avgLuminance = totalLuminance / validSamples;
             if (!isNaN(avgLuminance) && isFinite(avgLuminance)) {
               let threshold = 0.7; // Conservative threshold for overlight
-              
+
               // If overLight is an object, use its threshold property with validation
               if (typeof overLight === 'object' && overLight !== null) {
                 const objConfig = overLight as OverLightObjectConfig;
                 if (objConfig.threshold !== undefined) {
-                  const configThreshold = typeof objConfig.threshold === 'number' && 
-                                         !isNaN(objConfig.threshold) && 
-                                         isFinite(objConfig.threshold)
-                                         ? objConfig.threshold 
-                                         : 0.7;
+                  const configThreshold = typeof objConfig.threshold === 'number' &&
+                    !isNaN(objConfig.threshold) &&
+                    isFinite(objConfig.threshold)
+                    ? objConfig.threshold
+                    : 0.7;
                   threshold = Math.min(0.9, Math.max(0.1, configThreshold));
                 }
               }
-              
+
               const isOverLightDetected = avgLuminance > threshold;
-              setDetectedOverLight(isOverLightDetected);
               
+              // Cache the result in shared cache
+              setCachedBackgroundDetection(element.parentElement, overLight, isOverLightDetected, threshold);
+              
+              setDetectedOverLight(isOverLightDetected);
+
               // Debug logging
-              if (debugOverLight) {
+              if (process.env.NODE_ENV !== 'production' && debugOverLight) {
                 console.log('[AtomixGlass] OverLight Detection:', {
                   avgLuminance: avgLuminance.toFixed(3),
                   threshold: threshold.toFixed(3),
@@ -331,28 +466,46 @@ export function useAtomixGlass({
               }
             } else {
               // Invalid luminance calculation, default to false
-              setDetectedOverLight(false);
+              const result = false;
+              const threshold = typeof overLight === 'object' && overLight !== null
+                ? (overLight as OverLightObjectConfig).threshold || 0.7
+                : 0.7;
+              setCachedBackgroundDetection(element.parentElement, overLight, result, threshold);
+              setDetectedOverLight(result);
             }
           } else {
             // Default to false if no valid background found
-            setDetectedOverLight(false);
+            const result = false;
+            const threshold = typeof overLight === 'object' && overLight !== null
+              ? (overLight as OverLightObjectConfig).threshold || 0.7
+              : 0.7;
+            setCachedBackgroundDetection(element.parentElement, overLight, result, threshold);
+            setDetectedOverLight(result);
           }
         } catch (error) {
           // Enhanced error logging with context
           if (process.env.NODE_ENV === 'development') {
             console.warn('AtomixGlass: Error detecting background brightness:', error);
           }
-          setDetectedOverLight(false);
+          const result = false;
+          if (element && element.parentElement) {
+            const threshold = typeof overLight === 'object' && overLight !== null
+              ? (overLight as OverLightObjectConfig).threshold || 0.7
+              : 0.7;
+            setCachedBackgroundDetection(element.parentElement, overLight, result, threshold);
+          }
+          setDetectedOverLight(result);
         }
       }, 150);
-      
+
       return () => clearTimeout(timeoutId);
     } else if (typeof overLight === 'boolean') {
       // For boolean values, disable auto-detection
+      // Cache is automatically managed by WeakMap (no manual clearing needed)
       setDetectedOverLight(false);
-      
+
       // Debug logging for boolean mode
-      if (debugOverLight) {
+      if (process.env.NODE_ENV !== 'production' && debugOverLight) {
         console.log('[AtomixGlass] OverLight Mode: boolean', {
           value: overLight,
           autoDetection: false,
@@ -407,88 +560,121 @@ export function useAtomixGlass({
     }
   }, [overLight, glassRef, debugOverLight]);
 
-  // Mouse tracking
-  const mouseMoveThrottleRef = useRef<number | null>(null);
-  const lastMouseEventRef = useRef<MouseEvent | null>(null);
-
-  const handleMouseMove = useCallback(
-    (e: MouseEvent) => {
-      lastMouseEventRef.current = e;
+  // Mouse tracking using shared global tracker
+  // Cache bounding rect to avoid repeated getBoundingClientRect calls
+  const cachedRectRef = useRef<DOMRect | null>(null);
+  const updateRectRef = useRef<number | null>(null);
+
+  // Handle mouse position updates from shared tracker
+  const handleGlobalMousePosition = useCallback(
+    (globalPos: MousePosition) => {
+      if (externalGlobalMousePosition && externalMouseOffset) {
+        // External mouse position provided, skip internal tracking
+        return;
+      }
 
-      if (mouseMoveThrottleRef.current === null) {
-        mouseMoveThrottleRef.current = requestAnimationFrame(() => {
-          const event = lastMouseEventRef.current;
-          if (!event) {
-            mouseMoveThrottleRef.current = null;
-            return;
-          }
+      if (effectiveDisableEffects) {
+        return;
+      }
 
-          const container = mouseContainer?.current || glassRef.current;
-          if (!container) {
-            mouseMoveThrottleRef.current = null;
-            return;
-          }
+      const container = mouseContainer?.current || glassRef.current;
+      if (!container) {
+        return;
+      }
 
-          const startTime = enablePerformanceMonitoring ? performance.now() : 0;
+      const startTime = enablePerformanceMonitoring ? performance.now() : 0;
 
-          const rect = container.getBoundingClientRect();
-          if (rect.width === 0 || rect.height === 0) {
-            mouseMoveThrottleRef.current = null;
-            return;
-          }
+      // Use cached rect if available, otherwise get new one
+      let rect = cachedRectRef.current;
+      if (!rect || rect.width === 0 || rect.height === 0) {
+        rect = container.getBoundingClientRect();
+        cachedRectRef.current = rect;
+      }
 
-          const center = calculateElementCenter(rect);
+      if (rect.width === 0 || rect.height === 0) {
+        return;
+      }
 
-          setInternalMouseOffset({
-            x: ((event.clientX - center.x) / rect.width) * 100,
-            y: ((event.clientY - center.y) / rect.height) * 100,
-          });
+      const center = calculateElementCenter(rect);
 
-          setInternalGlobalMousePosition({
-            x: event.clientX,
-            y: event.clientY,
-          });
+      // Calculate offset relative to this container
+      const newOffset = {
+        x: ((globalPos.x - center.x) / rect.width) * 100,
+        y: ((globalPos.y - center.y) / rect.height) * 100,
+      };
 
-          if (enablePerformanceMonitoring) {
-            const endTime = performance.now();
-            const duration = endTime - startTime;
-            if (duration > 5) {
-              console.warn(`AtomixGlass: Mouse tracking took ${duration.toFixed(2)}ms`);
-            }
-          }
+      // React 18 automatically batches these updates
+      setInternalMouseOffset(newOffset);
+      setInternalGlobalMousePosition(globalPos);
 
-          mouseMoveThrottleRef.current = null;
-        });
+      if (process.env.NODE_ENV !== 'production' && enablePerformanceMonitoring) {
+        const endTime = performance.now();
+        const duration = endTime - startTime;
+        if (duration > 5) {
+          console.warn(`AtomixGlass: Mouse tracking took ${duration.toFixed(2)}ms`);
+        }
       }
     },
-    [mouseContainer, glassRef, enablePerformanceMonitoring]
+    [
+      mouseContainer,
+      glassRef,
+      externalGlobalMousePosition,
+      externalMouseOffset,
+      effectiveDisableEffects,
+      enablePerformanceMonitoring,
+    ]
   );
 
+  // Subscribe to shared mouse tracker
   useEffect(() => {
     if (externalGlobalMousePosition && externalMouseOffset) {
+      // External mouse position provided, don't subscribe
       return undefined;
     }
 
     if (effectiveDisableEffects) {
+      // Effects disabled, don't subscribe
       return undefined;
     }
 
+    // Subscribe to shared tracker
+    const unsubscribe = globalMouseTracker.subscribe(handleGlobalMousePosition);
+
+    // Update cached rect when container size changes
+    const updateRect = () => {
+      if (updateRectRef.current !== null) {
+        cancelAnimationFrame(updateRectRef.current);
+      }
+      updateRectRef.current = requestAnimationFrame(() => {
+        const container = mouseContainer?.current || glassRef.current;
+        if (container) {
+          cachedRectRef.current = container.getBoundingClientRect();
+        }
+        updateRectRef.current = null;
+      });
+    };
+
+    // Use ResizeObserver to update cached rect when container size changes
     const container = mouseContainer?.current || glassRef.current;
-    if (!container) {
-      return undefined;
+    let resizeObserver: ResizeObserver | null = null;
+    
+    if (container && typeof ResizeObserver !== 'undefined') {
+      resizeObserver = new ResizeObserver(updateRect);
+      resizeObserver.observe(container);
     }
 
-    container.addEventListener('mousemove', handleMouseMove, { passive: true });
-
     return () => {
-      container.removeEventListener('mousemove', handleMouseMove);
-      if (mouseMoveThrottleRef.current) {
-        cancelAnimationFrame(mouseMoveThrottleRef.current);
-        mouseMoveThrottleRef.current = null;
+      unsubscribe();
+      if (updateRectRef.current !== null) {
+        cancelAnimationFrame(updateRectRef.current);
+        updateRectRef.current = null;
+      }
+      if (resizeObserver) {
+        resizeObserver.disconnect();
       }
     };
   }, [
-    handleMouseMove,
+    handleGlobalMousePosition,
     mouseContainer,
     glassRef,
     externalGlobalMousePosition,
@@ -632,10 +818,10 @@ export function useAtomixGlass({
           return;
         }
 
-        const cornerRadiusOffset = Math.max(0, Math.min(effectiveCornerRadius * 0.1, 10));
+        // Measure actual rendered size without artificial offsets to avoid feedback loops
         const newSize: GlassSize = {
-          width: Math.round(rect.width + cornerRadiusOffset),
-          height: Math.round(rect.height + cornerRadiusOffset),
+          width: Math.round(rect.width),
+          height: Math.round(rect.height),
         };
 
         const cornerRadiusChanged = lastCornerRadius !== effectiveCornerRadius;
@@ -662,32 +848,29 @@ export function useAtomixGlass({
     const initialTimeoutId = setTimeout(() => updateGlassSize(true), 0);
 
     let resizeObserver: ResizeObserver | null = null;
-    let fallbackInterval: NodeJS.Timeout | null = null;
-
-    const hasResizeObserver = typeof ResizeObserver !== 'undefined';
+    let resizeDebounceTimeout: NodeJS.Timeout | null = null;
 
-    if (hasResizeObserver && isValidElement(glassRef.current)) {
+    // ResizeObserver has 98%+ browser support, no need for fallback
+    if (typeof ResizeObserver !== 'undefined' && isValidElement(glassRef.current)) {
       try {
         resizeObserver = new ResizeObserver(entries => {
           for (const entry of entries) {
             if (entry.target === glassRef.current) {
-              updateGlassSize(false);
+              // Update cached rect when size changes
+              if (glassRef.current) {
+                cachedRectRef.current = glassRef.current.getBoundingClientRect();
+              }
+              // Debounce resize updates to match RAF timing (16ms)
+              if (resizeDebounceTimeout) clearTimeout(resizeDebounceTimeout);
+              resizeDebounceTimeout = setTimeout(() => updateGlassSize(false), 16);
               break;
             }
           }
         });
         resizeObserver.observe(glassRef.current);
-      } catch {
-        fallbackInterval = setInterval(
-          () => isValidElement(glassRef.current) && updateGlassSize(false),
-          100
-        );
+      } catch (error) {
+        console.warn('AtomixGlass: ResizeObserver not available, using window resize only', error);
       }
-    } else {
-      fallbackInterval = setInterval(
-        () => isValidElement(glassRef.current) && updateGlassSize(false),
-        100
-      );
     }
 
     window.addEventListener('resize', debouncedResizeHandler, { passive: true });
@@ -696,7 +879,7 @@ export function useAtomixGlass({
       clearTimeout(initialTimeoutId);
       if (rafId !== null) cancelAnimationFrame(rafId);
       if (resizeTimeoutId) clearTimeout(resizeTimeoutId);
-      if (fallbackInterval) clearInterval(fallbackInterval);
+      if (resizeDebounceTimeout) clearTimeout(resizeDebounceTimeout);
       window.removeEventListener('resize', debouncedResizeHandler);
       resizeObserver?.disconnect();
     };
@@ -749,7 +932,7 @@ export function useAtomixGlass({
 
     // More robust overlight configuration with better defaults and clamping
     const baseOpacity = isOverLight ? Math.min(0.6, Math.max(0.2, 0.5 * hoverIntensity * activeIntensity)) : 0;
-    
+
     const baseConfig = {
       isOverLight,
       threshold: 0.7,
@@ -763,14 +946,14 @@ export function useAtomixGlass({
 
     if (typeof overLight === 'object' && overLight !== null) {
       const objConfig = overLight as OverLightObjectConfig;
-      
+
       // Validate and apply object config values with proper clamping
       const validatedThreshold = validateConfigValue(objConfig.threshold, 0.1, 1.0, baseConfig.threshold);
       const validatedOpacity = validateConfigValue(objConfig.opacity, 0.1, 1.0, baseConfig.opacity);
       const validatedContrast = validateConfigValue(objConfig.contrast, 0.5, 2.5, baseConfig.contrast);
       const validatedBrightness = validateConfigValue(objConfig.brightness, 0.5, 2.0, baseConfig.brightness);
       const validatedSaturationBoost = validateConfigValue(objConfig.saturationBoost, 0.5, 3.0, baseConfig.saturationBoost);
-      
+
       const finalConfig = {
         ...baseConfig,
         threshold: validatedThreshold,
@@ -779,9 +962,9 @@ export function useAtomixGlass({
         brightness: validatedBrightness + mouseInfluence * 0.15,
         saturationBoost: validatedSaturationBoost + mouseInfluence * 0.4,
       };
-      
+
       // Debug logging
-      if (debugOverLight) {
+      if (process.env.NODE_ENV !== 'production' && debugOverLight) {
         console.log('[AtomixGlass] OverLight Config:', {
           isOverLight,
           config: {
@@ -808,12 +991,12 @@ export function useAtomixGlass({
           timestamp: new Date().toISOString(),
         });
       }
-      
+
       return finalConfig;
     }
 
     // Debug logging for non-object configs
-    if (debugOverLight) {
+    if (process.env.NODE_ENV !== 'production' && debugOverLight) {
       console.log('[AtomixGlass] OverLight Config:', {
         isOverLight,
         configType: typeof overLight === 'boolean' ? (overLight ? 'true' : 'false') : overLight,
@@ -854,6 +1037,12 @@ export function useAtomixGlass({
     [onClick]
   );
 
+  // No-op handler for backward compatibility (mouse tracking now handled by shared tracker)
+  const handleMouseMove = useCallback((_e: MouseEvent) => {
+    // Mouse tracking is now handled by shared global tracker
+    // This handler is kept for backward compatibility with existing code
+  }, []);
+
   return {
     // State
     isHovered,
@@ -885,4 +1074,3 @@ export function useAtomixGlass({
     handleKeyDown,
   };
 }
-