@oxyhq/bloom 0.79.0 → 0.80.0

package/lib/typescript/commonjs/scroll/store.d.ts

@@ -1,42 +1,61 @@
 /**
- * Pure, platform-agnostic core of the scroll-restoration primitive.
+ * Derive the storage key for a scrollable from WHAT its screen is showing plus
+ * an optional caller sub-key.
  *
- * This file deliberately contains NO React and NO DOM/native imports so the
- * logic can be unit-tested in isolation and shared verbatim by the web and
- * native barrels. The web barrel drives it with real scroll offsets; the
- * native barrel never instantiates it (native-stack already restores scroll).
- */
-/**
- * Derive the storage key for a scrollable from its owning route key and an
- * optional caller sub-key.
+ * The key is CONTENT identity, deliberately not the navigation entry. An offset
+ * belongs to what the user was looking at, so returning to it restores however
+ * they got there — browser Back or Forward, a tab press, an in-app link — and
+ * only content never seen this session opens at the top. Keying on the entry
+ * would defeat that: a tab press and `router.replace` both mint a fresh entry,
+ * so both would open at the top even though the user has been there.
+ *
+ * The trade, chosen rather than overlooked: the same content occupying two LIVE
+ * entries now shares one offset. Pushing `/@alice` on top of `/@alice` in a
+ * native stack restores the first one's position instead of opening at the top,
+ * and while both are mounted each writes to the same key. That is the price of
+ * a tab press restoring, which is the behaviour that was asked for.
  *
- * - `routeKey` is React Navigation's stable per-route `route.key`.
- * - `subKey` distinguishes multiple scrollables that share a single route.
+ * The key is always the same two-field composite, with an absent sub-key
+ * written as empty, so two different identities can never collapse onto one key
+ * by omission.
  *
- * Returns `null` when there is no route key to anchor against (the scrollable
- * is not inside a navigator), which the caller treats as "do not persist".
+ * Returns `null` when there is no content id to anchor against (the scrollable
+ * is not inside a navigator, or the adapter cannot answer), which every caller
+ * treats as "do not persist and do not restore".
  */
-export declare function deriveScrollKey(routeKey: string | undefined, subKey?: string): string | null;
+export declare function deriveScrollKey(contentId: string | null, subKey?: string): string | null;
 /**
  * In-memory map of `scrollKey -> last-known scroll offset`.
  *
- * Mirrors the semantics of Bluesky's `Map<screenKey, scrollY>`: offsets live
- * only for the lifetime of the document/session. We never persist them — a
- * full reload should start at the top — and we never auto-evict, because a
- * route can be revisited via browser Forward/Back long after it blurred.
+ * Offsets live only for the lifetime of the document/session. We never persist
+ * them — a full reload should start at the top — and we never auto-evict,
+ * because an entry can be revisited via browser Forward/Back long after it
+ * blurred.
+ *
+ * Deliberately an instance held in React context rather than a module-level
+ * singleton: a dependency tree can legitimately contain two copies of Bloom
+ * (a hoisted one plus a nested one under another Oxy package), and a
+ * module-global would then exist twice with no way for either half to see the
+ * other's offsets.
  */
 export declare class ScrollOffsetStore {
     private readonly offsets;
     /** Persist the offset for a key. A negative offset is clamped to 0. */
     save(key: string, offset: number): void;
     /**
-     * Read the saved offset for a key. Returns `0` when nothing was saved, so
-     * callers can restore unconditionally (an unseen list restores to the top).
+     * Read the saved offset for a key. Returns `0` when nothing was saved, which
+     * is the same value a caller writes when {@link has} is false — an unseen
+     * list restores to the top.
      */
     read(key: string): number;
-    /** Whether an offset was ever saved for this key. */
+    /**
+     * Whether an offset was ever saved for this key. This — not `read() > 0` —
+     * is what separates "restore" from "reset": a key that was never seen and a
+     * key deliberately saved at the top both read 0, and only the store knows
+     * which is which.
+     */
     has(key: string): boolean;
-    /** Drop a saved offset (e.g. when a route is permanently removed). */
+    /** Drop a saved offset (e.g. when an entry is permanently removed). */
     forget(key: string): void;
     /** Clear every saved offset. Primarily for tests and full resets. */
     clear(): void;

package/lib/typescript/commonjs/scroll/store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../../src/scroll/store.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAcH;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,MAAM,CAAC,EAAE,MAAM,GACd,MAAM,GAAG,IAAI,CAIf;AAED;;;;;;;GAOG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;IAErD,uEAAuE;IACvE,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAIvC;;;OAGG;IACH,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAIzB,qDAAqD;IACrD,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB,sEAAsE;IACtE,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAIzB,qEAAqE;IACrE,KAAK,IAAI,IAAI;IAIb,iDAAiD;IACjD,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../../src/scroll/store.ts"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,MAAM,GAAG,IAAI,EACxB,MAAM,CAAC,EAAE,MAAM,GACd,MAAM,GAAG,IAAI,CAGf;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;IAErD,uEAAuE;IACvE,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAIvC;;;;OAIG;IACH,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAIzB;;;;;OAKG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB,uEAAuE;IACvE,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAIzB,qEAAqE;IACrE,KAAK,IAAI,IAAI;IAIb,iDAAiD;IACjD,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}

package/lib/typescript/commonjs/scroll/types.d.ts

@@ -1,24 +1,31 @@
 import type { ReactNode, RefObject } from 'react';
+import type { NativeScrollEvent, NativeSyntheticEvent } from 'react-native';
 /**
  * Anything `useScrollRestoration` knows how to read/write a vertical scroll
  * offset from. The hook accepts a ref to one of these:
  *
- * - a React Native `ScrollView` / `FlatList` ref (which on web is backed by a
- *   DOM node and exposes `getScrollableNode()`),
+ * - a React Native `ScrollView` / `FlatList` / `FlashList` ref (which on web is
+ *   backed by a DOM node and exposes `getScrollableNode()`),
  * - a raw DOM element ref (when a component renders its own scroll container),
- * - the literal `'window'` sentinel, for the rare layout where the list IS the
- *   window scroller (matches Bluesky's default).
+ * - the literal `'window'` sentinel, for the layout where the list IS the
+ *   document scroller.
  *
- * Native never reads any of these — the native hook is a no-op — so the type is
- * intentionally permissive rather than coupled to a specific RN class.
+ * The two imperative methods are the native write path; web writes `scrollTop`
+ * on the resolved DOM node instead. Both are optional because a given ref only
+ * ever exposes one of them (list vs. scroll view).
  */
 export interface ScrollableHandle {
-    /** Imperative scroll API exposed by RN scrollables. */
+    /** `ScrollView`'s imperative scroll API. */
     scrollTo?: (options: {
         x?: number;
         y?: number;
         animated?: boolean;
     }) => void;
+    /** `FlatList`/`FlashList`'s imperative scroll API. */
+    scrollToOffset?: (options: {
+        offset: number;
+        animated?: boolean;
+    }) => void;
     /** Web/RNW path: returns the underlying DOM node. */
     getScrollableNode?: () => unknown;
 }
@@ -26,21 +33,84 @@ export interface ScrollableHandle {
  * The accepted ref shapes. `'window'` is a sentinel for the document scroller.
  */
 export type ScrollRestorationTarget = RefObject<ScrollableHandle | null> | RefObject<unknown> | 'window';
+/** The effect shape `useScreenFocusEffect` runs — mirrors `useEffect`'s. */
+export type ScreenFocusEffect = () => (() => void) | void;
+/**
+ * The router bindings the scroll core needs, and the ONLY thing it knows about
+ * routing. Keeping this to two hooks is what lets the core ship without a
+ * router import, so a Vite/SPA consumer can supply its own adapter (or none).
+ *
+ * Both members are HOOKS: the core calls them from `useScrollRestoration`, so
+ * the adapter value must be referentially stable for the lifetime of the
+ * provider (a module-level constant, which is what every adapter Bloom ships
+ * is). Swapping in a different adapter at runtime would change the hook order
+ * of every consumer below it.
+ */
+export interface ScrollRouterAdapter {
+    /**
+     * Identify WHAT the calling screen is showing — its route and params, not the
+     * history slot it occupies. Offsets are remembered per content, so returning
+     * to something already seen restores it however the user got there.
+     *
+     * It must describe the screen the CALLER is rendered inside, never the
+     * globally focused one: a background screen has to keep reporting its own
+     * content, or it would save its offset under the foreground screen's key.
+     *
+     * `null` when the adapter cannot answer (a scrollable rendered outside any
+     * navigator), which makes the hook inert rather than guessing.
+     */
+    useScreenContentId(): string | null;
+    /**
+     * Run `effect` while the calling screen is focused, and its cleanup on blur.
+     * Re-runs when `effect`'s identity changes AND the screen is focused — that
+     * is what makes an in-screen key change (a tab or folder swap) visible to a
+     * hook that never blurred.
+     */
+    useScreenFocusEffect(effect: ScreenFocusEffect): void;
+}
 export interface UseScrollRestorationOptions {
     /**
-     * Sub-key to disambiguate multiple scrollables that live on the same route
-     * (e.g. the tabs of a profile screen). Combined with the active route key to
-     * form the storage key. Omit when a route has a single scrollable.
+     * Sub-key distinguishing scrollables that share one screen AND one content
+     * id — the tabs of a profile, the folders of a saved-items screen. Changing
+     * it while the screen stays focused saves the outgoing list's offset and
+     * restores (or resets) the incoming one.
      */
     key?: string;
     /**
-     * When `false`, the hook is inert (saves and restores are skipped). Useful to
-     * gate restoration behind a feature flag without changing call sites.
+     * When `false` the hook is completely inert: no save, no restore, no reset.
+     *
+     * On NATIVE this is load-bearing rather than a feature flag. Restoring into a
+     * list whose rows have not been laid out yet lands at the wrong place (or is
+     * clamped away), and native has no equivalent of the web path's re-apply
+     * loop — so the caller gates on its own content being present, e.g.
+     * `enabled: rows.length > 0`. Flipping it from `false` to `true` is what
+     * triggers the restore.
+     *
      * Defaults to `true`.
      */
     enabled?: boolean;
 }
+/**
+ * What `useScrollRestoration` hands back. Identical on both platforms so call
+ * sites are written once.
+ */
+export interface ScrollRestorationBinding {
+    /**
+     * Wire onto the list being restored: `<FlashList onScroll={scroll.onScroll}>`.
+     *
+     * Native has no way to observe a list's offset from outside it, so this is
+     * how offsets are recorded there. On web it is a stable no-op — the web path
+     * subscribes to the resolved DOM node's own `scroll` event, which needs
+     * nothing from the caller — and passing it costs nothing.
+     */
+    onScroll: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
+}
 export interface ScrollRestorationProviderProps {
     children: ReactNode;
+    /**
+     * Binds the store to a router. Must be referentially stable — see
+     * {@link ScrollRouterAdapter}.
+     */
+    adapter: ScrollRouterAdapter;
 }
 //# sourceMappingURL=types.d.ts.map

package/lib/typescript/commonjs/scroll/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/scroll/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAElD;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,gBAAgB;IAC/B,uDAAuD;IACvD,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAC;IAC7E,qDAAqD;IACrD,iBAAiB,CAAC,EAAE,MAAM,OAAO,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,MAAM,uBAAuB,GAC/B,SAAS,CAAC,gBAAgB,GAAG,IAAI,CAAC,GAClC,SAAS,CAAC,OAAO,CAAC,GAClB,QAAQ,CAAC;AAEb,MAAM,WAAW,2BAA2B;IAC1C;;;;OAIG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,EAAE,SAAS,CAAC;CACrB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/scroll/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAClD,OAAO,KAAK,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAE5E;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,gBAAgB;IAC/B,4CAA4C;IAC5C,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAC;IAC7E,sDAAsD;IACtD,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAC;IAC3E,qDAAqD;IACrD,iBAAiB,CAAC,EAAE,MAAM,OAAO,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,MAAM,uBAAuB,GAC/B,SAAS,CAAC,gBAAgB,GAAG,IAAI,CAAC,GAClC,SAAS,CAAC,OAAO,CAAC,GAClB,QAAQ,CAAC;AAEb,4EAA4E;AAC5E,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAC;AAE1D;;;;;;;;;;GAUG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;;;;;;;;OAWG;IACH,kBAAkB,IAAI,MAAM,GAAG,IAAI,CAAC;IACpC;;;;;OAKG;IACH,oBAAoB,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAAC;CACvD;AAED,MAAM,WAAW,2BAA2B;IAC1C;;;;;OAKG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;GAGG;AACH,MAAM,WAAW,wBAAwB;IACvC;;;;;;;OAOG;IACH,QAAQ,EAAE,CAAC,KAAK,EAAE,oBAAoB,CAAC,iBAAiB,CAAC,KAAK,IAAI,CAAC;CACpE;AAED,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,EAAE,SAAS,CAAC;IACpB;;;OAGG;IACH,OAAO,EAAE,mBAAmB,CAAC;CAC9B"}

package/lib/typescript/commonjs/tabs/Tabs.d.ts

@@ -1,6 +1,46 @@
 import React from 'react';
 import type { TabsProps, TabsTriggerProps, TabsContentProps } from './types';
-export declare const Tabs: React.NamedExoticComponent<TabsProps>;
+/**
+ * The imperative surface a horizontal drag gesture drives the underline through.
+ *
+ * It lives here rather than in the gesture's own code because every quantity the
+ * drag needs — where the neighbouring trigger is, how wide it is, whether there
+ * IS a neighbour — is measured layout the strip already holds and nothing
+ * outside it can see. The gesture supplies one number, the finger's delta; the
+ * strip decides what that means.
+ *
+ * Obtained via a `ref` on `Tabs`. The gesture belongs in the LAYOUT beside the
+ * strip, never inside a tab screen — a gesture mounted in a screen is destroyed
+ * by the navigation it commits, mid-release.
+ */
+export interface TabsDragController {
+    /**
+     * Feed the raw horizontal finger delta (`translationX`).
+     *
+     * The underline travels OPPOSITE the finger, because that is where the
+     * incoming tab is: dragging left reveals the NEXT tab, which sits to the
+     * right. Travel is clamped at the neighbour — the underline stops exactly
+     * where it would land, so it never promises more than the release delivers —
+     * and at the first/last tab it rubber-bands instead.
+     *
+     * Returns the value that releasing NOW would commit, or `null` for "no
+     * commit": either the drag has not passed the threshold, or there is no
+     * neighbour in that direction.
+     */
+    drag(translationX: number): string | null;
+    /**
+     * End the drag. Pass the value `drag` last returned to keep the underline
+     * where the finger left it while the caller navigates; pass `null` to spring
+     * it home.
+     *
+     * On a commit the offset is FOLDED into the underline's base position rather
+     * than zeroed, so the focus change that follows springs from where the finger
+     * actually let go. Zeroing first would snap backwards for a frame and then
+     * animate forwards from the wrong place.
+     */
+    release(committed: string | null): void;
+}
+export declare const Tabs: React.NamedExoticComponent<TabsProps & React.RefAttributes<TabsDragController>>;
 export declare const TabsTrigger: React.NamedExoticComponent<TabsTriggerProps>;
 export declare const TabsContent: React.NamedExoticComponent<TabsContentProps>;
 //# sourceMappingURL=Tabs.d.ts.map

package/lib/typescript/commonjs/tabs/Tabs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Tabs.d.ts","sourceRoot":"","sources":["../../../../src/tabs/Tabs.tsx"],"names":[],"mappings":"AAAA,OAAO,KAQN,MAAM,OAAO,CAAC;AAiBf,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,gBAAgB,EAAe,MAAM,SAAS,CAAC;AA4Q1F,eAAO,MAAM,IAAI,uCAAyB,CAAC;AAG3C,eAAO,MAAM,WAAW,8CAAqB,CAAC;AAG9C,eAAO,MAAM,WAAW,8CAA0B,CAAC"}
+{"version":3,"file":"Tabs.d.ts","sourceRoot":"","sources":["../../../../src/tabs/Tabs.tsx"],"names":[],"mappings":"AAAA,OAAO,KAUN,MAAM,OAAO,CAAC;AA4Bf,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,gBAAgB,EAAe,MAAM,SAAS,CAAC;AAwD1F;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;;;;;;;;;OAYG;IACH,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAC1C;;;;;;;;;OASG;IACH,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;CACzC;AAmbD,eAAO,MAAM,IAAI,iFAAyB,CAAC;AAG3C,eAAO,MAAM,WAAW,8CAAqB,CAAC;AAG9C,eAAO,MAAM,WAAW,8CAA0B,CAAC"}

package/lib/typescript/commonjs/tabs/expo-router/RouterTabs.d.ts

@@ -0,0 +1,80 @@
+/**
+ * expo-router bindings for the in-screen tab strip.
+ *
+ * This subpath (`@oxyhq/bloom/tabs/expo-router`) is the ONLY place in the tabs
+ * feature allowed to import `expo-router`, which is why it is a separate entry:
+ * the core `@oxyhq/bloom/tabs` stays usable in an app with a different router,
+ * or none, and the optional peer is never pulled into a bundle that does not
+ * ask for it. Same split as `tab-bar` / `tab-bar/expo-router` and
+ * `scroll` / `scroll/expo-router`.
+ *
+ * Everything routing-shaped lives here on purpose: which tab the route means,
+ * what a committed swipe navigates to, and which links to warm. The strip
+ * itself stays presentational and knows only about measured geometry.
+ */
+import { type ReactNode } from 'react';
+import { type Href } from 'expo-router';
+import type { TabsProps } from '../types';
+export interface RouterTabItem {
+    /** Stable id for the tab. Used as a React key and a callback argument. */
+    value: string;
+    /** Tab label text. */
+    label: string;
+    /** The route this tab shows. Must be the tab's EXACT path. */
+    href: Href;
+    /** Icon rendered before the label. */
+    icon?: ReactNode;
+    /** Optional tally beside the label; `0` or omitted renders nothing. */
+    count?: number;
+    disabled?: boolean;
+}
+export type RouterTabsProps = Omit<TabsProps, 'value' | 'onValueChange' | 'hasSelection' | 'children'> & {
+    items: RouterTabItem[];
+    /**
+     * Called instead of navigating when the ALREADY-active tab is pressed.
+     *
+     * Without it a re-tap would push a second history entry for the route the
+     * user is already on, so Back would appear to do nothing. Re-tapping the
+     * active tab conventionally means "refresh" or "scroll to top", and that is
+     * the caller's to define.
+     */
+    onReselect?: (value: string) => void;
+    /**
+     * Enable the horizontal swipe between neighbouring tabs. Defaults to `true`.
+     *
+     * The gesture is INDICATOR-LED: the underline tracks the finger toward the
+     * neighbour and commits on release past a threshold, while the content stays
+     * where it is. That asymmetry is deliberate — the underline has somewhere
+     * real to go and can complete its journey, whereas under a `<Slot/>` there is
+     * no neighbouring screen mounted to bring in, so translating the content
+     * would only open a blank gutter on the trailing edge.
+     */
+    swipeEnabled?: boolean;
+};
+/**
+ * A tab strip whose selection IS the route.
+ *
+ * Render it in the LAYOUT that owns the tabs, above the `<Slot/>` that renders
+ * them — not inside the tab screens themselves. That placement is the whole
+ * point, and it is load-bearing twice over: a strip inside the screens is
+ * unmounted and rebuilt by every navigation, so its underline has nothing to
+ * animate from and the chrome blanks while the incoming route's chunk loads;
+ * and a GESTURE inside the screens would be destroyed by the very navigation it
+ * commits, mid-release.
+ *
+ * ```tsx
+ * // app/(app)/[username]/_layout.tsx
+ * <RouterTabs
+ *   items={[
+ *     { value: 'posts', label: 'Posts', href: `/${username}` },
+ *     { value: 'replies', label: 'Replies', href: `/${username}/replies` },
+ *   ]}
+ * />
+ * <Slot />
+ * ```
+ */
+export declare function RouterTabs({ items, onReselect, swipeEnabled, ...tabsProps }: RouterTabsProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace RouterTabs {
+    var displayName: string;
+}
+//# sourceMappingURL=RouterTabs.d.ts.map

package/lib/typescript/commonjs/tabs/expo-router/RouterTabs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RouterTabs.d.ts","sourceRoot":"","sources":["../../../../../src/tabs/expo-router/RouterTabs.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAA2C,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAGhF,OAAO,EAAuB,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAG7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE1C,MAAM,WAAW,aAAa;IAC5B,0EAA0E;IAC1E,KAAK,EAAE,MAAM,CAAC;IACd,sBAAsB;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,8DAA8D;IAC9D,IAAI,EAAE,IAAI,CAAC;IACX,sCAAsC;IACtC,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,uEAAuE;IACvE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,MAAM,eAAe,GAAG,IAAI,CAChC,SAAS,EAGT,OAAO,GAAG,eAAe,GAAG,cAAc,GAAG,UAAU,CACxD,GAAG;IACF,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC;;;;;;;;;OASG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAuCF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,UAAU,CAAC,EACzB,KAAK,EACL,UAAU,EACV,YAAmB,EACnB,GAAG,SAAS,EACb,EAAE,eAAe,2CAwIjB;yBA7Ie,UAAU"}

package/lib/typescript/commonjs/tabs/expo-router/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Entry for `@oxyhq/bloom/tabs/expo-router`. The component lives in a sibling
+ * module because this file is the published entry path and must stay stable;
+ * the split also keeps the router binding in one place, which is what the
+ * optional-peer allowlist asserts about.
+ */
+export { RouterTabs } from './RouterTabs';
+export type { RouterTabItem, RouterTabsProps } from './RouterTabs';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/tabs/expo-router/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/tabs/expo-router/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC"}

package/lib/typescript/commonjs/tabs/types.d.ts

@@ -1,10 +1,38 @@
 import type { StyleProp, ViewStyle, TextStyle } from 'react-native';
 export type TabsVariant = 'underline' | 'filled' | 'outlined';
 export interface TabsProps {
-    /** The currently selected tab value. */
-    value: string;
-    /** Called when a tab is selected. */
-    onValueChange: (value: string) => void;
+    /**
+     * The currently selected tab value — the CONTROLLED path, where the bar owns
+     * the underline and reports presses through {@link TabsProps.onValueChange}.
+     *
+     * OMIT it for the focus-driven path, where each trigger supplies its own
+     * {@link TabsTriggerProps.isFocused} and performs its own navigation. That is
+     * how `@oxyhq/bloom/tabs/expo-router` keeps the underline correct through
+     * deep links, browser Back and back gestures — none of which pass through a
+     * press handler. Providing both would put two writers on one shared value.
+     */
+    value?: string;
+    /** Called when a tab is selected. Controlled path only. */
+    onValueChange?: (value: string) => void;
+    /**
+     * Focus-driven path only: whether ANY trigger is currently focused.
+     *
+     * `false` fades the underline out where it stands. This is not the same as
+     * "the selection moved", and it is not hypothetical: a strip rendered by a
+     * LAYOUT keeps rendering while the layout's other, non-tab children are
+     * showing — a profile's `/followers` sits beside its tab routes under one
+     * layout — and without this the underline stays parked on whichever tab was
+     * last visited, asserting a selection that is not there.
+     *
+     * Fading is the whole response; the underline is deliberately NOT moved,
+     * because there is no position that means "nowhere" and travelling to a
+     * sentinel would drag it across every tab on the way out.
+     *
+     * `RouterTabs` sets it, so an app author never passes it by hand. Defaults to
+     * `true`, which is correct for the controlled path (a `value` naming no
+     * trigger simply leaves the underline where it was, as it always has).
+     */
+    hasSelection?: boolean;
     /** Visual variant for the tab bar. */
     variant?: TabsVariant;
     /**
@@ -26,8 +54,24 @@ export interface TabsTriggerProps {
     label: string;
     /** Icon rendered before the label. */
     icon?: React.ReactNode;
+    /**
+     * Optional tally rendered as a small muted number beside the label. Omitted
+     * (or `0`) renders nothing. The underline tracks the trigger's measured
+     * width, so a count never changes where it sits.
+     */
+    count?: number;
+    /**
+     * Whether the ROUTER considers this tab focused — the focus-driven path.
+     * Supplying it makes this trigger, not the bar, the writer of the shared
+     * underline, and suppresses {@link TabsProps.onValueChange} on press because
+     * navigation is then the caller's job. Leave it `undefined` on the controlled
+     * path.
+     */
+    isFocused?: boolean;
     /** Whether this tab is disabled. */
     disabled?: boolean;
+    /** Extra press handler. Runs on both paths, before any selection is reported. */
+    onPress?: () => void;
     style?: StyleProp<ViewStyle>;
     textStyle?: StyleProp<TextStyle>;
 }

package/lib/typescript/commonjs/tabs/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/tabs/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEpE,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE9D,MAAM,WAAW,SAAS;IACxB,wCAAwC;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,qCAAqC;IACrC,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,sCAAsC;IACtC,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,qDAAqD;IACrD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,gBAAgB;IAC/B,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,sBAAsB;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,sCAAsC;IACtC,IAAI,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IACvB,oCAAoC;IACpC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IAC7B,SAAS,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,gBAAgB;IAC/B,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAC;IACd,qBAAqB;IACrB,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;CAC9B"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/tabs/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEpE,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE9D,MAAM,WAAW,SAAS;IACxB;;;;;;;;;OASG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2DAA2D;IAC3D,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC;;;;;;;;;;;;;;;;;OAiBG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,sCAAsC;IACtC,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,qDAAqD;IACrD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,gBAAgB;IAC/B,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,sBAAsB;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,sCAAsC;IACtC,IAAI,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IACvB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,oCAAoC;IACpC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iFAAiF;IACjF,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IAC7B,SAAS,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,gBAAgB;IAC/B,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAC;IACd,qBAAqB;IACrB,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;CAC9B"}

package/lib/typescript/commonjs/theme/color-policy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"color-policy.d.ts","sourceRoot":"","sources":["../../../../src/theme/color-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,EAAe,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAK9D,sFAAsF;AACtF,eAAO,MAAM,YAAY;;;;;CAKf,CAAC;AAEX,wFAAwF;AACxF,MAAM,WAAW,aAAa;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,kFAAkF;AAClF,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAiPlD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,OAAO,EACf,KAAK,EAAE,UAAU,EACjB,MAAM,GAAE,aAAkB,GACzB,YAAY,CAgHd"}
+{"version":3,"file":"color-policy.d.ts","sourceRoot":"","sources":["../../../../src/theme/color-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,EAAe,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAK9D,sFAAsF;AACtF,eAAO,MAAM,YAAY;;;;;CAKf,CAAC;AAEX,wFAAwF;AACxF,MAAM,WAAW,aAAa;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,kFAAkF;AAClF,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAkPlD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,OAAO,EACf,KAAK,EAAE,UAAU,EACjB,MAAM,GAAE,aAAkB,GACzB,YAAY,CAgHd"}

package/lib/typescript/module/provider/index.d.ts

@@ -18,11 +18,13 @@
  * Nesting extra contexts costs nothing at runtime — the win is that scope is no
  * longer a per-app decision.
  *
- * EXPO/EXPO-ROUTER APPS ONLY. The scroll-restoration provider it mounts imports
- * `expo-router` (its web implementation keys offsets on the focused route), so
- * a Vite/SPA consumer that has no expo-router cannot resolve this module. Those
- * apps keep mounting `BloomThemeProvider` (and any other piece they need)
- * directly — that is not a lesser path, just the one without a router.
+ * EXPO/EXPO-ROUTER APPS ONLY, and now for one narrow reason: it binds the
+ * scroll store to the expo-router ADAPTER, which is the only module in the
+ * scroll primitive that imports `expo-router`. The scroll core itself is
+ * router-agnostic, so a Vite/SPA consumer can mount
+ * `<ScrollRestorationProvider adapter={...}>` from `@oxyhq/bloom/scroll` with
+ * an adapter for its own router — alongside `BloomThemeProvider` and whatever
+ * else it needs — rather than going without.
  *
  * NOT included, on purpose — these are OUTLETS, not state, and their placement
  * in the tree is a real app decision (z-order, safe areas, and mounting a

package/lib/typescript/module/provider/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/provider/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,OAAO,EAAyB,KAAK,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAG9E,OAAO,EAAsB,KAAK,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAG5E,MAAM,WAAW,kBAAmB,SAAQ,IAAI,CAAC,uBAAuB,EAAE,UAAU,CAAC;IACnF,QAAQ,EAAE,SAAS,CAAC;IACpB;;;;OAIG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,wFAAwF;IACxF,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,wBAAgB,aAAa,CAAC,EAC5B,QAAQ,EACR,aAAa,EACb,OAAc,EACd,GAAG,UAAU,EACd,EAAE,kBAAkB,2CAcpB;yBAnBe,aAAa"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/provider/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,OAAO,EAAyB,KAAK,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAG9E,OAAO,EAAsB,KAAK,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAI5E,MAAM,WAAW,kBAAmB,SAAQ,IAAI,CAAC,uBAAuB,EAAE,UAAU,CAAC;IACnF,QAAQ,EAAE,SAAS,CAAC;IACpB;;;;OAIG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,wFAAwF;IACxF,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,wBAAgB,aAAa,CAAC,EAC5B,QAAQ,EACR,aAAa,EACb,OAAc,EACd,GAAG,UAAU,EACd,EAAE,kBAAkB,2CAcpB;yBAnBe,aAAa"}

package/lib/typescript/module/scroll/context.d.ts

@@ -0,0 +1,14 @@
+import { ScrollOffsetStore } from './store';
+import type { ScrollRestorationProviderProps, ScrollRouterAdapter } from './types';
+export interface ScrollRestorationContextValue {
+    store: ScrollOffsetStore;
+    adapter: ScrollRouterAdapter;
+}
+/**
+ * Holds the offset map and the router binding for the subtree. One provider
+ * near the app root is enough; the store lives as long as the provider, so
+ * offsets survive navigating away and back (including browser Back/Forward).
+ */
+export declare function ScrollRestorationProvider({ children, adapter, }: ScrollRestorationProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useScrollRestorationContext(): ScrollRestorationContextValue;
+//# sourceMappingURL=context.d.ts.map

package/lib/typescript/module/scroll/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../../src/scroll/context.tsx"],"names":[],"mappings":"AAWA,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,KAAK,EACV,8BAA8B,EAC9B,mBAAmB,EACpB,MAAM,SAAS,CAAC;AAEjB,MAAM,WAAW,6BAA6B;IAC5C,KAAK,EAAE,iBAAiB,CAAC;IACzB,OAAO,EAAE,mBAAmB,CAAC;CAC9B;AAMD;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,EACxC,QAAQ,EACR,OAAO,GACR,EAAE,8BAA8B,2CAWhC;AAED,wBAAgB,2BAA2B,IAAI,6BAA6B,CAQ3E"}

package/lib/typescript/module/scroll/expo-router/index.d.ts

@@ -0,0 +1,7 @@
+import type { ScrollRouterAdapter } from '../types';
+/**
+ * The adapter to hand `<ScrollRestorationProvider adapter={...}>` in an
+ * expo-router app. A module-level constant, as the adapter contract requires.
+ */
+export declare const expoRouterScrollAdapter: ScrollRouterAdapter;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/scroll/expo-router/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/scroll/expo-router/index.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAqB,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAkHvE;;;GAGG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAGrC,CAAC"}

package/lib/typescript/module/scroll/index.d.ts

@@ -1,27 +1,18 @@
+import type { ScrollRestorationBinding, ScrollRestorationTarget, UseScrollRestorationOptions } from './types';
+export { ScrollRestorationProvider } from './context';
+export type { ScreenFocusEffect, ScrollableHandle, ScrollRestorationBinding, ScrollRestorationProviderProps, ScrollRestorationTarget, ScrollRouterAdapter, UseScrollRestorationOptions, } from './types';
 /**
- * Native variant of the scroll-restoration primitive — a deliberate no-op.
+ * Preserve and restore the scroll offset of `target` across content changes,
+ * keyed by the content its screen is showing plus an optional `options.key`.
  *
- * React Navigation's native-stack keeps every screen mounted while it is in the
- * stack, so a list's scroll position survives a push/pop for free. There is
- * nothing to save or restore. We still ship the full API surface (provider +
- * hook) so consumers write one set of call sites that compile and run on every
- * platform; on native the provider just renders its children and the hook does
- * nothing.
- *
- * Web bundlers select `./index.web` via the `"browser"` export condition in
- * `package.json`; native bundlers fall through to this file.
- */
-import type { ReactElement } from 'react';
-import type { ScrollRestorationProviderProps, ScrollRestorationTarget, UseScrollRestorationOptions } from './types';
-export type { ScrollableHandle, ScrollRestorationProviderProps, ScrollRestorationTarget, UseScrollRestorationOptions, } from './types';
-/**
- * No-op provider. Renders children unchanged — native scroll persistence is
- * handled by the navigator, so no per-route state is kept.
- */
-export declare function ScrollRestorationProvider({ children, }: ScrollRestorationProviderProps): ReactElement;
-/**
- * No-op hook. Accepts the same arguments as the web implementation so call
- * sites are identical across platforms.
+ * Behaviour (native):
+ * - Offsets are recorded from the returned `onScroll` binding, which the caller
+ *   wires onto the list. There is no other way to observe a list's offset.
+ * - When the storage key changes — a re-keyed list, a remount, or `enabled`
+ *   turning on — the saved offset is applied, or 0 when the key was never seen.
+ * - A push/pop that re-focuses the same screen scrolls nothing. The navigator
+ *   already preserved the position, and re-applying it would at best be a
+ *   no-op and at worst fight a list that has legitimately moved on.
  */
-export declare function useScrollRestoration(_target: ScrollRestorationTarget, _options?: UseScrollRestorationOptions): void;
+export declare function useScrollRestoration(target: ScrollRestorationTarget, options?: UseScrollRestorationOptions): ScrollRestorationBinding;
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/scroll/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/scroll/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AAC1C,OAAO,KAAK,EACV,8BAA8B,EAC9B,uBAAuB,EACvB,2BAA2B,EAC5B,MAAM,SAAS,CAAC;AAEjB,YAAY,EACV,gBAAgB,EAChB,8BAA8B,EAC9B,uBAAuB,EACvB,2BAA2B,GAC5B,MAAM,SAAS,CAAC;AAEjB;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,EACxC,QAAQ,GACT,EAAE,8BAA8B,GAAG,YAAY,CAE/C;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,uBAAuB,EAChC,QAAQ,CAAC,EAAE,2BAA2B,GACrC,IAAI,CAEN"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/scroll/index.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EACV,wBAAwB,EACxB,uBAAuB,EACvB,2BAA2B,EAC5B,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,yBAAyB,EAAE,MAAM,WAAW,CAAC;AAEtD,YAAY,EACV,iBAAiB,EACjB,gBAAgB,EAChB,wBAAwB,EACxB,8BAA8B,EAC9B,uBAAuB,EACvB,mBAAmB,EACnB,2BAA2B,GAC5B,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,uBAAuB,EAC/B,OAAO,CAAC,EAAE,2BAA2B,GACpC,wBAAwB,CAyD1B"}