react-native-screen-transitions 3.3.0 → 3.4.0-alpha.1

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

@@ -0,0 +1,179 @@
+import { BoundStore } from "../../../stores/bounds";
+import type { BoundsNavigationZoomOptions } from "../../../types/bounds.types";
+import type { BoundId, BoundsOptions } from "../types/options";
+import type { ResolveTag } from "./types";
+
+const DEFAULT_DRAG_RESISTANCE = 0.4;
+const DEFAULT_DRAG_DIRECTIONAL_SCALE_MIN = 0.25;
+const DEFAULT_DRAG_DIRECTIONAL_SCALE_MAX = 1.06;
+
+type ZoomMask = NonNullable<BoundsNavigationZoomOptions["mask"]>;
+type ZoomRadiusValue = Exclude<ZoomMask["borderRadius"], undefined>;
+type ZoomEdgeInsets = ZoomMask["outset"];
+
+const DEFAULT_MASK_BORDER_RADIUS: ZoomRadiusValue = 12;
+
+const ZERO_OUTSET = Object.freeze({
+	top: 0,
+	right: 0,
+	bottom: 0,
+	left: 0,
+});
+
+type ResolvedZoomOutset = {
+	top: number;
+	right: number;
+	bottom: number;
+	left: number;
+};
+
+export type ResolvedZoomOptions = {
+	mask: {
+		borderRadius: ZoomRadiusValue;
+		borderTopLeftRadius?: ZoomRadiusValue;
+		borderTopRightRadius?: ZoomRadiusValue;
+		borderBottomLeftRadius?: ZoomRadiusValue;
+		borderBottomRightRadius?: ZoomRadiusValue;
+		borderCurve?: "circular" | "continuous";
+		outset: ResolvedZoomOutset;
+	};
+	motion: {
+		dragResistance: number;
+		dragDirectionalScaleMin: number;
+		dragDirectionalScaleMax: number;
+	};
+};
+
+export const toNumber = (value: unknown, fallback = 0): number => {
+	"worklet";
+	return typeof value === "number" ? value : fallback;
+};
+
+const isFiniteNumber = (value: unknown): value is number => {
+	"worklet";
+	return typeof value === "number" && Number.isFinite(value);
+};
+
+const normalizeOutset = (value?: ZoomEdgeInsets): ResolvedZoomOutset => {
+	"worklet";
+	if (typeof value === "number") {
+		return {
+			top: value,
+			right: value,
+			bottom: value,
+			left: value,
+		};
+	}
+
+	if (!value) {
+		return ZERO_OUTSET;
+	}
+
+	return {
+		top: isFiniteNumber(value.top) ? value.top : 0,
+		right: isFiniteNumber(value.right) ? value.right : 0,
+		bottom: isFiniteNumber(value.bottom) ? value.bottom : 0,
+		left: isFiniteNumber(value.left) ? value.left : 0,
+	};
+};
+
+const normalizeZoomOptions = (
+	zoomOptions?: BoundsNavigationZoomOptions,
+): ResolvedZoomOptions => {
+	"worklet";
+
+	const resolvedMaskRadius =
+		zoomOptions?.mask?.borderRadius ??
+		(isFiniteNumber(zoomOptions?.maskBorderRadius)
+			? zoomOptions?.maskBorderRadius
+			: DEFAULT_MASK_BORDER_RADIUS);
+
+	return {
+		mask: {
+			borderRadius: resolvedMaskRadius,
+			borderTopLeftRadius: zoomOptions?.mask?.borderTopLeftRadius,
+			borderTopRightRadius: zoomOptions?.mask?.borderTopRightRadius,
+			borderBottomLeftRadius: zoomOptions?.mask?.borderBottomLeftRadius,
+			borderBottomRightRadius: zoomOptions?.mask?.borderBottomRightRadius,
+			borderCurve: zoomOptions?.mask?.borderCurve,
+			outset: normalizeOutset(zoomOptions?.mask?.outset),
+		},
+		motion: {
+			dragResistance: isFiniteNumber(zoomOptions?.motion?.dragResistance)
+				? zoomOptions.motion.dragResistance
+				: DEFAULT_DRAG_RESISTANCE,
+			dragDirectionalScaleMin: isFiniteNumber(
+				zoomOptions?.motion?.dragDirectionalScaleMin,
+			)
+				? zoomOptions.motion.dragDirectionalScaleMin
+				: DEFAULT_DRAG_DIRECTIONAL_SCALE_MIN,
+			dragDirectionalScaleMax: DEFAULT_DRAG_DIRECTIONAL_SCALE_MAX,
+		},
+	};
+};
+
+export const resolveZoomConfig = ({
+	id,
+	group,
+	zoomOptions,
+	currentRouteKey,
+	resolveTag,
+	defaultAnchor,
+}: {
+	id: BoundId;
+	group?: string;
+	zoomOptions?: BoundsNavigationZoomOptions;
+	currentRouteKey?: string;
+	resolveTag: ResolveTag;
+	defaultAnchor: BoundsOptions["anchor"] | undefined;
+}): {
+	resolvedTag: string;
+	sharedOptions: Partial<BoundsOptions>;
+	explicitTarget: BoundsOptions["target"] | undefined;
+	zoomOptions: ResolvedZoomOptions;
+} | null => {
+	"worklet";
+	const resolvedTag = resolveTag({ id, group });
+	if (!resolvedTag) return null;
+
+	// Try direct boundary config for the current screen first.
+	const boundaryConfig = currentRouteKey
+		? BoundStore.getBoundaryConfig(resolvedTag, currentRouteKey)
+		: null;
+
+	// Fallback: when the current screen has no Boundary (e.g. a zoom detail
+	// screen without a destination element), inherit config from the link's
+	// source screen so that props like scaleMode propagate to both sides.
+	let effectiveConfig = boundaryConfig;
+	if (!effectiveConfig) {
+		// For no-destination navigation zoom, the focused route won't appear in
+		// a completed link yet. Fall back to the latest unscoped link so source
+		// boundary defaults (anchor/scaleMode/target) still propagate.
+		const scopedLink = currentRouteKey
+			? BoundStore.getActiveLink(resolvedTag, currentRouteKey)
+			: null;
+		const link = scopedLink ?? BoundStore.getActiveLink(resolvedTag);
+		if (link?.source) {
+			effectiveConfig = BoundStore.getBoundaryConfig(
+				resolvedTag,
+				link.source.screenKey,
+			);
+		}
+	}
+
+	const sharedOptions: Partial<BoundsOptions> = {
+		anchor: zoomOptions?.anchor ?? effectiveConfig?.anchor ?? defaultAnchor,
+		scaleMode:
+			zoomOptions?.scaleMode ?? effectiveConfig?.scaleMode ?? "uniform",
+	};
+
+	const explicitTarget = zoomOptions?.target ?? effectiveConfig?.target;
+	const resolvedZoomOptions = normalizeZoomOptions(zoomOptions);
+
+	return {
+		resolvedTag,
+		sharedOptions,
+		explicitTarget,
+		zoomOptions: resolvedZoomOptions,
+	};
+};

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

@@ -0,0 +1,2 @@
+export { createZoomAccessor } from "./accessor";
+export { buildZoomStyles } from "./build";

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

@@ -0,0 +1,22 @@
+import type { ScreenInterpolationProps } from "../../../types/animation.types";
+import type { BoundsNavigationZoomOptions } from "../../../types/bounds.types";
+import type { BoundId, BoundsOptions } from "../types/options";
+
+export type ResolveTag = (params: {
+	id?: BoundId;
+	group?: string;
+}) => string | undefined;
+
+export type ComputeRaw = (
+	overrides: Partial<BoundsOptions>,
+	frameProps?: Omit<ScreenInterpolationProps, "bounds">,
+) => Record<string, unknown>;
+
+export type BuildZoomStylesParams = {
+	id: BoundId;
+	group?: string;
+	zoomOptions?: BoundsNavigationZoomOptions;
+	props: Omit<ScreenInterpolationProps, "bounds">;
+	resolveTag: ResolveTag;
+	computeRaw: ComputeRaw;
+};

package/src/shared/utils/create-provider.tsx

@@ -4,7 +4,6 @@
  * SUPER COOL AMAZING UTILITY
  */
 import {
-	type ComponentType,
 	createContext,
 	type ReactNode,
 	useContext,
@@ -90,32 +89,10 @@ export default function createProvider<
 			return context;
 		};
 
-		/**
-		 * HOC that wraps a component with the provider.
-		 * Uses the Provider component internally to ensure hooks are called correctly.
-		 */
-		const withProvider = (Component: ComponentType<ContextValue>) => {
-			// Consumer component that reads context and passes to wrapped component
-			const ContextConsumer = () => {
-				const contextValue = useEnhancedContext();
-				if (!contextValue) return null;
-				return <Component {...contextValue} />;
-			};
-
-			return function WithProviderWrapper(props: ProviderProps) {
-				return (
-					<Provider {...props}>
-						<ContextConsumer />
-					</Provider>
-				);
-			};
-		};
-
 		return {
 			[`${name}Context`]: Context,
 			[`${name}Provider`]: Provider,
 			[`use${name}Context`]: useEnhancedContext,
-			[`with${name}Provider`]: withProvider,
 		} as {
 			[P in ProviderName as `${P}Context`]: React.Context<ContextValue>;
 		} & {
@@ -124,10 +101,6 @@ export default function createProvider<
 			[P in ProviderName as `use${P}Context`]: () => Guarded extends true
 				? ContextValue
 				: ContextValue | null;
-		} & {
-			[P in ProviderName as `with${P}Provider`]: (
-				Component: ComponentType<ContextValue>,
-			) => React.FC<ProviderProps>;
 		};
 	};
 }

package/src/shared/utils/gesture/find-collapse-target.ts

@@ -1,4 +1,5 @@
 import { EPSILON } from "../../constants";
+import { sanitizeSnapPoints } from "./validate-snap-points";
 
 interface FindCollapseTargetResult {
 	target: number;
@@ -22,9 +23,7 @@ export function findCollapseTarget(
 ): FindCollapseTargetResult {
 	"worklet";
 
-	const normalized = snapPoints.filter((point) =>
-		canDismiss ? Number.isFinite(point) : Number.isFinite(point) && point > 0,
-	);
+	const normalized = sanitizeSnapPoints(snapPoints, canDismiss);
 
 	if (normalized.length === 0) {
 		return canDismiss

package/src/shared/utils/gesture/resolve-ownership.ts

@@ -10,7 +10,7 @@ import {
  * Minimal interface for ancestor context needed for ownership resolution.
  * This allows the function to be used without importing the full GestureContextType.
  */
-export interface AncestorClaimsContext {
+interface AncestorClaimsContext {
 	claimedDirections: ClaimedDirections;
 	ancestorContext: AncestorClaimsContext | null;
 }
@@ -72,39 +72,3 @@ function resolveDirectionOwnership(
 	// No one claims this direction
 	return "none";
 }
-
-/**
- * Finds the nearest ancestor (or self if isCurrentOwner) that claims any direction.
- * Used for setting up native gesture relationships.
- *
- * @param selfClaimsAny - Whether the current screen claims any direction
- * @param ancestorContext - The ancestor context chain
- * @returns The nearest context that claims a direction, or null
- */
-export function findNearestOwner(
-	selfClaimsAny: boolean,
-	ancestorContext: AncestorClaimsContext | null,
-): AncestorClaimsContext | null {
-	// If self claims any direction, self is the nearest owner
-	// (but we return null since this is used for finding ANCESTOR owners)
-	if (selfClaimsAny) {
-		return null;
-	}
-
-	// Walk ancestors looking for one that claims any direction
-	let ancestor = ancestorContext;
-	while (ancestor) {
-		const claims = ancestor.claimedDirections;
-		if (
-			claims?.vertical ||
-			claims?.["vertical-inverted"] ||
-			claims?.horizontal ||
-			claims?.["horizontal-inverted"]
-		) {
-			return ancestor;
-		}
-		ancestor = ancestor.ancestorContext;
-	}
-
-	return null;
-}

package/src/shared/utils/gesture/validate-snap-points.ts

@@ -1,35 +1,58 @@
-interface ValidateSnapPointsResult {
+import type { SnapPoint } from "../../types/screen.types";
+
+/**
+ * Filters snap points to only valid, finite numeric values.
+ * Excludes zero (dismiss) when canDismiss is false.
+ */
+export function sanitizeSnapPoints(
+	snapPoints: SnapPoint[],
+	canDismiss: boolean,
+): number[] {
+	"worklet";
+	return snapPoints.filter(
+		(point): point is number =>
+			typeof point === "number" &&
+			(canDismiss
+				? Number.isFinite(point)
+				: Number.isFinite(point) && point > 0),
+	);
+}
+
+export interface EffectiveSnapPointsResult {
 	hasSnapPoints: boolean;
+	hasAutoSnapPoint: boolean;
 	snapPoints: number[];
 	minSnapPoint: number;
 	maxSnapPoint: number;
 }
 
 interface ValidateSnapPointsOptions {
-	snapPoints?: number[];
+	snapPoints?: SnapPoint[];
 	canDismiss?: boolean;
 }
 
 export const validateSnapPoints = ({
 	snapPoints,
 	canDismiss,
-}: ValidateSnapPointsOptions): ValidateSnapPointsResult => {
+}: ValidateSnapPointsOptions): EffectiveSnapPointsResult => {
 	if (!snapPoints || snapPoints.length === 0) {
 		return {
 			hasSnapPoints: false,
+			hasAutoSnapPoint: false,
 			snapPoints: [],
 			minSnapPoint: -1,
 			maxSnapPoint: -1,
 		};
 	}
 
-	const normalizedSnaps = snapPoints.filter((point) =>
-		canDismiss ? Number.isFinite(point) : Number.isFinite(point) && point > 0,
-	);
+	const hasAuto = snapPoints.includes("auto");
+	const normalizedSnaps = sanitizeSnapPoints(snapPoints, canDismiss ?? false);
 
-	if (normalizedSnaps.length === 0) {
+	// hasSnapPoints is true if there are valid numeric points OR an 'auto' point
+	if (normalizedSnaps.length === 0 && !hasAuto) {
 		return {
 			hasSnapPoints: false,
+			hasAutoSnapPoint: false,
 			snapPoints: [],
 			minSnapPoint: -1,
 			maxSnapPoint: -1,
@@ -38,11 +61,12 @@ export const validateSnapPoints = ({
 
 	const sortedSnaps = normalizedSnaps.slice().sort((a, b) => a - b);
 	// Clamp to snap point bounds (dismiss at 0 only if allowed)
-	const minProgress = canDismiss ? 0 : sortedSnaps[0];
-	const maxProgress = sortedSnaps[sortedSnaps.length - 1];
+	const minProgress = canDismiss ? 0 : (sortedSnaps[0] ?? -1);
+	const maxProgress = sortedSnaps[sortedSnaps.length - 1] ?? -1;
 
 	return {
 		hasSnapPoints: true,
+		hasAutoSnapPoint: hasAuto,
 		snapPoints: sortedSnaps,
 		minSnapPoint: minProgress,
 		maxSnapPoint: maxProgress,

package/src/shared/utils/logger.ts

@@ -10,6 +10,3 @@ export const logger = {
 		console.warn(`[${LIBRARY_NAME}] ${message}`);
 	},
 };
-
-export const error = (message: string) =>
-	new Error(`[${LIBRARY_NAME}] ${message}`);

package/src/shared/utils/navigation/compose-descriptors.ts

@@ -1,6 +1,4 @@
-interface RouteWithKey {
-	key: string;
-}
+import type { RouteWithKey } from "../../types/stack.types";
 
 export const composeDescriptors = <
 	Route extends RouteWithKey,

package/src/shared/utils/navigation/resolve-scene-neighbors.ts

@@ -0,0 +1,89 @@
+interface SceneWithKey {
+	route: { key: string };
+	descriptor: unknown;
+}
+
+type IsRouteClosing = (routeKey: string) => boolean;
+
+/**
+ * Resolves previous/next descriptors while accounting for routes that are
+ * visually closing.
+ *
+ * Rules:
+ * - Closing scenes are isolated (no previous/next) so their transition does not
+ *   mix with newly pushed screens.
+ * - Non-closing scenes skip over closing neighbors to find the actual active
+ *   neighbor.
+ * - If there is no non-closing neighbor above/below, we fall back to the first
+ *   closing neighbor (needed for normal back transitions).
+ */
+export function resolveSceneNeighbors<T extends SceneWithKey>(
+	scenes: T[],
+	sceneIndex: number,
+	isRouteClosing: IsRouteClosing,
+): {
+	previousDescriptor: T["descriptor"] | undefined;
+	nextDescriptor: T["descriptor"] | undefined;
+} {
+	const current = scenes[sceneIndex];
+	if (!current) {
+		return {
+			previousDescriptor: undefined,
+			nextDescriptor: undefined,
+		};
+	}
+
+	if (isRouteClosing(current.route.key)) {
+		return {
+			previousDescriptor: undefined,
+			nextDescriptor: undefined,
+		};
+	}
+
+	let nextDescriptor: T["descriptor"] | undefined;
+	let firstClosingAbove: T["descriptor"] | undefined;
+
+	for (let i = sceneIndex + 1; i < scenes.length; i++) {
+		const candidate = scenes[i];
+		if (!candidate) continue;
+
+		if (!isRouteClosing(candidate.route.key)) {
+			nextDescriptor = candidate.descriptor;
+			break;
+		}
+
+		if (firstClosingAbove === undefined) {
+			firstClosingAbove = candidate.descriptor;
+		}
+	}
+
+	if (nextDescriptor === undefined) {
+		nextDescriptor = firstClosingAbove;
+	}
+
+	let previousDescriptor: T["descriptor"] | undefined;
+	let firstClosingBelow: T["descriptor"] | undefined;
+
+	for (let i = sceneIndex - 1; i >= 0; i--) {
+		const candidate = scenes[i];
+		if (!candidate) continue;
+
+		if (!isRouteClosing(candidate.route.key)) {
+			previousDescriptor = candidate.descriptor;
+			break;
+		}
+
+		if (firstClosingBelow === undefined) {
+			firstClosingBelow = candidate.descriptor;
+		}
+	}
+
+	if (previousDescriptor === undefined) {
+		previousDescriptor = firstClosingBelow;
+	}
+
+	return {
+		previousDescriptor,
+		nextDescriptor,
+	};
+}

package/src/shared/utils/navigation/sync-routes-with-removed.ts

@@ -1,10 +1,7 @@
 import type { useClosingRouteKeys } from "../../hooks/navigation/use-closing-route-keys";
+import type { RouteWithKey } from "../../types/stack.types";
 import { composeDescriptors } from "./compose-descriptors";
 
-interface RouteWithKey {
-	key: string;
-}
-
 type SyncRoutesWithRemovedParams<
 	Route extends RouteWithKey,
 	DescriptorMap extends Record<string, unknown>,

package/src/shared/utils/normalize-interpolated-style.ts

@@ -0,0 +1,67 @@
+import type {
+	NormalizedTransitionInterpolatedStyle,
+	NormalizedTransitionSlotStyle,
+} from "../types/animation.types";
+
+/**
+ * Normalizes an interpolator result into the canonical `{ style, props }` slot format.
+ *
+ * Handles three cases per key:
+ * 1. Legacy renamed keys (`contentStyle` → `content`, `backdropStyle` → `backdrop`)
+ * 2. Proper `TransitionSlotStyle` values (has `style` or `props` key) — pass through
+ * 3. Style shorthand (plain StyleProps without wrapping) — auto-wrapped as `{ style: value }`
+ *
+ * Mixed-format objects (e.g. new-format spread + a legacy `backdropStyle` key) are
+ * handled correctly because each key is processed individually.
+ */
+export function normalizeInterpolatedStyle(raw: Record<string, any>): {
+	result: NormalizedTransitionInterpolatedStyle;
+	wasLegacy: boolean;
+} {
+	"worklet";
+
+	const hasLegacyKeys =
+		"contentStyle" in raw || "backdropStyle" in raw || "overlayStyle" in raw;
+
+	const normalized: Record<string, NormalizedTransitionSlotStyle | undefined> =
+		{};
+
+	for (const key in raw) {
+		const value = raw[key];
+
+		// ── Legacy key renames ──
+		if (key === "contentStyle") {
+			if (value !== undefined) normalized.content = { style: value };
+			continue;
+		}
+		if (key === "backdropStyle") {
+			if (value !== undefined) normalized.backdrop = { style: value };
+			continue;
+		}
+		if (key === "overlayStyle") {
+			if (value !== undefined && !normalized.backdrop) {
+				normalized.backdrop = { style: value };
+			}
+			continue;
+		}
+
+		// ── All other keys ──
+		if (value === undefined) {
+			normalized[key] = undefined;
+			continue;
+		}
+
+		if (typeof value === "object" && ("style" in value || "props" in value)) {
+			// Proper TransitionSlotStyle — pass through
+			normalized[key] = value;
+		} else {
+			// Shorthand: plain StyleProps — wrap it
+			normalized[key] = { style: value };
+		}
+	}
+
+	return {
+		result: normalized as NormalizedTransitionInterpolatedStyle,
+		wasLegacy: hasLegacyKeys,
+	};
+}

package/src/shared/utils/overlay/visibility.ts

@@ -1,23 +1,8 @@
-import type { OverlayMode } from "../../types/overlay.types";
-
 type OverlayOptionsLike = {
 	overlay?: unknown;
-	overlayMode?: OverlayMode;
 	overlayShown?: boolean;
 };
 
 export const isOverlayVisible = (options?: OverlayOptionsLike): boolean => {
 	return Boolean(options?.overlay) && options?.overlayShown !== false;
 };
-
-export const isFloatOverlayVisible = (
-	options?: OverlayOptionsLike,
-): boolean => {
-	return isOverlayVisible(options) && options?.overlayMode !== "screen";
-};
-
-export const isScreenOverlayVisible = (
-	options?: OverlayOptionsLike,
-): boolean => {
-	return isOverlayVisible(options) && options?.overlayMode === "screen";
-};

package/src/shared/utils/platform.ts

@@ -0,0 +1,6 @@
+/**
+ * Detects whether the app is running on React Native's new architecture (Fabric).
+ */
+export function isFabric(): boolean {
+	return "nativeFabricUIManager" in global;
+}

package/lib/commonjs/shared/components/overlay/variations/screen-overlay.js

@@ -1,64 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.ScreenOverlay = ScreenOverlay;
-var _react = require("react");
-var _snapTo = require("../../../animation/snap-to");
-var _useOptimisticFocusedIndex = require("../../../hooks/navigation/use-optimistic-focused-index");
-var _useStack = require("../../../hooks/navigation/use-stack");
-var _keys = require("../../../providers/screen/keys.provider");
-var _visibility = require("../../../utils/overlay/visibility");
-var _overlayHost = require("./overlay-host");
-var _jsxRuntime = require("react/jsx-runtime");
-/**
- * Screen overlay component that renders per-screen.
- * Gets current descriptor from keys context.
- *
- * @deprecated Screen overlays are deprecated. For per-screen overlays, render an
- * absolute-positioned view directly in your screen component and use `useScreenAnimation()`
- * to access animation values. This component will be removed in a future version.
- */
-function ScreenOverlay() {
-  const {
-    current
-  } = (0, _keys.useKeys)();
-  const {
-    flags,
-    routes,
-    optimisticFocusedIndex,
-    routeKeys
-  } = (0, _useStack.useStack)();
-  const focusedIndex = (0, _useOptimisticFocusedIndex.useOptimisticFocusedIndex)(optimisticFocusedIndex, routeKeys.length);
-  const options = current.options;
-  const scene = (0, _react.useMemo)(() => ({
-    descriptor: current,
-    route: current.route
-  }), [current]);
-  const overlayScreenState = (0, _react.useMemo)(() => ({
-    index: routeKeys.indexOf(current.route.key),
-    options: current.options,
-    routes,
-    focusedRoute: routes[focusedIndex] ?? current.route,
-    focusedIndex,
-    meta: current.options?.meta,
-    navigation: current.navigation,
-    snapTo: index => {
-      (0, _snapTo.snapDescriptorToIndex)(current, index);
-    }
-  }), [current, routeKeys, routes, focusedIndex]);
-
-  // Skip screens without enableTransitions (native-stack only)
-  if (!flags.TRANSITIONS_ALWAYS_ON && !options.enableTransitions) {
-    return null;
-  }
-  if (!(0, _visibility.isScreenOverlayVisible)(options)) {
-    return null;
-  }
-  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_overlayHost.OverlayHost, {
-    scene: scene,
-    overlayScreenState: overlayScreenState
-  });
-}
-//# sourceMappingURL=screen-overlay.js.map