@fountain-ui/lab 2.0.0-beta.10 → 2.0.0-beta.13

package/src/ViewPager/ViewPagerProps.ts

@@ -1,41 +1,43 @@
-import React from 'react';
+import type { ComponentType, PropsWithChildren, ReactNode, Ref } from 'react';
 import type { ViewProps } from 'react-native';
+import type { SharedValue } from 'react-native-reanimated';
 import type { ComponentProps } from '@fountain-ui/core';
 
 export type KeyboardDismissMode = 'none' | 'on-drag';
 
-export type PageProps = React.PropsWithChildren<ViewProps> & {
-    isNeighbor: boolean;
-    isVisible: boolean;
-    rerenderKey?: any;
+export type PageProps = PropsWithChildren<ViewProps> & {
+    index: number;
+    loading: ViewPagerProps['loading'];
+    offscreenPageRerenderLimit: number;
+    sharedIndex: SharedValue<number>;
+    rerenderKey?: ViewPagerProps['pageForceRerenderKey'];
 };
 
-export type PageComponent = React.ComponentType<PageProps>;
+export type PageComponent = ComponentType<PageProps>;
 
 export type Loading = 'lazy' | 'eager';
 
-export default interface ViewPagerProps extends ComponentProps<{
+export interface ViewPagerInstance {
     /**
-     * Collection of ViewPager components.
+     * Function to scroll to a specific page in the ViewPager. Invalid index is ignored.
+     * @param index
      */
-    children?: React.ReactNode;
+    setPage: (index: number) => void;
+}
 
-    /**
-     * If `true`, enable page visible hint.
-     * @default false
-     */
-    enableVisibleHint?: boolean;
+export default interface ViewPagerProps extends ComponentProps<{
+    ref?: Ref<ViewPagerInstance>;
 
     /**
-     * If `true`, Based on the current index, the pages on the left and right are also rerender.
-     * @default false
+     * Collection of ViewPager components.
      */
-    enableNeighborPageRerender?: boolean;
+    children?: ReactNode;
 
     /**
-     * A number representing the index of the active page.
+     * Index of initial page that should be selected.
+     * @default 0
      */
-    index: number,
+    initialPage?: number;
 
     /**
      * Whether to load the page immediately (`eager`) or on an as-needed basis (`lazy`).
@@ -43,6 +45,13 @@ export default interface ViewPagerProps extends ComponentProps<{
      */
     loading?: Loading;
 
+    /**
+     * Mobile only. The number of pages that should be re-rendered to either side of the current page.
+     * Changing this value after the component mount has no effect.
+     * @default 0
+     */
+    offscreenPageRerenderLimit?: number;
+
     /**
      * Callback fired when an index is changed.
      */
@@ -70,4 +79,9 @@ export default interface ViewPagerProps extends ComponentProps<{
      * @default 'on-drag'
      */
     keyboardDismissMode?: KeyboardDismissMode;
+
+    /**
+     * Unstable API.
+     */
+    UNSTABLE_sharedPage?: SharedValue<number>;
 }> {}

package/src/ViewPager/ViewPagerWeb.tsx

@@ -1,13 +1,10 @@
-import React from 'react';
-import { StyleSheet, View } from 'react-native';
+import React, { Children, forwardRef, useCallback, useImperativeHandle } from 'react';
+import { View } from 'react-native';
+import { useSharedValue } from 'react-native-reanimated';
+import { StyleSheet } from '@fountain-ui/core';
 import type ViewPagerProps from './ViewPagerProps';
-import {
-    defaultEnableNeighborPageRerender,
-    defaultEnableVisibleHint,
-    defaultLoading,
-    defaultPageComponent,
-    usePageRenderer,
-} from './utils';
+import type { ViewPagerInstance } from './ViewPagerProps';
+import { defaultInitialPage, defaultLoading, defaultPageComponent } from './utils';
 
 const styles = StyleSheet.create({
     root: {
@@ -15,38 +12,50 @@ const styles = StyleSheet.create({
         overflow: 'auto',
         position: 'relative',
     },
-    none: { display: 'none' },
 });
 
-export default function ViewPager(props: ViewPagerProps) {
+const ViewPager = forwardRef<ViewPagerInstance, ViewPagerProps>(function ViewPager(props, ref) {
     const {
         children,
-        enableVisibleHint = defaultEnableVisibleHint,
-        enableNeighborPageRerender = defaultEnableNeighborPageRerender,
-        index,
+        initialPage = defaultInitialPage,
         loading = defaultLoading,
         pageComponent = defaultPageComponent,
         pageForceRerenderKey,
         style,
+        UNSTABLE_sharedPage,
     } = props;
 
-    const renderer = usePageRenderer({
-        enableVisibleHint,
-        enableNeighborPageRerender,
-        index,
-        loading,
-        pageComponent,
-        pageForceRerenderKey,
-    });
+    const fallbackSharedPage = useSharedValue<number>(initialPage);
+
+    const sharedPage = UNSTABLE_sharedPage ?? fallbackSharedPage;
+
+    const setPage = useCallback((newPage: number) => {
+        sharedPage.value = newPage;
+    }, [sharedPage]);
+
+    useImperativeHandle(
+        ref,
+        () => ({ setPage }),
+        [setPage],
+    );
+
+    const PageComponent = pageComponent;
 
     return (
         <View style={[styles.root, style]}>
-            {React.Children.map(renderer(children), (child, i) =>
-                React.cloneElement(child as React.ReactElement, {
-                    isVisible: i === index,
-                    style: i !== index ? styles.none : StyleSheet.absoluteFill,
-                }),
-            )}
+            {Children.map(children, (child, index) => (
+                <PageComponent
+                    key={index}
+                    children={child}
+                    index={index}
+                    loading={loading}
+                    offscreenPageRerenderLimit={0} // All offscreen pages will not be re-rendered
+                    rerenderKey={pageForceRerenderKey}
+                    sharedIndex={sharedPage}
+                />
+            ))}
         </View>
     );
-};
+});
+
+export default ViewPager;

package/src/ViewPager/index.native.ts

@@ -1 +1,2 @@
 export { default } from './ViewPagerNative';
+export { useViewPagerPageState } from './PageStateContext';

package/src/ViewPager/index.ts

@@ -1,2 +1,3 @@
 export { default } from './ViewPagerWeb';
-export type { default as ViewPagerProps } from './ViewPagerProps';
+export type { default as ViewPagerProps, ViewPagerInstance } from './ViewPagerProps';
+export { useViewPagerPageState } from './PageStateContext';

package/src/ViewPager/utils.tsx

@@ -1,62 +1,10 @@
-import React from 'react';
-import ViewPagerProps, { Loading, PageComponent } from './ViewPagerProps';
+import { Loading, PageComponent } from './ViewPagerProps';
 import ChildrenMemoizedPage from './ChildrenMemoizedPage';
 
-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,
-    };
-
-    return (children => React.Children.map(children, (child, index) => {
-        const visited = pagesStateRef.current[index]?.visited ?? false;
-        const content = (loading === 'eager' || visited) ? child : null;
+export const defaultOffscreenPageRerenderLimit: number = 0;
 
-        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 const defaultPageComponent: PageComponent = ChildrenMemoizedPage;

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,56 @@
+import type { View } from 'react-native';
+
+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;
+
+const clamp = (value: number, min: number, max: number): number =>
+    Math.min(Math.max(value, min), max);
+
+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/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/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"}