react-native-screen-transitions 3.4.0-alpha.6 → 3.4.0-beta.0

package/src/shared/utils/bounds/zoom/build.ts

@@ -1,4 +1,4 @@
-import { interpolate } from "react-native-reanimated";
+import { interpolate, makeMutable } from "react-native-reanimated";
 import {
 	EPSILON,
 	HIDDEN_STYLE,
@@ -17,6 +17,8 @@ import type { BoundsOptions } from "../types/options";
 import {
 	getZoomAnchor,
 	toNumber,
+	ZOOM_BACKGROUND_SCALE,
+	ZOOM_DRAG_DIRECTIONAL_SCALE_EXPONENT,
 	ZOOM_DRAG_DIRECTIONAL_SCALE_MAX,
 	ZOOM_DRAG_DIRECTIONAL_SCALE_MIN,
 	ZOOM_DRAG_RESISTANCE,
@@ -33,18 +35,22 @@ import {
 import type { BuildZoomStylesParams, ZoomInterpolatedStyle } from "./types";
 
 const IDENTITY_DRAG_SCALE_OUTPUT = [1, 1] as const;
+const UNFOCUSED_ENTER_FADE_END = 1.6;
+const presentedZoomTagByRoute = makeMutable<Record<string, string>>({});
 
-const getSourceBorderRadius = (
-	resolvedPair: ResolvedTransitionPair,
-): number => {
+/* -------------------------------------------------------------------------- */
+/*                               LOCAL HELPERS                                */
+/* -------------------------------------------------------------------------- */
+
+function getSourceBorderRadius(resolvedPair: ResolvedTransitionPair): number {
 	"worklet";
 
 	return typeof resolvedPair.sourceStyles?.borderRadius === "number"
 		? resolvedPair.sourceStyles.borderRadius
 		: 0;
-};
+}
 
-const getZoomContentTarget = ({
+function getZoomContentTarget({
 	explicitTarget,
 	screenLayout,
 	anchor,
@@ -54,7 +60,7 @@ const getZoomContentTarget = ({
 	screenLayout: Layout;
 	anchor: BoundsOptions["anchor"] | undefined;
 	resolvedPair: ResolvedTransitionPair;
-}) => {
+}) {
 	"worklet";
 
 	if (explicitTarget) return explicitTarget;
@@ -90,71 +96,183 @@ const getZoomContentTarget = ({
 		width: screenWidth,
 		height,
 	};
-};
+}
+
+function resolveDragScaleTuple(
+	value:
+		| readonly [shrinkMin: number, growMax: number, exponent?: number]
+		| undefined,
+) {
+	"worklet";
+
+	return {
+		shrinkMin: value?.[0] ?? ZOOM_DRAG_DIRECTIONAL_SCALE_MIN,
+		growMax: value?.[1] ?? ZOOM_DRAG_DIRECTIONAL_SCALE_MAX,
+		exponent: value?.[2] ?? ZOOM_DRAG_DIRECTIONAL_SCALE_EXPONENT,
+	};
+}
+
+function resolveBackgroundScale(value: number | undefined) {
+	"worklet";
+
+	return value ?? ZOOM_BACKGROUND_SCALE;
+}
+
+function resolveEffectiveZoomTag(params: {
+	resolvedTag: string;
+	activeRouteKey?: string;
+	entering: boolean;
+	animating: boolean;
+	activeProgress: number;
+	livePairReady: boolean;
+}) {
+	"worklet";
+
+	const {
+		resolvedTag,
+		activeRouteKey,
+		entering,
+		animating,
+		activeProgress,
+		livePairReady,
+	} = params;
+
+	// Only grouped ids need retarget stabilization. Plain ids should keep their
+	// normal behavior with no route-level caching.
+	if (!activeRouteKey || !resolvedTag.includes(":")) {
+		return resolvedTag;
+	}
+
+	const cachedTag = presentedZoomTagByRoute.value[activeRouteKey];
+	const isFreshOpenFrame = entering && activeProgress <= 0.05;
+	const shouldFreezeDuringEnter = entering && animating && !isFreshOpenFrame;
 
-export const buildZoomStyles = ({
+	if (!cachedTag || isFreshOpenFrame) {
+		presentedZoomTagByRoute.modify((state) => ({
+			...state,
+			[activeRouteKey]: resolvedTag,
+		}));
+		return resolvedTag;
+	}
+
+	if (shouldFreezeDuringEnter) {
+		return cachedTag;
+	}
+
+	// After the enter animation, grouped retargeting can still briefly point at a
+	// new active id before that tag has usable bounds. Keep presenting the last
+	// good tag until the next one is transition-ready.
+	if (cachedTag !== resolvedTag && !livePairReady) {
+		return cachedTag;
+	}
+
+	if (cachedTag !== resolvedTag) {
+		presentedZoomTagByRoute.modify((state) => ({
+			...state,
+			[activeRouteKey]: resolvedTag,
+		}));
+	}
+
+	return resolvedTag;
+}
+
+/* -------------------------------------------------------------------------- */
+/*                             BUILD ZOOM STYLES                              */
+/* -------------------------------------------------------------------------- */
+
+export function buildZoomStyles({
 	resolvedTag,
 	zoomOptions,
 	props,
-}: BuildZoomStylesParams): ZoomInterpolatedStyle => {
+}: BuildZoomStylesParams): ZoomInterpolatedStyle {
 	"worklet";
 
 	if (!resolvedTag) return {};
 
-	const explicitTarget = zoomOptions?.target;
-	const debug = zoomOptions?.DEBUG === true;
+	/* ------------------------------ Shared Setup ------------------------------ */
 
+	const explicitTarget = zoomOptions?.target;
 	const focused = props.focused;
 	const progress = props.progress;
+	const screenLayout = props.layouts.screen;
+	const isEnteringTransition = !props.next;
+	const activeRouteKey = props.active.route.key;
 	const currentRouteKey = props.current?.route.key;
 	const previousRouteKey = props.previous?.route.key;
 	const nextRouteKey = props.next?.route.key;
-	const entering = !props.next;
-	const screenLayout = props.layouts.screen;
 	const resolvedZoomAnchor = getZoomAnchor(explicitTarget);
+	const liveResolvedPair = BoundStore.resolveTransitionPair(resolvedTag, {
+		currentScreenKey: currentRouteKey,
+		previousScreenKey: previousRouteKey,
+		nextScreenKey: nextRouteKey,
+		entering: isEnteringTransition,
+	});
+	const effectiveTag = resolveEffectiveZoomTag({
+		resolvedTag,
+		activeRouteKey,
+		entering: !!props.active.entering,
+		animating: !!props.active.animating,
+		activeProgress: props.active.progress,
+		livePairReady: !!liveResolvedPair.sourceBounds,
+	});
+
 	const zoomComputeParams = {
-		id: resolvedTag,
+		id: effectiveTag,
 		previous: props.previous,
 		current: props.current,
 		next: props.next,
 		progress,
 		dimensions: screenLayout,
 	} as const;
+
 	const baseRawOptions = {
-		id: resolvedTag,
+		id: effectiveTag,
 		raw: true,
 		scaleMode: ZOOM_SHARED_OPTIONS.scaleMode,
 	} as const;
 
-	const resolvedPair = BoundStore.resolveTransitionPair(resolvedTag, {
-		currentScreenKey: currentRouteKey,
-		previousScreenKey: previousRouteKey,
-		nextScreenKey: nextRouteKey,
-		entering,
-	});
+	const resolvedPair =
+		effectiveTag === resolvedTag
+			? liveResolvedPair
+			: BoundStore.resolveTransitionPair(effectiveTag, {
+					currentScreenKey: currentRouteKey,
+					previousScreenKey: previousRouteKey,
+					nextScreenKey: nextRouteKey,
+					entering: isEnteringTransition,
+				});
 
 	const sourceBorderRadius = getSourceBorderRadius(resolvedPair);
 	const targetBorderRadius = zoomOptions?.borderRadius ?? sourceBorderRadius;
-
-	const focusedVisibilityStyles = {
-		[resolvedTag]: VISIBLE_STYLE,
+	const sourceVisibilityStyle = {
+		[effectiveTag]: VISIBLE_STYLE,
 	} satisfies TransitionInterpolatedStyle;
-	const focusedContainerStyleId = props.navigationMaskEnabled
+	const focusedContentSlot = props.navigationMaskEnabled
 		? NAVIGATION_MASK_CONTAINER_STYLE_ID
 		: "content";
 
-	// To avoid initial flickering, we'll want to hide if there are no source bounds
-	// But to also avoid scenarios where activeId changes in dst and theres a failed measurement,
-	// we should only hide if entering and there is no source bounds.
-	if (!resolvedPair.sourceBounds && props.active.entering) {
+	/* --------------------------- Missing Source Guard -------------------------- */
+
+	// Only the focused entering route should be hidden when source bounds are
+	// missing. During grouped retargeting, the unfocused/source route can still be
+	// styled by the destination interpolator while the new active member is warming
+	// up; hiding there blanks the wrong screen.
+	if (focused && !resolvedPair.sourceBounds && props.active.entering) {
 		return {
-			[focusedContainerStyleId]: HIDDEN_STYLE,
+			[focusedContentSlot]: HIDDEN_STYLE,
 		};
 	}
 
+	/* --------------------------- Gesture / Drag Values ------------------------- */
+
 	const normX = props.active.gesture.normX;
 	const normY = props.active.gesture.normY;
 	const initialDirection = props.active.gesture.direction;
+	const isHorizontalDismiss =
+		initialDirection === "horizontal" ||
+		initialDirection === "horizontal-inverted";
+	const isVerticalDismiss =
+		initialDirection === "vertical" || initialDirection === "vertical-inverted";
+
 	const dragX = normalizedToTranslation({
 		normalized: normX,
 		dimension: screenLayout.width,
@@ -165,35 +283,40 @@ export const buildZoomStyles = ({
 		dimension: screenLayout.height,
 		resistance: ZOOM_DRAG_RESISTANCE,
 	});
-	const dragXScale =
-		initialDirection === "horizontal" ||
-		initialDirection === "horizontal-inverted"
-			? resolveDirectionalDragScale({
-					normalized: normX,
-					dismissDirection:
-						initialDirection === "horizontal-inverted"
-							? "negative"
-							: "positive",
-					shrinkMin: ZOOM_DRAG_DIRECTIONAL_SCALE_MIN,
-					growMax: ZOOM_DRAG_DIRECTIONAL_SCALE_MAX,
-					exponent: 2,
-				})
-			: IDENTITY_DRAG_SCALE_OUTPUT[0];
-	const dragYScale =
-		initialDirection === "vertical" || initialDirection === "vertical-inverted"
-			? resolveDirectionalDragScale({
-					normalized: normY,
-					dismissDirection:
-						initialDirection === "vertical-inverted" ? "negative" : "positive",
-					shrinkMin: ZOOM_DRAG_DIRECTIONAL_SCALE_MIN,
-					growMax: ZOOM_DRAG_DIRECTIONAL_SCALE_MAX,
-					exponent: 2,
-				})
-			: IDENTITY_DRAG_SCALE_OUTPUT[1];
+	const horizontalDragScale = resolveDragScaleTuple(
+		zoomOptions?.horizontalDragScale,
+	);
+	const verticalDragScale = resolveDragScaleTuple(
+		zoomOptions?.verticalDragScale,
+	);
+	const backgroundScale = resolveBackgroundScale(zoomOptions?.backgroundScale);
+
+	const dragXScale = isHorizontalDismiss
+		? resolveDirectionalDragScale({
+				normalized: normX,
+				dismissDirection:
+					initialDirection === "horizontal-inverted" ? "negative" : "positive",
+				shrinkMin: horizontalDragScale.shrinkMin,
+				growMax: horizontalDragScale.growMax,
+				exponent: horizontalDragScale.exponent,
+			})
+		: IDENTITY_DRAG_SCALE_OUTPUT[0];
+	const dragYScale = isVerticalDismiss
+		? resolveDirectionalDragScale({
+				normalized: normY,
+				dismissDirection:
+					initialDirection === "vertical-inverted" ? "negative" : "positive",
+				shrinkMin: verticalDragScale.shrinkMin,
+				growMax: verticalDragScale.growMax,
+				exponent: verticalDragScale.exponent,
+			})
+		: IDENTITY_DRAG_SCALE_OUTPUT[1];
 	const dragScale = combineScales(dragXScale, dragYScale);
 
+	/* ----------------------------- Focused Screen ----------------------------- */
+
 	if (focused) {
-		const contentTarget = getZoomContentTarget({
+		const focusedContentTarget = getZoomContentTarget({
 			explicitTarget,
 			screenLayout,
 			anchor: ZOOM_SHARED_OPTIONS.anchor,
@@ -206,7 +329,7 @@ export const buildZoomStyles = ({
 				...baseRawOptions,
 				anchor: resolvedZoomAnchor,
 				method: "content",
-				target: contentTarget,
+				target: focusedContentTarget,
 			},
 			resolvedPair,
 		) as Record<string, unknown>;
@@ -224,8 +347,8 @@ export const buildZoomStyles = ({
 		) as Record<string, unknown>;
 
 		const focusedFade = props.active?.closing
-			? interpolate(progress, [0.6, 1], [0, debug ? 0.5 : 1], "clamp")
-			: interpolate(progress, [0, 0.5], [0, debug ? 0.5 : 1], "clamp");
+			? interpolate(progress, [0.6, 1], [0, 1], "clamp")
+			: interpolate(progress, [0, 0.5], [0, 1], "clamp");
 
 		/**
 		 * This is also how swiftui handles their navigation zoom.
@@ -247,6 +370,7 @@ export const buildZoomStyles = ({
 		const contentScale = toNumber(contentRaw.scale, 1) * dragScale;
 		const maskTranslateX = toNumber(maskRaw.translateX) + dragX - left;
 		const maskTranslateY = toNumber(maskRaw.translateY) + dragY - top;
+
 		const focusedContentStyle = {
 			opacity: focusedFade,
 			transform: [
@@ -259,10 +383,10 @@ export const buildZoomStyles = ({
 		};
 
 		const focusedStyles: ZoomInterpolatedStyle = {
-			[focusedContainerStyleId]: {
+			[focusedContentSlot]: {
 				style: focusedContentStyle,
 			},
-			...focusedVisibilityStyles,
+			...sourceVisibilityStyle,
 		};
 
 		if (props.navigationMaskEnabled) {
@@ -283,22 +407,32 @@ export const buildZoomStyles = ({
 		return focusedStyles;
 	}
 
-	const unfocusedFade = props.active?.closing
-		? interpolate(progress, [1.6, 2], [1, debug ? 1 : 0], "clamp")
-		: interpolate(progress, [1, 1.5], [1, debug ? 1 : 0], "clamp");
+	/* ---------------------------- Unfocused Screen ---------------------------- */
 
-	const unfocusedScale = interpolate(progress, [1, 2], [1, 0.95], "clamp");
+	const unfocusedFade = props.active?.closing
+		? interpolate(progress, [1.9, 2], [1, 0], "clamp")
+		: interpolate(progress, [1, 2], [1, 0], "clamp");
+	const unfocusedScale = interpolate(
+		progress,
+		[1, 2],
+		[1, backgroundScale],
+		"clamp",
+	);
 	const isUnfocusedIdle = props.active.settled === 1;
-	const shouldHideUnfocusedIdle = isUnfocusedIdle && !debug;
-	const elementTarget =
-		explicitTarget !== undefined || resolvedPair.destinationBounds
-			? getZoomContentTarget({
-					explicitTarget,
-					screenLayout,
-					anchor: ZOOM_SHARED_OPTIONS.anchor,
-					resolvedPair,
-				})
-			: ("fullscreen" as const);
+	const shouldHideUnfocusedIdle = isUnfocusedIdle;
+	const didSourceComponentVisiblyHide =
+		!props.active.closing && unfocusedFade <= EPSILON;
+
+	const shouldResetUnfocusedElement =
+		!props.active.closing &&
+		(props.active.logicallySettled || didSourceComponentVisiblyHide);
+
+	const unfocusedElementTarget = getZoomContentTarget({
+		explicitTarget,
+		screenLayout,
+		anchor: ZOOM_SHARED_OPTIONS.anchor,
+		resolvedPair,
+	});
 
 	const elementRaw = computeBoundStyles(
 		zoomComputeParams,
@@ -307,10 +441,11 @@ export const buildZoomStyles = ({
 			anchor: resolvedZoomAnchor,
 			method: "transform",
 			space: "relative",
-			target: elementTarget,
+			target: unfocusedElementTarget,
 		},
 		resolvedPair,
 	) as Record<string, unknown>;
+
 	const boundTargetCenterX =
 		explicitTarget === "bound" && resolvedPair.destinationBounds
 			? resolvedPair.destinationBounds.pageX +
@@ -321,16 +456,18 @@ export const buildZoomStyles = ({
 			? resolvedPair.destinationBounds.pageY +
 				resolvedPair.destinationBounds.height / 2
 			: undefined;
+
 	const elementCenterX =
 		boundTargetCenterX ??
-		(typeof elementTarget === "object"
-			? elementTarget.pageX + elementTarget.width / 2
+		(typeof unfocusedElementTarget === "object"
+			? unfocusedElementTarget.pageX + unfocusedElementTarget.width / 2
 			: screenLayout.width / 2);
 	const elementCenterY =
 		boundTargetCenterY ??
-		(typeof elementTarget === "object"
-			? elementTarget.pageY + elementTarget.height / 2
+		(typeof unfocusedElementTarget === "object"
+			? unfocusedElementTarget.pageY + unfocusedElementTarget.height / 2
 			: screenLayout.height / 2);
+
 	const scaleShiftX = computeCenterScaleShift({
 		center: elementCenterX,
 		containerCenter: screenLayout.width / 2,
@@ -341,6 +478,7 @@ export const buildZoomStyles = ({
 		containerCenter: screenLayout.height / 2,
 		scale: dragScale,
 	});
+
 	const compensatedGestureX = composeCompensatedTranslation({
 		gesture: dragX,
 		parentScale: unfocusedScale,
@@ -353,12 +491,14 @@ export const buildZoomStyles = ({
 		centerShift: scaleShiftY,
 		epsilon: EPSILON,
 	});
+
 	const elementTranslateX =
 		toNumber(elementRaw.translateX) + compensatedGestureX;
 	const elementTranslateY =
 		toNumber(elementRaw.translateY) + compensatedGestureY;
 	const elementScaleX = toNumber(elementRaw.scaleX, 1) * dragScale;
 	const elementScaleY = toNumber(elementRaw.scaleY, 1) * dragScale;
+
 	const resolvedElementStyle = shouldHideUnfocusedIdle
 		? {
 				transform: [
@@ -374,31 +514,19 @@ export const buildZoomStyles = ({
 		: {
 				transform: [
 					{
-						translateX:
-							props.active.logicallySettled && !props.active.closing
-								? 0
-								: elementTranslateX,
+						translateX: shouldResetUnfocusedElement ? 0 : elementTranslateX,
 					},
 					{
-						translateY:
-							props.active.logicallySettled && !props.active.closing
-								? 0
-								: elementTranslateY,
+						translateY: shouldResetUnfocusedElement ? 0 : elementTranslateY,
 					},
 					{
-						scaleX:
-							props.active.logicallySettled && !props.active.closing
-								? 1
-								: elementScaleX,
+						scaleX: shouldResetUnfocusedElement ? 1 : elementScaleX,
 					},
 					{
-						scaleY:
-							props.active.logicallySettled && !props.active.closing
-								? 1
-								: elementScaleY,
+						scaleY: shouldResetUnfocusedElement ? 1 : elementScaleY,
 					},
 				],
-				opacity: debug ? 0.5 : unfocusedFade,
+				opacity: unfocusedFade,
 				zIndex: 9999,
 				elevation: 9999,
 			};
@@ -409,8 +537,8 @@ export const buildZoomStyles = ({
 				transform: [{ scale: unfocusedScale }],
 			},
 		},
-		[resolvedTag]: {
+		[effectiveTag]: {
 			style: resolvedElementStyle,
 		},
 	};
-};
+}

package/src/shared/utils/bounds/zoom/config.ts

@@ -8,6 +8,8 @@ export const ZOOM_SHARED_OPTIONS = Object.freeze({
 export const ZOOM_DRAG_RESISTANCE = 0.4;
 export const ZOOM_DRAG_DIRECTIONAL_SCALE_MIN = 0.25;
 export const ZOOM_DRAG_DIRECTIONAL_SCALE_MAX = 1.06;
+export const ZOOM_DRAG_DIRECTIONAL_SCALE_EXPONENT = 2;
+export const ZOOM_BACKGROUND_SCALE = 0.9375;
 
 export const ZOOM_MASK_OUTSET = Object.freeze({
 	top: 0,

package/lib/commonjs/shared/components/create-boundary-component/hooks/use-deferred-measurement-trigger.js

@@ -1,54 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useDeferredMeasurementTrigger = void 0;
-var _react = require("react");
-var _reactNativeReanimated = require("react-native-reanimated");
-const useDeferredMeasurementTrigger = params => {
-  const {
-    enabled,
-    isAnimating,
-    canFlush,
-    onFlush
-  } = params;
-  const hasPendingMeasurement = (0, _reactNativeReanimated.useSharedValue)(false);
-  const clearPendingMeasurement = (0, _react.useCallback)(() => {
-    "worklet";
-
-    hasPendingMeasurement.value = false;
-  }, [hasPendingMeasurement]);
-  const queueOrFlushMeasurement = (0, _react.useCallback)(() => {
-    "worklet";
-
-    if (!enabled) return;
-    if (isAnimating.value) {
-      hasPendingMeasurement.value = true;
-      return;
-    }
-    hasPendingMeasurement.value = false;
-    onFlush();
-  }, [enabled, isAnimating, hasPendingMeasurement, onFlush]);
-  (0, _reactNativeReanimated.useAnimatedReaction)(() => {
-    "worklet";
-
-    if (!enabled) return false;
-    if (!hasPendingMeasurement.value) return false;
-    if (isAnimating.value) return false;
-    return canFlush ? canFlush() : true;
-  }, (shouldFlush, previousShouldFlush) => {
-    "worklet";
-
-    if (!enabled) return;
-    if (!shouldFlush || shouldFlush === previousShouldFlush) return;
-    hasPendingMeasurement.value = false;
-    onFlush();
-  }, [enabled, isAnimating, hasPendingMeasurement, canFlush, onFlush]);
-  return {
-    clearPendingMeasurement,
-    queueOrFlushMeasurement
-  };
-};
-exports.useDeferredMeasurementTrigger = useDeferredMeasurementTrigger;
-//# sourceMappingURL=use-deferred-measurement-trigger.js.map

package/lib/commonjs/shared/components/create-boundary-component/hooks/use-deferred-measurement-trigger.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_react","require","_reactNativeReanimated","useDeferredMeasurementTrigger","params","enabled","isAnimating","canFlush","onFlush","hasPendingMeasurement","useSharedValue","clearPendingMeasurement","useCallback","value","queueOrFlushMeasurement","useAnimatedReaction","shouldFlush","previousShouldFlush","exports"],"sourceRoot":"../../../../../../src","sources":["shared/components/create-boundary-component/hooks/use-deferred-measurement-trigger.ts"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,sBAAA,GAAAD,OAAA;AAMO,MAAME,6BAA6B,GAAIC,MAK7C,IAAK;EACL,MAAM;IAAEC,OAAO;IAAEC,WAAW;IAAEC,QAAQ;IAAEC;EAAQ,CAAC,GAAGJ,MAAM;EAC1D,MAAMK,qBAAqB,GAAG,IAAAC,qCAAc,EAAC,KAAK,CAAC;EAEnD,MAAMC,uBAAuB,GAAG,IAAAC,kBAAW,EAAC,MAAM;IACjD,SAAS;;IACTH,qBAAqB,CAACI,KAAK,GAAG,KAAK;EACpC,CAAC,EAAE,CAACJ,qBAAqB,CAAC,CAAC;EAE3B,MAAMK,uBAAuB,GAAG,IAAAF,kBAAW,EAAC,MAAM;IACjD,SAAS;;IACT,IAAI,CAACP,OAAO,EAAE;IAEd,IAAIC,WAAW,CAACO,KAAK,EAAE;MACtBJ,qBAAqB,CAACI,KAAK,GAAG,IAAI;MAClC;IACD;IAEAJ,qBAAqB,CAACI,KAAK,GAAG,KAAK;IACnCL,OAAO,CAAC,CAAC;EACV,CAAC,EAAE,CAACH,OAAO,EAAEC,WAAW,EAAEG,qBAAqB,EAAED,OAAO,CAAC,CAAC;EAE1D,IAAAO,0CAAmB,EAClB,MAAM;IACL,SAAS;;IACT,IAAI,CAACV,OAAO,EAAE,OAAO,KAAK;IAC1B,IAAI,CAACI,qBAAqB,CAACI,KAAK,EAAE,OAAO,KAAK;IAC9C,IAAIP,WAAW,CAACO,KAAK,EAAE,OAAO,KAAK;IACnC,OAAON,QAAQ,GAAGA,QAAQ,CAAC,CAAC,GAAG,IAAI;EACpC,CAAC,EACD,CAACS,WAAW,EAAEC,mBAAmB,KAAK;IACrC,SAAS;;IACT,IAAI,CAACZ,OAAO,EAAE;IACd,IAAI,CAACW,WAAW,IAAIA,WAAW,KAAKC,mBAAmB,EAAE;IAEzDR,qBAAqB,CAACI,KAAK,GAAG,KAAK;IACnCL,OAAO,CAAC,CAAC;EACV,CAAC,EACD,CAACH,OAAO,EAAEC,WAAW,EAAEG,qBAAqB,EAAEF,QAAQ,EAAEC,OAAO,CAChE,CAAC;EAED,OAAO;IACNG,uBAAuB;IACvBG;EACD,CAAC;AACF,CAAC;AAACI,OAAA,CAAAf,6BAAA,GAAAA,6BAAA","ignoreList":[]}