@scalebun/react-native 1.13.0 → 2.0.1

package/src/features/journey/ScaleBunScrollView.tsx

@@ -52,6 +52,35 @@ export const ScaleBunScrollView = React.forwardRef<ScrollView, ScrollViewProps>(
                     }
                 } catch { /* no-throw */ }
 
+                /**
+                 * RN-3 — record WHERE THIS scroller sits, keyed by its own native tag, so a later
+                 * tap can say which content was under the finger.
+                 *
+                 * OUTSIDE the `isActive` guard above, deliberately. That guard is correct for the
+                 * gesture tracker, which produces scroll EVENTS and should only do so while
+                 * recording. This is a different thing: it is the position a tap needs in order to
+                 * be placed in content rather than on glass, and a tap is captured on the always-on
+                 * analytics lane even when no recording is active. Gating this the same way would
+                 * make content depth absent in exactly the sessions the heatmap is built from.
+                 *
+                 * The tag is taken from the EVENT's target rather than from this component's ref,
+                 * so it identifies the scroller that actually moved. With nested scrollers the
+                 * event may come from an inner one, and keying by the wrapper would file the
+                 * carousel's offset under the list.
+                 */
+                try {
+                    const { recordScrollOffset, nativeTagOf } = require('./scrollContext');
+                    const { contentOffset, target } = event.nativeEvent as unknown as {
+                        contentOffset: { x: number; y: number };
+                        target?: unknown;
+                    };
+                    recordScrollOffset(
+                        typeof target === 'number' ? target : nativeTagOf(target),
+                        contentOffset.x,
+                        contentOffset.y,
+                    );
+                } catch { /* no-throw */ }
+
                 // Forward to user's onScroll handler
                 if (userOnScroll) {
                     userOnScroll(event);

package/src/features/journey/autoInstrumentScroll.ts

@@ -0,0 +1,155 @@
+import { nativeTagOf, recordScrollOffset } from './scrollContext';
+
+/**
+ * RN-3, ZERO-CONFIG — make every ScrollView report its offset, not just the wrapped ones.
+ *
+ * THE PROBLEM THIS SOLVES. Scroll offsets reach the SDK from `ScaleBunScrollView` and nowhere
+ * else, so an app using React Native's own `<ScrollView>` — which is most apps — produces taps
+ * with no content depth at all. Two taps at the same screen coordinate one viewport apart then
+ * merge into one hotspot, and the heatmap shows heavy engagement at a position where, in content
+ * terms, nothing in particular is. Asking every integration to swap its scroll views is a real
+ * migration cost and will never reach the long tail.
+ *
+ * WHY IT IS OFF BY DEFAULT, and why that is not timidity. This patches React Native's own module
+ * exports. Every scroll view in the host app — including ones inside third-party libraries the
+ * app did not write — starts routing through an SDK component. The failure mode of getting that
+ * wrong is not a wrong number in a dashboard, it is the host's UI behaving differently because an
+ * analytics SDK replaced a primitive. That is a decision an integrator makes with their eyes open,
+ * not a default they discover afterwards.
+ *
+ * THE PRECEDENT, AND ITS LESSON. The SDK already patches `@react-navigation/native` this way
+ * (`AutoScreenDetector._autoHookReactNavigation`). That hook shipped BROKEN: it assigned to module
+ * exports that are getters, which throws in strict mode, inside a `catch` that discarded the
+ * error. It reported success, captured no ref, and the whole screen-name pipeline stayed empty
+ * with nothing to indicate it. So this uses the same defence that fixed it — define the property
+ * rather than assign to it, then READ IT BACK — and refuses to claim success it has not verified.
+ *
+ * WHAT IT DELIBERATELY DOES NOT PATCH. `FlatList` and `SectionList` render a `ScrollView`
+ * internally, so patching that one export covers them without touching three. Fewer patch points
+ * is fewer ways to be wrong, and RN-4's row identity comes off the fiber regardless of which
+ * component rendered it.
+ */
+
+interface PatchResult {
+  /** True only when the replacement was verified by reading it back. */
+  installed: boolean;
+  /** Why not, when it did not install — for a diagnostic the host can act on. */
+  reason?: string;
+}
+
+let alreadyPatched = false;
+
+/**
+ * Replace an export on a module whose exports are GETTERS.
+ *
+ * React Native's index is compiled re-exports, which bundlers emit as accessors with a getter and
+ * no setter. Plain assignment throws in strict mode and silently does nothing in sloppy mode.
+ * Defining the property works where assigning does not, and the read-back is what turns a future
+ * failure into a visible one instead of a silent no-op.
+ */
+function redefine(target: Record<string, unknown>, key: string, value: unknown): boolean {
+  try {
+    Object.defineProperty(target, key, {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value,
+    });
+    return target[key] === value;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Wrap a scroll component so its offsets are recorded, forwarding everything else untouched.
+ *
+ * The host's own `onScroll` is called AFTER the offset is recorded and is never replaced: an SDK
+ * that swallows a host's handler breaks the app, which is a far worse outcome than missing
+ * analytics. Recording first also means a throwing host handler cannot cost us the measurement.
+ */
+function instrument(Original: any, React: any): any {
+  const Wrapped = React.forwardRef((props: any, ref: unknown) => {
+    const onScroll = (event: any) => {
+      try {
+        const target = event?.nativeEvent?.target;
+        const offset = event?.nativeEvent?.contentOffset;
+        if (offset) {
+          recordScrollOffset(
+            typeof target === 'number' ? target : nativeTagOf(target),
+            offset.x,
+            offset.y,
+          );
+        }
+      } catch {
+        /* no-throw: a scroll offset is never worth breaking a gesture over */
+      }
+      try {
+        props?.onScroll?.(event);
+      } catch (e) {
+        /* The host's handler is the host's problem, but it must still run and still throw where
+           they can see it — rethrow on a later tick so this wrapper is not in the stack. */
+        setTimeout(() => {
+          throw e;
+        }, 0);
+      }
+    };
+    /**
+     * `scrollEventThrottle` defaults to 16 only when the host has not chosen one. Overriding a
+     * host's explicit value would change how often their own handler runs — a behaviour change
+     * for a measurement, which is exactly the trade this module is not allowed to make.
+     */
+    const throttle = props?.scrollEventThrottle ?? 16;
+    return React.createElement(Original, {
+      ...props,
+      scrollEventThrottle: throttle,
+      onScroll,
+      ref,
+    });
+  });
+  Wrapped.displayName = 'ScaleBunAutoScrollView';
+  return Wrapped;
+}
+
+/**
+ * Patch React Native's `ScrollView` export so every scroll view reports its offset.
+ *
+ * Idempotent, no-throw, and honest about failure: returns `installed: false` with a reason rather
+ * than claiming a success it did not verify.
+ */
+export function autoInstrumentScrollViews(): PatchResult {
+  if (alreadyPatched) return { installed: true };
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const RN = require('react-native') as Record<string, unknown>;
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const React = require('react');
+    const Original = RN.ScrollView;
+    if (typeof Original !== 'function' && typeof Original !== 'object') {
+      return { installed: false, reason: 'react-native has no ScrollView export to wrap' };
+    }
+    if ((Original as { __scalebunInstrumented?: boolean }).__scalebunInstrumented) {
+      alreadyPatched = true;
+      return { installed: true };
+    }
+    const Wrapped = instrument(Original, React);
+    (Wrapped as { __scalebunInstrumented?: boolean }).__scalebunInstrumented = true;
+    if (!redefine(RN, 'ScrollView', Wrapped)) {
+      return {
+        installed: false,
+        reason:
+          "react-native's ScrollView export could not be replaced — it is a getter with no " +
+          'configurable descriptor on this bundler. Use ScaleBunScrollView explicitly instead.',
+      };
+    }
+    alreadyPatched = true;
+    return { installed: true };
+  } catch (e) {
+    return { installed: false, reason: (e as Error)?.message ?? 'unknown failure' };
+  }
+}
+
+/** Test seam: forget that the patch ran, so a suite can exercise it more than once. */
+export function resetAutoInstrumentForTests(): void {
+  alreadyPatched = false;
+}

package/src/features/journey/interactionProtocol.ts

@@ -14,7 +14,52 @@ export interface InteractionStartContext {
     y: number;
     target?: string;
     targetId?: string;
+    /**
+     * WHICH kind of identity `targetId` is: an authored `testID`, a structural component path, or
+     * a bare component name.
+     *
+     * Carried because they are not equally trustworthy — a testID is a promise from the app's
+     * authors, a path is an inference that breaks when the tree is refactored — and a consumer
+     * that cannot tell them apart renders a refactor-fragile guess as a confident target.
+     */
+    targetSource?: 'testID' | 'path' | 'component' | 'none';
     screenName?: string;
+    /** RN-8: where `screenName` came from, so low coverage is diagnosable rather than merely visible. */
+    screenSource?: 'manual' | 'navigation' | 'none';
+    /**
+     * RN-13: the target control's rectangle as fractions of the capture base, or undefined when it
+     * could not be measured synchronously. Comparable to the tap's own normalized point, which is
+     * what makes 'heat is on this control' checkable rather than assumed.
+     */
+    targetRect?: { x: number; y: number; width: number; height: number };
+    /**
+     * RN-3: the content offset of the nearest ancestor scroller at finger-down, so two taps at the
+     * same screen coordinate one viewport apart do not merge. Absent when no ancestor reported one
+     * — never defaulted to 0, which is a real scroll position (the top of a list).
+     */
+    scrollX?: number;
+    scrollY?: number;
+    /** Whether a scroll offset was available at all. 'none' means no wrapped scroller was an ancestor. */
+    scrollSource?: 'wrapper' | 'none';
+    /**
+     * RN-4: the list row's key, taken from the app's own `keyExtractor` via the cell's `cellKey`
+     * prop. Distinguishes two taps that share a RECYCLED native view — the same slot showing a
+     * different row after scrolling — which would otherwise merge into one hotspot.
+     */
+    itemKey?: string;
+    /** The row's index at render time. Same index + different key = a recycled slot. */
+    itemIndex?: number;
+    /**
+     * RN-15: the tap's position INSIDE the target control — (0,0) its top-left, (1,1) its
+     * bottom-right. Resolution-independent, so one control is one distribution across every device
+     * size rather than a separate cloud of heat per screen width.
+     *
+     * NOT clamped. A value outside 0..1 means the tap landed outside the control's visual box and
+     * was still attributed to it, which is what `hitSlop` does — and a control whose taps cluster
+     * outside its own bounds is drawn too small, which is a finding rather than noise.
+     */
+    localU?: number;
+    localV?: number;
     ui?: string;
     stateStatus: InteractionStateStatus;
     emitAutomaticAnalytics: boolean;
@@ -24,22 +69,155 @@ export function generateInteractionId(): string {
     return `ixj-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
 }
 
+/**
+ * RN-6 — THE CORRELATION CONTRACT.
+ *
+ * WHAT IS BEING JOINED, AND WHY IT IS HARD. A physical tap is observed twice: natively, by
+ * a window callback that sees ACTION_DOWN/UP and produces the coordinates; and in JS, by a
+ * capture-phase touch handler that produces the IDENTITY — which control was hit, what UI
+ * state was declared, which screen. Both sides mint their own id and neither can derive
+ * the other's: native builds `ixn-a-<process nonce>-<MotionEvent ts>` from a clock JS
+ * cannot read, and JS builds `ixj-<Date.now()>-<random>`. So the two observations have to
+ * be JOINED, and the only shared quantity is time.
+ *
+ * WHY THE OLD JOIN WAS DANGEROUS RATHER THAN MERELY APPROXIMATE. It took whichever start
+ * was nearest in time within ±1500 ms and used it unconditionally. The fields it carries
+ * across are `target`, `targetId`, `ui`, `stateStatus` and `screenName`; the coordinates
+ * come from the native side and are always right. So a wrong pairing does not produce
+ * obviously broken data — it produces heat in the CORRECT position attributed to the
+ * WRONG control, in the wrong UI state, on the wrong screen. Nothing downstream can
+ * detect that, because every field is individually well-formed.
+ *
+ * 1500 ms is a very long time on a touch surface. A deliberate double-tap is 150–300 ms
+ * apart; an impatient tapper is faster. So "nearest within 1500 ms" routinely had more
+ * than one candidate, and picked one with no record that it had a choice.
+ *
+ * WHAT THIS REPLACES IT WITH — three outcomes instead of one, and a refusal:
+ *
+ *   'exact'      one candidate is clearly closest: the runner-up is at least
+ *                `marginMs` further away. The join is used.
+ *   'ambiguous'  two candidates are within `marginMs` of each other, so choosing
+ *                between them is a coin flip. The join is REFUSED and the caller must
+ *                emit the interaction WITHOUT js-derived identity. A tap with no target
+ *                is honest and visibly incomplete; a tap with the wrong target is
+ *                indistinguishable from a correct one and corrupts every aggregate it
+ *                enters.
+ *   'none'       nothing within tolerance. Same refusal, different reason — worth
+ *                separating because 'none' means the JS handler never fired (a real
+ *                capture gap) while 'ambiguous' means it fired too often to attribute.
+ *
+ * It also reports `deltaMs` and `runnerUpDeltaMs` so the outcome is auditable after the
+ * fact rather than being a claim this comment makes.
+ *
+ * WHAT IT DELIBERATELY DOES NOT DO: use position to disambiguate. The native event carries
+ * raw px in the capture view and normalized 0..1 coordinates; the JS start carries its own
+ * x/y in a different space (dp in the root view). Comparing them needs a proven scale
+ * factor between the two, and getting it wrong would REJECT valid pairings — strictly
+ * worse than today. That calibration needs a device run, so it is a follow-up, not a
+ * guess made here.
+ */
+export type CorrelationOutcome = 'exact' | 'ambiguous' | 'none';
+
+export interface CorrelationResult<T> {
+    /** Present only when `outcome` is 'exact'. Never a best-guess. */
+    start?: T;
+    /** Index into the input array, so the caller can consume it. -1 unless 'exact'. */
+    index: number;
+    outcome: CorrelationOutcome;
+    /** Distance to the chosen (or best rejected) candidate; null when there was none. */
+    deltaMs: number | null;
+    /** Distance to the second candidate — what makes 'ambiguous' auditable. */
+    runnerUpDeltaMs: number | null;
+}
+
+/**
+ * How far apart a native event and a JS start may be and still be the same touch.
+ *
+ * Unchanged at 1500 ms from the previous implementation, deliberately: narrowing it is a
+ * separate, measurable decision about how late the JS handler can run on a slow device,
+ * and bundling it into this change would make any regression impossible to attribute.
+ */
+export const CORRELATION_TOLERANCE_MS = 1500;
+
+/**
+ * How much closer the winner must be than the runner-up to count as identified.
+ *
+ * 100 ms because that is comfortably below the fastest deliberate double-tap (~150 ms):
+ * when two candidate starts are within 100 ms of each other in distance, the native event
+ * sits effectively between them and the "nearest" one is a coin flip.
+ */
+export const CORRELATION_MARGIN_MS = 100;
+
 /** Match a native bridge event to the JS evidence sampled at the same finger-down. */
-export function nearestInteractionStart<T extends InteractionStartContext>(
+export function correlateInteraction<T extends InteractionStartContext>(
     starts: readonly T[],
     occurredAt: number,
-    toleranceMs = 1500,
-): T | undefined {
-    let best: T | undefined;
-    let bestDelta = toleranceMs + 1;
-    for (const start of starts) {
+    toleranceMs = CORRELATION_TOLERANCE_MS,
+    marginMs = CORRELATION_MARGIN_MS,
+): CorrelationResult<T> {
+    const candidates: Array<{ index: number; delta: number }> = [];
+    for (let i = 0; i < starts.length; i++) {
+        const start = starts[i];
+        if (!start) continue;
         const delta = Math.abs(start.occurredAt - occurredAt);
-        if (delta < bestDelta) {
-            best = start;
-            bestDelta = delta;
+        if (delta <= toleranceMs) candidates.push({ index: i, delta });
+    }
+
+    if (candidates.length === 0) {
+        return { index: -1, outcome: 'none', deltaMs: null, runnerUpDeltaMs: null };
+    }
+
+    /* Stable ordering: equal deltas resolve by index so a repeated run cannot produce a
+       different answer from the same inputs. A non-deterministic correlation would make
+       every downstream measurement unreproducible. */
+    candidates.sort((a, b) => (a.delta - b.delta) || (a.index - b.index));
+    const best = candidates[0]!;
+    const runnerUp = candidates[1];
+
+    if (runnerUp && runnerUp.delta - best.delta < marginMs) {
+        return {
+            index: -1,
+            outcome: 'ambiguous',
+            deltaMs: best.delta,
+            runnerUpDeltaMs: runnerUp.delta,
+        };
+    }
+
+    return {
+        start: starts[best.index],
+        index: best.index,
+        outcome: 'exact',
+        deltaMs: best.delta,
+        runnerUpDeltaMs: runnerUp ? runnerUp.delta : null,
+    };
+}
+
+/**
+ * Drop starts that can no longer match anything, in place.
+ *
+ * WHY IT MATTERS BEYOND MEMORY. A start older than the tolerance is unreachable, but while
+ * it sits in the list it is still a CANDIDATE for the ambiguity test — so a stale entry can
+ * turn a perfectly clear pairing into a refusal, and an accumulating list makes that more
+ * likely the longer a session runs. Pruning is therefore part of the correctness of the
+ * join, not housekeeping.
+ *
+ * Mutates rather than returning a copy because the caller holds it in a ref that the native
+ * listener and the touch handler both read.
+ */
+export function pruneInteractionStarts<T extends InteractionStartContext>(
+    starts: T[],
+    now: number,
+    toleranceMs = CORRELATION_TOLERANCE_MS,
+): number {
+    let removed = 0;
+    for (let i = starts.length - 1; i >= 0; i--) {
+        const start = starts[i];
+        if (!start || now - start.occurredAt > toleranceMs) {
+            starts.splice(i, 1);
+            removed++;
         }
     }
-    return bestDelta <= toleranceMs ? best : undefined;
+    return removed;
 }
 
 /** Analytics is a projection of the same evidence; no second click is invented. */

package/src/features/journey/scrollContext.ts

@@ -0,0 +1,137 @@
+/**
+ * RN-3 — WHERE IN THE CONTENT A TAP HAPPENED, not just where on the glass.
+ *
+ * THE DEFECT. A tap carries screen coordinates. Two taps at the SAME screen coordinate, one
+ * viewport apart in a scrolling list, are two different controls — and with no scroll offset they
+ * are indistinguishable, so they merge into one hotspot. The heatmap then shows heavy engagement
+ * at a position where, in content terms, nothing in particular is.
+ *
+ * That is not a rendering nicety. Scroll offset is a PLACEMENT dimension (which content was under
+ * the finger) and a CACHE dimension (two states of one route that must not share a backdrop), so
+ * its absence corrupts both the aggregate and the picture drawn beneath it.
+ *
+ * WHY A REGISTRY RATHER THAN A SINGLE NUMBER. `ScrollTracker` already accumulates
+ * `previousOffsetX/Y`, but as ONE global pair with no idea which scroller moved. A screen with a
+ * vertical list containing a horizontal carousel has two scrollers, and whichever fired last
+ * overwrites the other — so the vertical position of a tap inside the carousel is whatever the
+ * carousel's horizontal offset happened to leave behind. A single global scrollY cannot express a
+ * nested scroller, and silently reports a wrong number rather than none.
+ *
+ * So offsets are keyed by the scroller's NATIVE TAG, which is the one identity both ends of this
+ * can see: the wrapper holds a ref to its own ScrollView, and the touch handler's fiber walk
+ * passes the same host instances on its way up. Matching on anything else — a name, an index, a
+ * generated id — would require the two sides to agree on a convention, and a convention that can
+ * drift is a join that can silently attach the wrong scroller's offset.
+ *
+ * WHAT THIS DELIBERATELY DOES NOT DO: guess. If no ancestor of the tapped node has a recorded
+ * offset, the answer is null, not zero. Zero is a real scroll position — the top of a list — and
+ * reporting it for "we do not know" would place every unmeasured tap at the top of its content,
+ * which is both wrong and indistinguishable from a genuine tap there.
+ *
+ * KNOWN LIMIT, stated because it bounds what this can deliver: offsets only arrive from
+ * `ScaleBunScrollView`, which an app has to opt into. A plain `<ScrollView>` reports nothing, so
+ * `scrollSource` is `'none'` and the tap has no content depth. Making it automatic means patching
+ * React Native's own exports — the SDK already does that for `@react-navigation/native` — and that
+ * is a decision with a much larger blast radius, not one to make silently inside a data fix.
+ */
+
+export interface ScrollOffset {
+  x: number;
+  y: number;
+  /** When it was recorded; used only to expire entries, never reported. */
+  at: number;
+}
+
+/**
+ * How long a recorded offset stays usable.
+ *
+ * A scroller that has not moved in this long may well have been unmounted — a list on a screen the
+ * user left — and its stale offset must not be attached to a tap on a DIFFERENT screen that happens
+ * to reuse the same native tag. Tags are recycled by the platform, which makes this a correctness
+ * bound rather than a memory one.
+ *
+ * Five minutes is far longer than any plausible gap between scrolling a list and tapping in it,
+ * and far shorter than a session.
+ */
+export const SCROLL_OFFSET_TTL_MS = 5 * 60_000;
+
+/**
+ * Cap on tracked scrollers.
+ *
+ * Bounded because a long session on a virtualised screen can mount and unmount many scrollers, and
+ * an unbounded map is a leak that only shows up in the sessions that matter most — the long ones.
+ * Eviction is oldest-first, which is the entry least likely to be the one a tap needs.
+ */
+const MAX_TRACKED_SCROLLERS = 32;
+
+const offsets = new Map<number, ScrollOffset>();
+
+/**
+ * The native tag of a host instance, across the shapes React Native has used.
+ *
+ * Fabric exposes `__nativeTag`; the old architecture used `_nativeTag`. Probing both means this
+ * keeps working on either architecture, and returns null rather than throwing on anything else —
+ * a scroll offset is never worth a crash.
+ */
+export function nativeTagOf(node: unknown): number | null {
+  if (!node || typeof node !== 'object') return null;
+  const n = node as { __nativeTag?: unknown; _nativeTag?: unknown };
+  const tag = typeof n.__nativeTag === 'number' ? n.__nativeTag : n._nativeTag;
+  return typeof tag === 'number' && Number.isFinite(tag) ? tag : null;
+}
+
+/** Record where a scroller currently sits. Called on every scroll event of a wrapped scroller. */
+export function recordScrollOffset(tag: number | null, x: number, y: number, now = Date.now()): void {
+  if (tag === null || !Number.isFinite(x) || !Number.isFinite(y)) return;
+  offsets.set(tag, { x, y, at: now });
+  if (offsets.size > MAX_TRACKED_SCROLLERS) {
+    let oldestTag: number | null = null;
+    let oldestAt = Infinity;
+    for (const [k, v] of offsets) {
+      if (v.at < oldestAt) {
+        oldestAt = v.at;
+        oldestTag = k;
+      }
+    }
+    if (oldestTag !== null) offsets.delete(oldestTag);
+  }
+}
+
+/**
+ * The offset of the NEAREST ancestor scroller that has one, given the tapped node's ancestor tags
+ * ordered innermost first.
+ *
+ * Nearest wins because that is the scroller the content under the finger actually moved with. A
+ * tap inside a horizontal carousel inside a vertical list belongs to the carousel's content
+ * position; attributing it to the outer list would place it by how far the PAGE had scrolled,
+ * which is the merge this whole module exists to prevent.
+ *
+ * Returns null when no ancestor has a recorded offset — never a zero.
+ */
+export function nearestRecordedOffset(
+  ancestorTags: readonly (number | null)[],
+  now = Date.now(),
+): { x: number; y: number; tag: number } | null {
+  for (const tag of ancestorTags) {
+    if (tag === null) continue;
+    const hit = offsets.get(tag);
+    if (!hit) continue;
+    if (now - hit.at > SCROLL_OFFSET_TTL_MS) {
+      /* Expired: drop it so a recycled tag cannot serve a previous screen's offset. */
+      offsets.delete(tag);
+      continue;
+    }
+    return { x: hit.x, y: hit.y, tag };
+  }
+  return null;
+}
+
+/** Forget everything. Called between sessions so one recording cannot inherit another's scrollers. */
+export function clearScrollOffsets(): void {
+  offsets.clear();
+}
+
+/** How many scrollers are currently tracked — for the leak assertion in tests. */
+export function trackedScrollerCount(): number {
+  return offsets.size;
+}