app-studio 0.7.7 → 0.7.9

package/dist/app-studio.cjs.development.js

@@ -1066,12 +1066,15 @@ const deepMerge = (target, source) => {
   }
   return merged;
 };
+// Stable default references to prevent unnecessary re-renders and cache invalidation
+const DEFAULT_THEME_OVERRIDE = {};
+const DEFAULT_COLORS_OVERRIDE = {};
 const ThemeProvider = _ref => {
   let {
-    theme: themeOverride = {},
+    theme: themeOverride = DEFAULT_THEME_OVERRIDE,
     mode: initialMode = 'light',
-    dark: darkOverride = {},
-    light: lightOverride = {},
+    dark: darkOverride = DEFAULT_COLORS_OVERRIDE,
+    light: lightOverride = DEFAULT_COLORS_OVERRIDE,
     children,
     strict = false,
     targetWindow
@@ -2950,10 +2953,11 @@ const AnalyticsProvider = _ref => {
     trackEvent,
     children
   } = _ref;
+  const value = React.useMemo(() => ({
+    trackEvent
+  }), [trackEvent]);
   return /*#__PURE__*/React__default.createElement(AnalyticsContext.Provider, {
-    value: {
-      trackEvent
-    }
+    value: value
   }, children);
 };
 
@@ -2985,12 +2989,10 @@ function hashStyleProps(props) {
  */
 function useStableStyleMemo(propsToProcess, getColor, mediaQueries, devices, manager, theme) {
   const cacheRef = React.useRef(null);
-  // Compute hash of current props
-  const currentHash = React.useMemo(() => {
-    // Include theme in hash to bust cache on theme changes
-    const themeHash = theme ? JSON.stringify(theme) : '';
-    return hashStyleProps(propsToProcess) + '|' + hash(themeHash);
-  }, [propsToProcess, theme]);
+  // Compute hash directly — no useMemo since propsToProcess is always a new
+  // reference (from destructuring), so the memo deps would always change.
+  const themeHash = theme ? JSON.stringify(theme) : '';
+  const currentHash = hashStyleProps(propsToProcess) + '|' + hash(themeHash);
   // Only recompute classes if hash changed
   if (!cacheRef.current || cacheRef.current.hash !== currentHash) {
     const classes = extractUtilityClasses(propsToProcess, getColor, mediaQueries, devices, manager);
@@ -3082,44 +3084,44 @@ const Element = /*#__PURE__*/React__default.memo(/*#__PURE__*/React.forwardRef((
     };
   }, [animateOut, manager]);
   // Prepare props for processing (apply view/scroll timeline if needed)
-  const propsToProcess = React.useMemo(() => {
-    const processed = {
-      ...rest,
-      blend
-    };
-    // Apply view() timeline ONLY if animateOn='View' (not Both or Mount)
-    if (animateOn === 'View' && processed.animate) {
-      const animations = Array.isArray(processed.animate) ? processed.animate : [processed.animate];
-      processed.animate = animations.map(anim => {
-        // Only add timeline if not already specified
-        if (!anim.timeline) {
-          return {
-            ...anim,
-            timeline: 'view()',
-            range: anim.range || 'entry',
-            fillMode: anim.fillMode || 'both'
-          };
-        }
-        return anim;
-      });
-    }
-    // Apply scroll() timeline if animateOn='Scroll'
-    if (animateOn === 'Scroll' && processed.animate) {
-      const animations = Array.isArray(processed.animate) ? processed.animate : [processed.animate];
-      processed.animate = animations.map(anim => {
-        // Only add timeline if not already specified
-        if (!anim.timeline) {
-          return {
-            ...anim,
-            timeline: 'scroll()',
-            fillMode: anim.fillMode || 'both'
-          };
-        }
-        return anim;
-      });
-    }
-    return processed;
-  }, [rest, blend, animateOn]);
+  // No useMemo — `rest` is always a new reference from destructuring, so
+  // memo deps would always change. useStableStyleMemo handles the real
+  // memoization via hash-based comparison.
+  const propsToProcess = {
+    ...rest,
+    blend
+  };
+  // Apply view() timeline ONLY if animateOn='View' (not Both or Mount)
+  if (animateOn === 'View' && propsToProcess.animate) {
+    const animations = Array.isArray(propsToProcess.animate) ? propsToProcess.animate : [propsToProcess.animate];
+    propsToProcess.animate = animations.map(anim => {
+      // Only add timeline if not already specified
+      if (!anim.timeline) {
+        return {
+          ...anim,
+          timeline: 'view()',
+          range: anim.range || 'entry',
+          fillMode: anim.fillMode || 'both'
+        };
+      }
+      return anim;
+    });
+  }
+  // Apply scroll() timeline if animateOn='Scroll'
+  if (animateOn === 'Scroll' && propsToProcess.animate) {
+    const animations = Array.isArray(propsToProcess.animate) ? propsToProcess.animate : [propsToProcess.animate];
+    propsToProcess.animate = animations.map(anim => {
+      // Only add timeline if not already specified
+      if (!anim.timeline) {
+        return {
+          ...anim,
+          timeline: 'scroll()',
+          fillMode: anim.fillMode || 'both'
+        };
+      }
+      return anim;
+    });
+  }
   // Use hash-based memoization for style extraction
   const utilityClasses = useStableStyleMemo(propsToProcess, getColor, mediaQueries, devices, manager, theme);
   const newProps = {
@@ -5041,14 +5043,28 @@ const WindowSizeProvider = _ref => {
     width: win?.innerWidth || 0,
     height: win?.innerHeight || 0
   });
+  const timeoutRef = React.useRef();
   React.useEffect(() => {
     if (!win) return;
-    const handleResize = () => setSize({
-      width: win.innerWidth,
-      height: win.innerHeight
-    });
+    const handleResize = () => {
+      if (timeoutRef.current) clearTimeout(timeoutRef.current);
+      timeoutRef.current = setTimeout(() => {
+        const newWidth = win.innerWidth;
+        const newHeight = win.innerHeight;
+        setSize(prev => {
+          if (prev.width === newWidth && prev.height === newHeight) return prev;
+          return {
+            width: newWidth,
+            height: newHeight
+          };
+        });
+      }, 100);
+    };
     win.addEventListener('resize', handleResize);
-    return () => win.removeEventListener('resize', handleResize);
+    return () => {
+      win.removeEventListener('resize', handleResize);
+      if (timeoutRef.current) clearTimeout(timeoutRef.current);
+    };
   }, [win]);
   return /*#__PURE__*/React__default.createElement(WindowSizeContext.Provider, {
     value: size
@@ -5081,12 +5097,13 @@ function useActive() {
   return [ref, active];
 }
 
+const DEFAULT_CLICK_OUTSIDE_OPTIONS = {};
 function useClickOutside(options) {
   const [clickedOutside, setClickedOutside] = React.useState(false);
   const ref = React.useRef(null);
   const {
     targetWindow
-  } = options || {};
+  } = options || DEFAULT_CLICK_OUTSIDE_OPTIONS;
   React.useEffect(() => {
     const win = targetWindow || (typeof window !== 'undefined' ? window : null);
     if (!win) return;
@@ -5106,13 +5123,14 @@ function useClickOutside(options) {
   return [ref, clickedOutside];
 }
 
+const DEFAULT_ELEMENT_POSITION_OPTIONS = {};
 /**
  * A React hook to determine an element's relative position within the viewport
  * and where the most available space is around it within the viewport.
  */
 function useElementPosition(options) {
   if (options === void 0) {
-    options = {};
+    options = DEFAULT_ELEMENT_POSITION_OPTIONS;
   }
   const {
     trackChanges = true,
@@ -5284,18 +5302,21 @@ function useKeyPress(targetKey) {
 }
 
 const useMount = callback => {
+  const callbackRef = React.useRef(callback);
+  callbackRef.current = callback;
   React.useEffect(() => {
-    callback();
+    callbackRef.current();
   }, []);
 };
 
+const DEFAULT_ON_SCREEN_OPTIONS = {};
 function useOnScreen(options) {
   const ref = React.useRef(null);
   const [isOnScreen, setOnScreen] = React.useState(false);
   const {
     targetWindow,
     ...observerOptions
-  } = options || {};
+  } = options || DEFAULT_ON_SCREEN_OPTIONS;
   React.useEffect(() => {
     const node = ref.current;
     if (!node) return;
@@ -5314,7 +5335,7 @@ function useOnScreen(options) {
     return () => {
       observer.disconnect();
     };
-  }, [targetWindow, options]);
+  }, [targetWindow, observerOptions.root, observerOptions.rootMargin, observerOptions.threshold]);
   return [ref, isOnScreen];
 }
 
@@ -5339,14 +5360,14 @@ const useBreakpoint = () => {
     devices
   } = context;
   // Helper to check if current screen matches a breakpoint or device
-  const on = s => devices[s] ? devices[s].includes(screen) : s === screen;
-  return {
+  const on = React.useCallback(s => devices[s] ? devices[s].includes(screen) : s === screen, [devices, screen]);
+  return React.useMemo(() => ({
     ...context,
     screen,
     orientation,
     on,
     is: on
-  };
+  }), [context, screen, orientation, on]);
 };
 /**
  * Hook for components that need exact window dimensions.
@@ -5377,17 +5398,21 @@ const useResponsive = () => {
     orientation,
     devices
   } = context;
-  const on = s => devices[s] ? devices[s].includes(screen) : s === screen;
-  const result = {
+  const on = React.useCallback(s => devices[s] ? devices[s].includes(screen) : s === screen, [devices, screen]);
+  return React.useMemo(() => ({
     ...context,
     screen,
     orientation,
     on,
     is: on
-  };
-  return result;
+  }), [context, screen, orientation, on]);
 };
 
+// Stable default references to prevent unnecessary re-renders
+const DEFAULT_SCROLL_OFFSET = [0, 0];
+const DEFAULT_SCROLL_OPTIONS = {};
+const DEFAULT_SCROLL_ANIMATION_OPTIONS = {};
+const DEFAULT_INFINITE_SCROLL_OPTIONS = {};
 // Helper to check if element is a Window object (works across iframes)
 const isWindow = obj => {
   return obj && obj.window === obj;
@@ -5421,18 +5446,21 @@ const getScrollDimensions = element => {
 const useScroll = function (_temp) {
   let {
     container,
-    offset = [0, 0],
+    offset = DEFAULT_SCROLL_OFFSET,
     throttleMs = 100,
     disabled = false
-  } = _temp === void 0 ? {} : _temp;
+  } = _temp === void 0 ? DEFAULT_SCROLL_OPTIONS : _temp;
   const [scrollPosition, setScrollPosition] = React.useState({
     x: 0,
     y: 0,
     xProgress: 0,
-    yProgress: 0
+    yProgress: 0,
+    elementY: 0,
+    elementProgress: 0
   });
   const lastUpdateRef = React.useRef(0);
   const frameRef = React.useRef();
+  const ticking = React.useRef(false);
   // Resolve the window/document context. If the container is an iframe element, use its contentWindow.
   const getContext = React.useCallback(() => {
     const targetEl = container?.current ?? null;
@@ -5453,18 +5481,21 @@ const useScroll = function (_temp) {
       targetDocument
     };
   }, [container]);
-  const handleScroll = React.useCallback(() => {
-    if (disabled) return;
+  const updateScrollPosition = React.useCallback(() => {
     const {
       targetEl,
       targetWindow
     } = getContext();
     const hasScrollableElement = targetEl && isElementScrollable(targetEl);
     const scrollTarget = hasScrollableElement ? targetEl : targetWindow || targetEl;
-    if (!scrollTarget) return;
+    if (!scrollTarget) {
+      ticking.current = false;
+      return;
+    }
     const now = Date.now();
+    // Verify throttle constraints inside the RAF to skip frame if needed
     if (throttleMs > 0 && now - lastUpdateRef.current < throttleMs) {
-      frameRef.current = requestAnimationFrame(handleScroll);
+      ticking.current = false;
       return;
     }
     const dimensions = getScrollDimensions(scrollTarget);
@@ -5474,19 +5505,47 @@ const useScroll = function (_temp) {
     const maxScrollY = dimensions.scrollHeight - dimensions.clientHeight;
     const xProgress = maxScrollX <= 0 ? 1 : Math.min(Math.max(x / maxScrollX, 0), 1);
     const yProgress = maxScrollY <= 0 ? 1 : Math.min(Math.max(y / maxScrollY, 0), 1);
+    // Calculate element-specific stats if we are tracking a specific element container
+    // that is NOT the main scroller itself.
+    let elementY = 0;
+    let elementProgress = 0;
+    if (targetEl && targetEl !== scrollTarget) {
+      const rect = targetEl.getBoundingClientRect();
+      elementY = rect.top;
+      const viewportHeight = dimensions.clientHeight;
+      const scrollDistance = rect.height - viewportHeight;
+      if (scrollDistance > 0) {
+        // Calculate progress consistent with sticky scrolling behavior
+        // 0 when hitting top, 1 when finished scrolling
+        const scrolled = -rect.top;
+        elementProgress = Math.max(0, Math.min(1, scrolled / scrollDistance));
+      } else {
+        elementProgress = 0;
+      }
+    }
     setScrollPosition(prev => {
-      if (prev.x !== x || prev.y !== y || prev.xProgress !== xProgress || prev.yProgress !== yProgress) {
+      if (prev.elementProgress !== elementProgress || prev.y !== y || prev.x !== x || prev.yProgress !== yProgress) {
         lastUpdateRef.current = now;
         return {
           x,
           y,
           xProgress,
-          yProgress
+          yProgress,
+          elementY,
+          elementProgress
         };
       }
       return prev;
     });
-  }, [offset, throttleMs, disabled, getContext]);
+    ticking.current = false;
+  }, [offset, throttleMs, getContext]);
+  const handleScroll = React.useCallback(() => {
+    if (disabled) return;
+    if (!ticking.current) {
+      frameRef.current = requestAnimationFrame(updateScrollPosition);
+      ticking.current = true;
+    }
+  }, [disabled, updateScrollPosition]);
   React.useEffect(() => {
     if (disabled) return;
     const {
@@ -5498,7 +5557,7 @@ const useScroll = function (_temp) {
     const scrollTarget = hasScrollableElement ? targetEl : targetWindow || targetEl;
     if (!scrollTarget) return;
     // Initial scroll position
-    handleScroll();
+    updateScrollPosition();
     const options = {
       passive: true
     };
@@ -5521,14 +5580,15 @@ const useScroll = function (_temp) {
       if (frameRef.current) {
         cancelAnimationFrame(frameRef.current);
       }
+      ticking.current = false;
     };
-  }, [handleScroll, disabled, getContext]);
+  }, [handleScroll, disabled, getContext, updateScrollPosition]);
   return scrollPosition;
 };
 // Enhanced useScrollAnimation with callback support and iframe support
 const useScrollAnimation = function (ref, options) {
   if (options === void 0) {
-    options = {};
+    options = DEFAULT_SCROLL_ANIMATION_OPTIONS;
   }
   const [isInView, setIsInView] = React.useState(false);
   const [progress, setProgress] = React.useState(0);
@@ -5596,7 +5656,7 @@ const useSmoothScroll = targetWindow => {
 // Enhanced useInfiniteScroll with debouncing
 const useInfiniteScroll = function (callback, options) {
   if (options === void 0) {
-    options = {};
+    options = DEFAULT_INFINITE_SCROLL_OPTIONS;
   }
   const [sentinel, setSentinel] = React.useState(null);
   const callbackRef = React.useRef(callback);
@@ -5691,12 +5751,13 @@ const useScrollDirection = function (threshold, targetWindow) {
 
 const useWindowSize = () => React.useContext(WindowSizeContext);
 
+const DEFAULT_IN_VIEW_OPTIONS = {};
 function useInView(options) {
   const {
     triggerOnce = false,
     targetWindow,
     ...observerOptions
-  } = options || {};
+  } = options || DEFAULT_IN_VIEW_OPTIONS;
   const ref = React.useRef(null);
   const [inView, setInView] = React.useState(false);
   React.useEffect(() => {
@@ -5726,7 +5787,7 @@ function useInView(options) {
     return () => {
       observer.disconnect();
     };
-  }, [triggerOnce, targetWindow, ...Object.values(observerOptions || {})]);
+  }, [triggerOnce, targetWindow, observerOptions.root, observerOptions.rootMargin, observerOptions.threshold]);
   return {
     ref,
     inView
@@ -5811,7 +5872,7 @@ function useIframe(iframeRef) {
     if (!iframe) return;
     const updateState = () => {
       const win = iframe.contentWindow;
-      const doc = iframe.contentDocument || win?.document;
+      const doc = win?.document || iframe.contentDocument;
       if (win && doc) {
         setIframeWindow(win);
         setIframeDocument(doc);

package/dist/app-studio.cjs.development.js.map

@@ -1 +1 @@
-{"version":3,"file":"app-studio.cjs.development.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"app-studio.cjs.development.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}