@fountain-ui/lab 2.0.0-beta.8 → 2.0.0-beta.81

package/src/ViewPager/utils.tsx

@@ -1,62 +1,15 @@
-import React from 'react';
-import ViewPagerProps, { Loading, PageComponent } from './ViewPagerProps';
-import ChildrenMemoizedPage from './ChildrenMemoizedPage';
+import type { EqualityFunction, Loading } from './types';
 
-export interface PageState {
-    visited?: boolean;
-}
-
-export interface PageRenderOption {
-    enableVisibleHint: boolean;
-    enableNeighborPageRerender: boolean;
-    index: number;
-    loading: Loading;
-    pageComponent: PageComponent;
-    pageForceRerenderKey?: any;
-}
-
-export interface PageRenderer {
-    (children: ViewPagerProps['children']): React.ReactNode;
-}
-
-export const defaultEnableVisibleHint: boolean = false;
-
-export const defaultEnableNeighborPageRerender: boolean = false;
+export const defaultInitialPage: number = 0;
 
 export const defaultLoading: Loading = 'lazy';
 
-export const defaultPageComponent: PageComponent = ChildrenMemoizedPage;
-
-export const usePageRenderer = ({
-    enableVisibleHint,
-    index: currentIndex,
-    loading,
-    pageComponent: PageComponent,
-    pageForceRerenderKey,
-    enableNeighborPageRerender,
-}: PageRenderOption): PageRenderer => {
-    const pagesStateRef = React.useRef<Array<PageState>>([]);
-
-    pagesStateRef.current[currentIndex] = {
-        ...pagesStateRef.current[currentIndex],
-        visited: true,
-    };
+export const defaultOffscreenPageRerenderLimit: number = 0;
 
-    return (children => React.Children.map(children, (child, index) => {
-        const visited = pagesStateRef.current[index]?.visited ?? false;
-        const content = (loading === 'eager' || visited) ? child : null;
+export const refEqual: EqualityFunction<any> = (a: any, b: any) => a === b;
 
-        const isVisible = enableVisibleHint ? (index === currentIndex) : false;
-        const isNeighborIndex = index === currentIndex - 1 || index === currentIndex + 1;
-
-        return (
-            <PageComponent
-                key={index}
-                children={content}
-                isNeighbor={enableNeighborPageRerender && isNeighborIndex}
-                isVisible={isVisible}
-                rerenderKey={pageForceRerenderKey}
-            />
-        );
-    }));
-};
+export function isValidPage(maybePage: number, numberOfPages: number) {
+    return Number.isInteger(maybePage)
+        && maybePage >= 0
+        && maybePage < numberOfPages;
+}

package/src/ViewabilityTrackerView/Viewability.ts

@@ -0,0 +1,3 @@
+export default interface Viewability {
+    visible: boolean;
+}

package/src/ViewabilityTrackerView/ViewabilityTrackerView.tsx

@@ -0,0 +1,33 @@
+import React, { useRef } from 'react';
+import { View } from 'react-native';
+import useViewabilityTracker from './useViewabilityTracker';
+import type ViewabilityTrackerViewProps from './ViewabilityTrackerViewProps';
+
+
+export default function ViewabilityTrackerView(props: ViewabilityTrackerViewProps) {
+    const {
+        enabled = true,
+        measurementIntervalMillis = 1000,
+        onViewabilityChange,
+        visiblePercentThreshold = 50,
+        ...otherProps
+    } = props;
+
+    const viewRef = useRef<View>(null);
+
+    useViewabilityTracker({
+        enabled,
+        measurementIntervalMillis,
+        onViewabilityChange,
+        viewRef,
+        visiblePercentThreshold,
+    });
+
+    return (
+        <View
+            {...otherProps}
+            ref={viewRef}
+            collapsable={false}
+        />
+    );
+};

package/src/ViewabilityTrackerView/ViewabilityTrackerViewProps.ts

@@ -0,0 +1,25 @@
+import type { ViewProps } from 'react-native';
+import type { OverridableComponentProps } from '@fountain-ui/core';
+import type Viewability from './Viewability';
+
+export default interface ViewabilityTrackerViewProps extends OverridableComponentProps<ViewProps, {
+    /**
+     * @default true
+     */
+    enabled?: boolean;
+
+    /**
+     * @default 1000
+     */
+    measurementIntervalMillis?: number;
+
+    /**
+     *
+     */
+    onViewabilityChange?: (viewability: Viewability) => void;
+
+    /**
+     * @default 50
+     */
+    visiblePercentThreshold?: number;
+}> {}

package/src/ViewabilityTrackerView/index.ts

@@ -0,0 +1,2 @@
+export { default } from './ViewabilityTrackerView';
+export type { default as ViewabilityTrackerViewProps } from './ViewabilityTrackerViewProps';

package/src/ViewabilityTrackerView/measureViewability.ts

@@ -0,0 +1,54 @@
+import type { View } from 'react-native';
+import { clamp } from '@fountain-ui/utils';
+
+interface Rect {
+    top: number,
+    bottom: number;
+    left: number;
+    right: number;
+}
+
+export interface ViewabilityDetail {
+    visiblePercent: number;
+}
+
+export interface MeasureViewabilityParameters {
+    view: View;
+    windowWidth: number;
+    windowHeight: number;
+    onViewabilityDetailMeasured: (detail: ViewabilityDetail) => void;
+}
+
+const computeRectSize = (rect: Rect): number =>
+    (rect.bottom - rect.top) * (rect.right - rect.left);
+
+const normalizePagePosition = (value?: number): number =>
+    (value != null && Number.isFinite(value)) ? value : Number.MAX_SAFE_INTEGER;
+
+const normalizeViewSize = (size: number): number =>
+    Number.isFinite(size) && size > 0 ? size : Number.MAX_SAFE_INTEGER;
+
+export default function measureViewability({
+    view,
+    windowWidth,
+    windowHeight,
+    onViewabilityDetailMeasured,
+}: MeasureViewabilityParameters) {
+    view.measure((x, y, width, height, pageX?: number, pageY?: number) => {
+        const safePageX = normalizePagePosition(pageX);
+        const safePageY = normalizePagePosition(pageY);
+
+        const visibleRect: Rect = {
+            top: clamp(safePageY, 0, windowHeight),
+            bottom: clamp(safePageY + height, 0, windowHeight),
+            left: clamp(safePageX, 0, windowWidth),
+            right: clamp(safePageX + width, 0, windowWidth),
+        };
+
+        const visibleRectSize = computeRectSize(visibleRect);
+        const viewSize = normalizeViewSize(width * height);
+        const visiblePercent = Math.round(visibleRectSize / viewSize * 100);
+
+        onViewabilityDetailMeasured?.({ visiblePercent });
+    });
+};

package/src/ViewabilityTrackerView/useViewabilityTracker.ts

@@ -0,0 +1,85 @@
+import type { RefObject } from 'react';
+import { useEffect, useRef } from 'react';
+import type { View } from 'react-native';
+import { useValidWindowDimensions } from '@fountain-ui/core';
+import { useDeferredExecutor } from '../hooks';
+import type { ViewabilityDetail } from './measureViewability';
+import measureViewability from './measureViewability';
+import type Viewability from './Viewability';
+
+export interface ViewabilityTrackerConfig {
+    enabled: boolean;
+    measurementIntervalMillis: number;
+    onViewabilityChange?: (viewability: Viewability) => void;
+    viewRef: RefObject<View>;
+    visiblePercentThreshold: number;
+}
+
+const initialViewability: Readonly<Viewability> = { visible: false };
+
+export default function useViewabilityTracker(config: ViewabilityTrackerConfig) {
+    const {
+        enabled,
+        measurementIntervalMillis,
+        onViewabilityChange,
+        viewRef,
+        visiblePercentThreshold,
+    } = config;
+
+    const viewabilityRef = useRef<Viewability>(initialViewability);
+
+    const executor = useDeferredExecutor();
+
+    const window = useValidWindowDimensions();
+
+    const maybeMeasureRecursive = () => {
+        if (!enabled) {
+            return;
+        }
+
+        const mapViewabilityDetailToViewability = (detail: ViewabilityDetail): Viewability => {
+            return { visible: detail.visiblePercent >= visiblePercentThreshold };
+        };
+
+        const isViewabilityEquals = (a: Viewability, b: Viewability): boolean => {
+            return a.visible === b.visible;
+        };
+
+        const dispatchViewabilityChanged = (viewability: Viewability) => {
+            executor.execute(() => onViewabilityChange?.(viewability));
+        };
+
+        const onViewabilityDetailMeasured = (detail: ViewabilityDetail) => {
+            const nextViewability = mapViewabilityDetailToViewability(detail);
+
+            if (!isViewabilityEquals(viewabilityRef.current, nextViewability)) {
+                viewabilityRef.current = nextViewability;
+
+                dispatchViewabilityChanged(nextViewability);
+            }
+
+            maybeMeasureRecursive();
+        };
+
+        const maybeMeasure = () => {
+            if (viewRef.current) {
+                measureViewability({
+                    view: viewRef.current,
+                    windowWidth: window.width,
+                    windowHeight: window.height,
+                    onViewabilityDetailMeasured,
+                });
+            }
+        };
+
+        executor.execute(maybeMeasure, measurementIntervalMillis);
+    };
+
+    useEffect(() => {
+        if (enabled) {
+            maybeMeasureRecursive();
+        } else {
+            executor.cancel();
+        }
+    }, [enabled]);
+};

package/src/hooks/index.ts

@@ -1,3 +1,5 @@
+export { default as useDeferredExecutor } from './useDeferredExecutor';
+export { default as useIsMounted } from './useIsMounted';
 export { default as useUnstableCollapsibleAppBar } from './useUnstableCollapsibleAppBar';
 export { default as useUnstableToggleDisplayStyle } from './useUnstableToggleDisplayStyle';
 

package/src/hooks/useDeferredExecutor.ts

@@ -0,0 +1,46 @@
+import { useCallback, useEffect, useRef } from 'react';
+import useIsMounted from './useIsMounted';
+
+export interface Runnable {
+    (): void;
+}
+
+export interface DeferredExecute {
+    (runnable: Runnable, delay?: number): void;
+}
+
+export interface DeferredExecutor {
+    cancel: () => void;
+    execute: DeferredExecute;
+}
+
+export default function useDeferredExecutor(): DeferredExecutor {
+    const isMounted = useIsMounted();
+    const timeoutIdRef = useRef<NodeJS.Timer | null>(null);
+
+    const cancel = useCallback(() => {
+        if (timeoutIdRef.current) {
+            clearTimeout(timeoutIdRef.current);
+        }
+    }, []);
+
+    useEffect(() => {
+        return cancel;
+    }, []);
+
+    const execute = useCallback<DeferredExecute>((runnable, delay) => {
+        if (!isMounted()) {
+            return;
+        }
+
+        cancel();
+
+        if (Number.isFinite(delay)) {
+            timeoutIdRef.current = setTimeout(() => runnable(), delay);
+        } else {
+            runnable();
+        }
+    }, []);
+
+    return { cancel, execute };
+};

package/src/hooks/useHeight.ts

@@ -1,13 +1,12 @@
-import React from 'react';
-import { ViewProps } from 'react-native';
-import { useWorkletCallback } from 'react-native-reanimated';
+import React, { useCallback } from 'react';
+import { LayoutChangeEvent, ViewProps } from 'react-native';
 
 type OnLayoutCallback = ViewProps['onLayout'];
 
 export default function useHeight(initialHeight = 0): [number, OnLayoutCallback] {
     const [height, setHeight] = React.useState<number>(initialHeight);
 
-    const onLayout = useWorkletCallback((e) => {
+    const onLayout = useCallback((e: LayoutChangeEvent) => {
         setHeight(e.nativeEvent.layout.height);
     }, []);
 

package/src/hooks/useIsMounted.ts

@@ -0,0 +1,19 @@
+import { useCallback, useEffect, useRef } from 'react';
+
+export interface UseIsMounted {
+    (): boolean;
+}
+
+export default function useIsMounted(): UseIsMounted {
+    const mountedRef = useRef<boolean>(false);
+
+    useEffect(() => {
+        mountedRef.current = true;
+
+        return () => {
+            mountedRef.current = false;
+        };
+    }, []);
+
+    return useCallback(() => mountedRef.current, []);
+};

package/src/hooks/useUnstableCollapsibleAppBar.ts

@@ -1,4 +1,4 @@
-import React, { useRef } from 'react';
+import { useCallback, useRef } from 'react';
 import { Falsy, Platform, RegisteredStyle, ScrollViewProps, ViewProps, ViewStyle } from 'react-native';
 import type { SharedValue } from 'react-native-reanimated';
 import {
@@ -50,7 +50,6 @@ const ANIMATION_DURATION_MILLIS = 100;
 
 const SUPPORTS_DRAG_DETECTION = Platform.OS !== 'web';
 
-
 function useLargerValueOfLastTwoValues(value: number) {
     const refLatestTwoValues = useRef([0, 0]);
 
@@ -60,7 +59,6 @@ function useLargerValueOfLastTwoValues(value: number) {
     return Math.max(...refLatestTwoValues.current);
 }
 
-
 export default function useUnstableCollapsibleAppBar(userOptions: Options = defaultOptions): CollapsibleAppBar {
     const { shouldTranslateYReset }: Required<Options> = {
         ...defaultOptions,
@@ -75,7 +73,7 @@ export default function useUnstableCollapsibleAppBar(userOptions: Options = defa
     const appBarMaxHeight = useLargerValueOfLastTwoValues(appBarHeight);
     const [collapsibleToolbarHeight, onCollapsibleToolbarLayout] = useHeight();
 
-    const maxTranslateY = useDerivedValue(() => -collapsibleToolbarHeight);
+    const maxTranslateY = useDerivedValue(() => -collapsibleToolbarHeight, [collapsibleToolbarHeight]);
 
     const translateY = useSharedValue<number>(0);
     const lastTranslateY = useSharedValue<number>(0);
@@ -86,21 +84,23 @@ export default function useUnstableCollapsibleAppBar(userOptions: Options = defa
 
     const elevationStyle = useElevationStyle(4);
     const animatedStyle = useAnimatedStyle(() => {
+        const transform = [{ translateY: translateY.value }];
+
         if (Platform.OS === 'web') {
             return {
-                transform: [{ translateY: translateY.value }],
+                transform,
                 boxShadow: overlapped.value ? elevationStyle?.boxShadow : 0,
             };
         }
         if (Platform.OS === 'android') {
             return {
-                transform: [{ translateY: translateY.value }],
+                transform,
                 elevation: overlapped.value ? elevationStyle?.elevation : 0,
             };
         }
         if (Platform.OS === 'ios') {
             return {
-                transform: [{ translateY: translateY.value }],
+                transform,
                 shadowColor: elevationStyle?.shadowColor,
                 shadowOffset: elevationStyle?.shadowOffset,
                 shadowRadius: elevationStyle?.shadowRadius,
@@ -108,12 +108,16 @@ export default function useUnstableCollapsibleAppBar(userOptions: Options = defa
             };
         }
         return {};
-    });
+    }, [
+        /**
+         * FIXME: Consider add `elevationStyle` to dependencies.
+         */
+    ]);
 
-    const indexRef = React.useRef<number>(0);
-    const offsetsRef = React.useRef<Array<number>>([]);
+    const indexRef = useRef<number>(0);
+    const offsetsRef = useRef<Array<number>>([]);
 
-    const onScrollViewChanged = (nextIndex: number) => {
+    const onScrollViewChanged = useCallback((nextIndex: number) => {
         const prevIndex = indexRef.current;
         if (prevIndex === nextIndex) {
             if (shouldTranslateYReset) {
@@ -147,7 +151,7 @@ export default function useUnstableCollapsibleAppBar(userOptions: Options = defa
 
             vectorY.value = 0;
         }
-    };
+    }, [appBarHeight]);
 
     const scrollHandler = useAnimatedScrollHandler({
         onBeginDrag: () => {
@@ -218,7 +222,7 @@ export default function useUnstableCollapsibleAppBar(userOptions: Options = defa
                 duration: ANIMATION_DURATION_MILLIS,
             });
         },
-    });
+    }, [appBarHeight]);
 
     const hasCollapsible = collapsibleToolbarHeight > 0;
 

package/src/hooks/useUnstableToggleDisplayStyle.ts

@@ -17,9 +17,10 @@ export default function useAnimatedDisplayStyle(
                 display.value = 'flex';
             }
         },
+        [threshold],
     );
 
     return useAnimatedStyle(() => ({
         display: display.value,
-    }));
+    }), []);
 };

package/src/index.ts

@@ -19,4 +19,7 @@ export * from './ComicViewer';
 export { default as StatusBarProvider, useStatusBarContext } from './StatusBarProvider';
 export * from './StatusBarProvider';
 
+export { default as ViewabilityTrackerView } from './ViewabilityTrackerView';
+export * from './ViewabilityTrackerView';
+
 export * from './hooks';

package/build/commonjs/Carousel/CarouselNative.js

@@ -1,72 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = Carousel;
-
-var _react = _interopRequireWildcard(require("react"));
-
-var _reactNative = require("react-native");
-
-var _reactNativeSnapCarousel = _interopRequireDefault(require("react-native-snap-carousel"));
-
-var _utils = require("./utils");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-function Carousel(props) {
-  const {
-    autoplay = _utils.defaultAutoplay,
-    autoplayInterval = _utils.defaultAutoplayInterval,
-    centerSlidePadding,
-    data,
-    inactiveSlideOpacity = _utils.defaultInactiveSlideOpacity,
-    inactiveSlideScale = _utils.defaultInactiveSlideScale,
-    index,
-    infinite = _utils.defaultInfinite,
-    onChange,
-    renderItem
-  } = props;
-  const carouselRef = (0, _react.useRef)(null);
-  const [sliderWidth, setSliderWidth] = (0, _react.useState)(() => _reactNative.Dimensions.get('window').width);
-  const itemWidth = centerSlidePadding !== undefined ? sliderWidth - centerSlidePadding * 2 : sliderWidth;
-  (0, _react.useEffect)(() => {
-    const carousel = carouselRef.current;
-
-    if (carousel && index !== carousel.currentIndex) {
-      carousel.snapToItem(index, true);
-    }
-  }, [index]);
-
-  const handleSnapToItem = newIndex => {
-    if (onChange) {
-      onChange(newIndex);
-    }
-  };
-
-  return /*#__PURE__*/_react.default.createElement(_reactNative.View, {
-    onLayout: event => setSliderWidth(event.nativeEvent.layout.width)
-  }, /*#__PURE__*/_react.default.createElement(_reactNativeSnapCarousel.default, {
-    autoplay: autoplay,
-    autoplayInterval: autoplayInterval,
-    data: data,
-    horizontal: true,
-    inactiveSlideOpacity: inactiveSlideOpacity,
-    inactiveSlideScale: inactiveSlideScale,
-    itemWidth: itemWidth,
-    loop: infinite,
-    loopClonesPerSide: 2,
-    onSnapToItem: handleSnapToItem,
-    ref: carouselRef,
-    renderItem: renderItem,
-    sliderWidth: sliderWidth
-  }));
-}
-
-;
-//# sourceMappingURL=CarouselNative.js.map

package/build/commonjs/Carousel/CarouselNative.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["Carousel","props","autoplay","defaultAutoplay","autoplayInterval","defaultAutoplayInterval","centerSlidePadding","data","inactiveSlideOpacity","defaultInactiveSlideOpacity","inactiveSlideScale","defaultInactiveSlideScale","index","infinite","defaultInfinite","onChange","renderItem","carouselRef","useRef","sliderWidth","setSliderWidth","useState","Dimensions","get","width","itemWidth","undefined","useEffect","carousel","current","currentIndex","snapToItem","handleSnapToItem","newIndex","event","nativeEvent","layout"],"sources":["CarouselNative.tsx"],"sourcesContent":["import React, { useEffect, useRef, useState } from 'react';\nimport { Dimensions, View } from 'react-native';\nimport RNSnapCarousel from 'react-native-snap-carousel';\nimport type CarouselProps from './CarouselProps';\nimport {\n    defaultAutoplay,\n    defaultAutoplayInterval,\n    defaultInactiveSlideOpacity,\n    defaultInactiveSlideScale,\n    defaultInfinite,\n} from './utils';\n\nexport default function Carousel<ItemT>(props: CarouselProps<ItemT>) {\n    const {\n        autoplay = defaultAutoplay,\n        autoplayInterval = defaultAutoplayInterval,\n        centerSlidePadding,\n        data,\n        inactiveSlideOpacity = defaultInactiveSlideOpacity,\n        inactiveSlideScale = defaultInactiveSlideScale,\n        index,\n        infinite = defaultInfinite,\n        onChange,\n        renderItem,\n    } = props;\n\n    const carouselRef = useRef<RNSnapCarousel<ItemT> | null>(null);\n\n    const [sliderWidth, setSliderWidth] = useState(() => Dimensions.get('window').width);\n\n    const itemWidth = centerSlidePadding !== undefined\n        ? sliderWidth - (centerSlidePadding * 2)\n        : sliderWidth;\n\n    useEffect(() => {\n        const carousel = carouselRef.current;\n        if (carousel && index !== carousel.currentIndex) {\n            carousel.snapToItem(index, true);\n        }\n    }, [index]);\n\n    const handleSnapToItem = (newIndex: number) => {\n        if (onChange) {\n            onChange(newIndex);\n        }\n    };\n\n    return (\n        <View onLayout={(event) => setSliderWidth(event.nativeEvent.layout.width)}>\n            <RNSnapCarousel\n                autoplay={autoplay}\n                autoplayInterval={autoplayInterval}\n                data={data}\n                horizontal={true}\n                inactiveSlideOpacity={inactiveSlideOpacity}\n                inactiveSlideScale={inactiveSlideScale}\n                itemWidth={itemWidth}\n                loop={infinite}\n                loopClonesPerSide={2}\n                onSnapToItem={handleSnapToItem}\n                ref={carouselRef}\n                renderItem={renderItem}\n                sliderWidth={sliderWidth}\n            />\n        </View>\n    );\n};\n"],"mappings":";;;;;;;AAAA;;AACA;;AACA;;AAEA;;;;;;;;AAQe,SAASA,QAAT,CAAyBC,KAAzB,EAAsD;EACjE,MAAM;IACFC,QAAQ,GAAGC,sBADT;IAEFC,gBAAgB,GAAGC,8BAFjB;IAGFC,kBAHE;IAIFC,IAJE;IAKFC,oBAAoB,GAAGC,kCALrB;IAMFC,kBAAkB,GAAGC,gCANnB;IAOFC,KAPE;IAQFC,QAAQ,GAAGC,sBART;IASFC,QATE;IAUFC;EAVE,IAWFf,KAXJ;EAaA,MAAMgB,WAAW,GAAG,IAAAC,aAAA,EAAqC,IAArC,CAApB;EAEA,MAAM,CAACC,WAAD,EAAcC,cAAd,IAAgC,IAAAC,eAAA,EAAS,MAAMC,uBAAA,CAAWC,GAAX,CAAe,QAAf,EAAyBC,KAAxC,CAAtC;EAEA,MAAMC,SAAS,GAAGnB,kBAAkB,KAAKoB,SAAvB,GACZP,WAAW,GAAIb,kBAAkB,GAAG,CADxB,GAEZa,WAFN;EAIA,IAAAQ,gBAAA,EAAU,MAAM;IACZ,MAAMC,QAAQ,GAAGX,WAAW,CAACY,OAA7B;;IACA,IAAID,QAAQ,IAAIhB,KAAK,KAAKgB,QAAQ,CAACE,YAAnC,EAAiD;MAC7CF,QAAQ,CAACG,UAAT,CAAoBnB,KAApB,EAA2B,IAA3B;IACH;EACJ,CALD,EAKG,CAACA,KAAD,CALH;;EAOA,MAAMoB,gBAAgB,GAAIC,QAAD,IAAsB;IAC3C,IAAIlB,QAAJ,EAAc;MACVA,QAAQ,CAACkB,QAAD,CAAR;IACH;EACJ,CAJD;;EAMA,oBACI,6BAAC,iBAAD;IAAM,QAAQ,EAAGC,KAAD,IAAWd,cAAc,CAACc,KAAK,CAACC,WAAN,CAAkBC,MAAlB,CAAyBZ,KAA1B;EAAzC,gBACI,6BAAC,gCAAD;IACI,QAAQ,EAAEtB,QADd;IAEI,gBAAgB,EAAEE,gBAFtB;IAGI,IAAI,EAAEG,IAHV;IAII,UAAU,EAAE,IAJhB;IAKI,oBAAoB,EAAEC,oBAL1B;IAMI,kBAAkB,EAAEE,kBANxB;IAOI,SAAS,EAAEe,SAPf;IAQI,IAAI,EAAEZ,QARV;IASI,iBAAiB,EAAE,CATvB;IAUI,YAAY,EAAEmB,gBAVlB;IAWI,GAAG,EAAEf,WAXT;IAYI,UAAU,EAAED,UAZhB;IAaI,WAAW,EAAEG;EAbjB,EADJ,CADJ;AAmBH;;AAAA"}