@sigx/lynx-navigation 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Andreas Ekdahl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/components/EdgeBackHandle.d.ts

@@ -0,0 +1,2 @@
+export declare const EdgeBackHandle: import("@sigx/runtime-core").ComponentFactory<{}, void, unknown>;
+//# sourceMappingURL=EdgeBackHandle.d.ts.map

package/dist/components/EdgeBackHandle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EdgeBackHandle.d.ts","sourceRoot":"","sources":["../../src/components/EdgeBackHandle.tsx"],"names":[],"mappings":"AA+DA,eAAO,MAAM,cAAc,kEAiGzB,CAAC"}

package/dist/components/Link.d.ts

@@ -0,0 +1,61 @@
+import type { RouteId, RouteParams, RouteSearch } from '../register.js';
+import type { RoutesWithParams } from '../hooks/use-nav.js';
+/**
+ * Per-route conditional props for `<Link>`.
+ *
+ * Mapped over `RouteId`, then indexed by `RouteId` to flatten into a union.
+ * Each branch enforces the `params`-required-iff-route-has-schema rule:
+ *
+ *   - `<Link to="profile" />`             → TS error (profile requires params)
+ *   - `<Link to="profile" params={...} />` → ok
+ *   - `<Link to="home" />`                → ok (home has no params)
+ *   - `<Link to="home" params={...} />`   → TS error (home accepts no params)
+ *
+ * Same per-route discrimination as `nav.push`, expressed as a JSX-friendly
+ * union rather than overloads.
+ */
+type LinkPropsByRoute = {
+    [K in RouteId]: K extends RoutesWithParams ? {
+        to: K;
+        params: RouteParams<K>;
+        search?: RouteSearch<K>;
+    } : {
+        to: K;
+        params?: undefined;
+        search?: RouteSearch<K>;
+    };
+}[RouteId];
+/**
+ * Public type for `<Link>`'s props. The conditional `LinkPropsByRoute` carries
+ * the typed `to`/`params`/`search` triple; the rest are simple optionals.
+ *
+ * `children` is declared explicitly because the public type is exposed via a
+ * type-cast (so JSX sees a function-shaped signature). The cast strips sigx's
+ * built-in `Define.Slot<'default'>` → JSX-children wiring, so we add a
+ * permissive `children?` slot ourselves.
+ */
+export type LinkProps = LinkPropsByRoute & {
+    /** Use `replace` instead of `push` (no new history entry). */
+    replace?: boolean;
+    /** Link content rendered inside the tappable container. */
+    children?: unknown;
+};
+/**
+ * Declarative navigation. Same typing as `nav.push` — pass `params` only when
+ * the route declares a schema. Wraps a `<view>` that fires `nav.push` (or
+ * `nav.replace` if `replace` is set) on tap.
+ *
+ * @example
+ * ```tsx
+ * <Link to="home">Home</Link>
+ * <Link to="profile" params={{ id: '42' }}>View profile</Link>
+ * <Link to="profile" params={{ id: '42' }} search={{ tab: 'about' }}>About</Link>
+ * <Link to="settings" replace>Settings (no back)</Link>
+ * ```
+ *
+ * The cast widens the inferred prop type from the loose impl to the strict
+ * `LinkProps` so JSX usage gets per-route discrimination. Runtime is identical.
+ */
+export declare const Link: (props: LinkProps) => unknown;
+export {};
+//# sourceMappingURL=Link.d.ts.map

package/dist/components/Link.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Link.d.ts","sourceRoot":"","sources":["../../src/components/Link.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACxE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D;;;;;;;;;;;;;GAaG;AACH,KAAK,gBAAgB,GAAG;KACnB,CAAC,IAAI,OAAO,GAAG,CAAC,SAAS,gBAAgB,GACpC;QAAE,EAAE,EAAE,CAAC,CAAC;QAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;QAAC,MAAM,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAA;KAAE,GAC1D;QAAE,EAAE,EAAE,CAAC,CAAC;QAAC,MAAM,CAAC,EAAE,SAAS,CAAC;QAAC,MAAM,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAA;KAAE;CAC/D,CAAC,OAAO,CAAC,CAAC;AAEX;;;;;;;;GAQG;AACH,MAAM,MAAM,SAAS,GAAG,gBAAgB,GAAG;IACvC,8DAA8D;IAC9D,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAwDF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,IAAI,EAA0B,CAAC,KAAK,EAAE,SAAS,KAAK,OAAO,CAAC"}

package/dist/components/Link.js

@@ -0,0 +1,54 @@
+import { jsx as _jsx } from "@sigx/lynx/jsx-runtime";
+import { component } from '@sigx/lynx';
+import { useNav } from '../hooks/use-nav.js';
+import { useNavRoutes } from '../hooks/use-nav-internal.js';
+const LinkImpl = component(({ props, slots }) => {
+    const nav = useNav();
+    const routes = useNavRoutes();
+    const handlePress = () => {
+        const route = props.to;
+        const routeDef = routes[route];
+        if (!routeDef) {
+            // Defensive: prop was typed against the registry, so this shouldn't
+            // happen at runtime — but if it does (e.g. a stale Link survived a
+            // route removal), surface a clear error rather than crashing on
+            // the navigator's lookup.
+            throw new Error(`[lynx-navigation] <Link to='${route}'>: route is not registered.`);
+        }
+        const hasParams = !!routeDef.params;
+        const action = props.replace ? nav.replace : nav.push;
+        // Branch on whether the route declares a params schema so positional
+        // args land correctly: routes-with-params shift everything one slot
+        // (push/replace overload signatures `(name, params, search?, options?)`
+        // vs `(name, search?, options?)`). Calling the wrong shape silently
+        // puts `search` into the `options` slot.
+        if (hasParams) {
+            action(route, props.params, props.search);
+        }
+        else {
+            action(route, props.search);
+        }
+    };
+    return () => (
+    // `bindtap` is correct here because the underlying element is a Lynx
+    // native `<view>` — sigx component-level events would use `onPress`.
+    _jsx("view", { bindtap: handlePress, children: slots.default?.() }));
+}, { name: 'Link' });
+/**
+ * Declarative navigation. Same typing as `nav.push` — pass `params` only when
+ * the route declares a schema. Wraps a `<view>` that fires `nav.push` (or
+ * `nav.replace` if `replace` is set) on tap.
+ *
+ * @example
+ * ```tsx
+ * <Link to="home">Home</Link>
+ * <Link to="profile" params={{ id: '42' }}>View profile</Link>
+ * <Link to="profile" params={{ id: '42' }} search={{ tab: 'about' }}>About</Link>
+ * <Link to="settings" replace>Settings (no back)</Link>
+ * ```
+ *
+ * The cast widens the inferred prop type from the loose impl to the strict
+ * `LinkProps` so JSX usage gets per-route discrimination. Runtime is identical.
+ */
+export const Link = LinkImpl;
+//# sourceMappingURL=Link.js.map

package/dist/components/Link.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Link.js","sourceRoot":"","sources":["../../src/components/Link.tsx"],"names":[],"mappings":";AAAA,OAAO,EAAE,SAAS,EAAe,MAAM,YAAY,CAAC;AACpD,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAqD5D,MAAM,QAAQ,GAAG,SAAS,CAAiB,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE;IAC5D,MAAM,GAAG,GAAG,MAAM,EAAE,CAAC;IACrB,MAAM,MAAM,GAAG,YAAY,EAAE,CAAC;IAE9B,MAAM,WAAW,GAAG,GAAS,EAAE;QAC3B,MAAM,KAAK,GAAG,KAAK,CAAC,EAAE,CAAC;QACvB,MAAM,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAC/B,IAAI,CAAC,QAAQ,EAAE,CAAC;YACZ,oEAAoE;YACpE,mEAAmE;YACnE,gEAAgE;YAChE,0BAA0B;YAC1B,MAAM,IAAI,KAAK,CACX,+BAA+B,KAAK,8BAA8B,CACrE,CAAC;QACN,CAAC;QACD,MAAM,SAAS,GAAG,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC;QACpC,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC;QACtD,qEAAqE;QACrE,oEAAoE;QACpE,wEAAwE;QACxE,oEAAoE;QACpE,yCAAyC;QACzC,IAAI,SAAS,EAAE,CAAC;YACX,MAAuD,CACpD,KAAK,EACL,KAAK,CAAC,MAAM,EACZ,KAAK,CAAC,MAAM,CACf,CAAC;QACN,CAAC;aAAM,CAAC;YACH,MAA2C,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;QACtE,CAAC;IACL,CAAC,CAAC;IAEF,OAAO,GAAG,EAAE,CAAC;IACT,qEAAqE;IACrE,qEAAqE;IACrE,eAAM,OAAO,EAAE,WAAW,YAAG,KAAK,CAAC,OAAO,EAAE,EAAE,GAAQ,CACzD,CAAC;AACN,CAAC,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC;AAErB;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,QAAoD,CAAC"}

package/dist/components/NavigationRoot.d.ts

@@ -0,0 +1,37 @@
+import { type Define } from '@sigx/lynx';
+import type { RouteId } from '../register.js';
+import type { RouteMap } from '../types.js';
+type NavigationRootProps = Define.Prop<'routes', RouteMap, true> & Define.Prop<'initialRoute', RouteId> & Define.Prop<'initialParams', Record<string, unknown>> & Define.Prop<'initialSearch', Record<string, unknown>>
+/**
+ * Enable slide-from-right transitions on push/pop. Defaults to true.
+ * Tests against `@sigx/testing-lynx` (which doesn't have an MT runtime)
+ * should pass `animated={false}` so navigations commit synchronously.
+ */
+ & Define.Prop<'animated', boolean>
+/**
+ * Enable the iOS-style edge-swipe-back gesture. Defaults to true. Set
+ * to false if it conflicts with screen content on the leftmost 20px,
+ * or while debugging gesture issues.
+ */
+ & Define.Prop<'edgeSwipeEnabled', boolean> & Define.Slot<'default'>;
+/**
+ * Root of a navigator subtree.
+ *
+ * Creates a fresh `NavigatorState` from `routes` and provides it via
+ * `defineProvide`, so descendant `<Stack>` / `<Screen>` components and any
+ * `useNav()` / `useParams()` calls resolve through this instance.
+ *
+ * The bottom-of-stack entry is built from `initialRoute` (defaults to the
+ * first key in `routes`). For routes that declare a params schema, you must
+ * pass `initialParams` matching that schema.
+ *
+ * Mirrors the install pattern of `@sigx/router` (see
+ * `packages/router/src/router.ts:519-528`), but at component scope rather than
+ * `app.use(router)` — no app-wide singleton, so multi-navigator apps and
+ * tests get isolated state for free.
+ */
+export declare const NavigationRoot: import("@sigx/runtime-core").ComponentFactory<NavigationRootProps, void, {
+    default: () => import("@sigx/runtime-core").JSXElement | import("@sigx/runtime-core").JSXElement[] | null;
+}>;
+export {};
+//# sourceMappingURL=NavigationRoot.d.ts.map

package/dist/components/NavigationRoot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NavigationRoot.d.ts","sourceRoot":"","sources":["../../src/components/NavigationRoot.tsx"],"names":[],"mappings":"AAAA,OAAO,EAA4C,KAAK,MAAM,EAAE,MAAM,YAAY,CAAC;AAInF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,KAAK,EAAgB,QAAQ,EAAc,MAAM,aAAa,CAAC;AAEtE,KAAK,mBAAmB,GAClB,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,CAAC,GACrC,MAAM,CAAC,IAAI,CAAC,cAAc,EAAE,OAAO,CAAC,GACpC,MAAM,CAAC,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACrD,MAAM,CAAC,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AACvD;;;;GAIG;GACD,MAAM,CAAC,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC;AAClC;;;;GAIG;GACD,MAAM,CAAC,IAAI,CAAC,kBAAkB,EAAE,OAAO,CAAC,GACxC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AAE7B;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc;;EA0CzB,CAAC"}

package/dist/components/NavigationRoot.js

@@ -0,0 +1,41 @@
+import { component, defineProvide } from '@sigx/lynx';
+import { createNavigatorState } from '../navigator/core.js';
+import { useNav } from '../hooks/use-nav.js';
+import { useNavRoutes } from '../hooks/use-nav-internal.js';
+/**
+ * Root of a navigator subtree.
+ *
+ * Creates a fresh `NavigatorState` from `routes` and provides it via
+ * `defineProvide`, so descendant `<Stack>` / `<Screen>` components and any
+ * `useNav()` / `useParams()` calls resolve through this instance.
+ *
+ * The bottom-of-stack entry is built from `initialRoute` (defaults to the
+ * first key in `routes`). For routes that declare a params schema, you must
+ * pass `initialParams` matching that schema.
+ *
+ * Mirrors the install pattern of `@sigx/router` (see
+ * `packages/router/src/router.ts:519-528`), but at component scope rather than
+ * `app.use(router)` — no app-wide singleton, so multi-navigator apps and
+ * tests get isolated state for free.
+ */
+export const NavigationRoot = component(({ props, slots }) => {
+    const routes = props.routes;
+    const initialName = props.initialRoute ?? Object.keys(routes)[0];
+    if (!routes[initialName]) {
+        throw new Error(`[lynx-navigation] <NavigationRoot> initialRoute='${initialName}' is not in the routes registry.`);
+    }
+    const initialPresentation = routes[initialName].presentation ?? 'card';
+    const initial = {
+        key: 'root',
+        route: initialName,
+        params: props.initialParams ?? {},
+        search: props.initialSearch ?? {},
+        state: undefined,
+        presentation: initialPresentation,
+    };
+    const navState = createNavigatorState(routes, initial);
+    defineProvide(useNav, () => navState.nav);
+    defineProvide(useNavRoutes, () => navState.routes);
+    return () => slots.default?.();
+});
+//# sourceMappingURL=NavigationRoot.js.map

package/dist/components/NavigationRoot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NavigationRoot.js","sourceRoot":"","sources":["../../src/components/NavigationRoot.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAe,MAAM,YAAY,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAW5D;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,SAAS,CAAsB,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE;IAC9E,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;IAC5B,MAAM,WAAW,GAAW,KAAK,CAAC,YAAY,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IACzE,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC;QACvB,MAAM,IAAI,KAAK,CACX,oDAAoD,WAAW,kCAAkC,CACpG,CAAC;IACN,CAAC;IACD,MAAM,mBAAmB,GAAiB,MAAM,CAAC,WAAW,CAAC,CAAC,YAAY,IAAI,MAAM,CAAC;IACrF,MAAM,OAAO,GAAe;QACxB,GAAG,EAAE,MAAM;QACX,KAAK,EAAE,WAAW;QAClB,MAAM,EAAE,KAAK,CAAC,aAAa,IAAI,EAAE;QACjC,MAAM,EAAE,KAAK,CAAC,aAAa,IAAI,EAAE;QACjC,KAAK,EAAE,SAAS;QAChB,YAAY,EAAE,mBAAmB;KACpC,CAAC;IAEF,MAAM,QAAQ,GAAG,oBAAoB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEvD,aAAa,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;IAC1C,aAAa,CAAC,YAAY,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IAEnD,OAAO,GAAG,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE,EAAE,CAAC;AACnC,CAAC,CAAC,CAAC"}

package/dist/components/ScreenContainer.d.ts

@@ -0,0 +1,18 @@
+import { type ComponentFactory, type Define, type SharedValue } from '@sigx/lynx';
+import type { RouteMap, StackEntry, TransitionKind, TransitionRole } from '../types.js';
+type ScreenContainerProps = Define.Prop<'entry', StackEntry, true> & Define.Prop<'routes', RouteMap, true> & Define.Prop<'role', TransitionRole, true> & Define.Prop<'kind', TransitionKind, true> & Define.Prop<'progress', SharedValue<number>, true>;
+/**
+ * Animated screen slot — absolutely positioned, MT-bound translateX driven by
+ * the navigator's progress SharedValue. Used during transitions to render the
+ * top + underneath entries together.
+ *
+ * Each instance is keyed by `${entry.key}-${role}-${kind}` in the parent so a
+ * role/kind change forces a fresh mount with a fresh `useAnimatedStyle`
+ * binding (the binding is set at setup and can't be re-keyed mid-life). State
+ * loss across transition boundaries is accepted in v0.2; persistent screen
+ * state (scroll position, input fields surviving navigations) is a polish
+ * item for Phase 0.5+.
+ */
+export declare const ScreenContainer: ComponentFactory<ScreenContainerProps, void, {}>;
+export {};
+//# sourceMappingURL=ScreenContainer.d.ts.map

package/dist/components/ScreenContainer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScreenContainer.d.ts","sourceRoot":"","sources":["../../src/components/ScreenContainer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAIH,KAAK,gBAAgB,EACrB,KAAK,MAAM,EAEX,KAAK,WAAW,EACnB,MAAM,YAAY,CAAC;AAGpB,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAuCxF,KAAK,oBAAoB,GACnB,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,CAAC,GACtC,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,CAAC,GACrC,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,cAAc,EAAE,IAAI,CAAC,GACzC,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,cAAc,EAAE,IAAI,CAAC,GACzC,MAAM,CAAC,IAAI,CAAC,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CAAC;AAEzD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,kDA+B1B,CAAC"}

package/dist/components/Stack.d.ts

@@ -0,0 +1,21 @@
+import { type ComponentFactory } from '@sigx/lynx';
+/**
+ * Stack navigator — renders the topmost stack entry's component at rest, or
+ * the top + underneath entries during a transition.
+ *
+ * **Idle**: just the top entry, full-bleed, no transform. The screen
+ * component mounts directly so it can use its own layout (no extra absolute
+ * positioning that would break percentage heights).
+ *
+ * **Transitioning**: two `<ScreenContainer>` instances stacked absolutely,
+ * each with an MT-driven `translateX` that reads from the navigator's
+ * progress `SharedValue`. The host's BG thread doesn't tick per frame —
+ * `useAnimatedStyle` runs the interpolation entirely on MT.
+ *
+ * `key={top.key}` keeps the idle render's component instance stable across
+ * unrelated re-renders. During transitions, composite keys
+ * (`${entry.key}-${role}-${kind}`) ensure a fresh mount per role/kind pair so
+ * the `useAnimatedStyle` binding is set with the right input/output ranges.
+ */
+export declare const Stack: ComponentFactory<{}, void, unknown>;
+//# sourceMappingURL=Stack.d.ts.map

package/dist/components/Stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Stack.d.ts","sourceRoot":"","sources":["../../src/components/Stack.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,gBAAgB,EAAoB,MAAM,YAAY,CAAC;AAMhF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,KAAK,qCA0EhB,CAAC"}

package/dist/components/Stack.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx } from "@sigx/lynx/jsx-runtime";
+import { component } from '@sigx/lynx';
+import { useNav } from '../hooks/use-nav.js';
+import { useNavRoutes } from '../hooks/use-nav-internal.js';
+/**
+ * Stack navigator — renders the topmost stack entry's component.
+ *
+ * v0.1 minimal slice: renders only the top entry, with no transition and no
+ * preserved-mount lower entries. Phase 0.2 extends this to mount the
+ * top-N entries (so back-swipe can show the underlying screen) and runs MTS
+ * transition drivers between them.
+ *
+ * `key={top.key}` forces unmount/remount when the active entry changes — same
+ * pattern `@sigx/router`'s `<RouterView>` uses to prevent lazy components
+ * from stacking (`packages/router/src/RouterView.tsx:97-98`).
+ */
+export const Stack = component(() => {
+    const nav = useNav();
+    const routes = useNavRoutes();
+    return () => {
+        const top = nav.current;
+        const route = routes[top.route];
+        if (!route) {
+            // Defensive: navigator state should never reference an unregistered
+            // route, but if it does we surface nothing rather than crash.
+            return null;
+        }
+        const Comp = route.component;
+        if (typeof Comp !== 'function')
+            return null;
+        // Phase 0.1 only handles eager component factories. Lazy
+        // imports — `() => import(...)` — need a `lazy()` wrapper from sigx;
+        // we'll integrate that in the showcase-migration slice.
+        const ComponentFactoryRef = Comp;
+        const params = top.params;
+        return _jsx(ComponentFactoryRef, { ...params }, top.key);
+    };
+});
+//# sourceMappingURL=Stack.js.map

package/dist/components/Stack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Stack.js","sourceRoot":"","sources":["../../src/components/Stack.tsx"],"names":[],"mappings":";AAAA,OAAO,EAAE,SAAS,EAAyB,MAAM,YAAY,CAAC;AAC9D,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAE5D;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,SAAS,CAAC,GAAG,EAAE;IAChC,MAAM,GAAG,GAAG,MAAM,EAAE,CAAC;IACrB,MAAM,MAAM,GAAG,YAAY,EAAE,CAAC;IAE9B,OAAO,GAAG,EAAE;QACR,MAAM,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC;QACxB,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAChC,IAAI,CAAC,KAAK,EAAE,CAAC;YACT,oEAAoE;YACpE,8DAA8D;YAC9D,OAAO,IAAI,CAAC;QAChB,CAAC;QACD,MAAM,IAAI,GAAG,KAAK,CAAC,SAAS,CAAC;QAC7B,IAAI,OAAO,IAAI,KAAK,UAAU;YAAE,OAAO,IAAI,CAAC;QAC5C,yDAAyD;QACzD,qEAAqE;QACrE,wDAAwD;QACxD,MAAM,mBAAmB,GAAG,IAI3B,CAAC;QACF,MAAM,MAAM,GAAG,GAAG,CAAC,MAAiC,CAAC;QACrD,OAAO,KAAC,mBAAmB,OAAmB,MAAM,IAAnB,GAAG,CAAC,GAAG,CAAgB,CAAC;IAC7D,CAAC,CAAC;AACN,CAAC,CAAC,CAAC"}

package/dist/define-routes.d.ts

@@ -0,0 +1,31 @@
+import type { RouteMap } from './types.js';
+/**
+ * Define a typed route registry.
+ *
+ * Returns the input verbatim at runtime — the function exists for TypeScript
+ * inference. The returned type is narrowed to the literal route map so that
+ * downstream APIs (`useNav`, `useParams`, `<Link>`) can extract route names
+ * and params/search schemas precisely.
+ *
+ * @example
+ * ```ts
+ * import { defineRoutes } from '@sigx/lynx-navigation';
+ * import { z } from 'zod';
+ *
+ * export const routes = defineRoutes({
+ *     home: { component: lazy(() => import('./Home')) },
+ *     profile: {
+ *         params: z.object({ id: z.string() }),
+ *         component: lazy(() => import('./Profile')),
+ *         path: '/users/:id',
+ *     },
+ * });
+ *
+ * // Then in app entry:
+ * declare module '@sigx/lynx-navigation' {
+ *     interface Register { routes: typeof routes }
+ * }
+ * ```
+ */
+export declare function defineRoutes<const T extends RouteMap>(routes: T): T;
+//# sourceMappingURL=define-routes.d.ts.map

package/dist/define-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-routes.d.ts","sourceRoot":"","sources":["../src/define-routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,YAAY,CAAC,KAAK,CAAC,CAAC,SAAS,QAAQ,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAEnE"}

package/dist/define-routes.js

@@ -0,0 +1,32 @@
+/**
+ * Define a typed route registry.
+ *
+ * Returns the input verbatim at runtime — the function exists for TypeScript
+ * inference. The returned type is narrowed to the literal route map so that
+ * downstream APIs (`useNav`, `useParams`, `<Link>`) can extract route names
+ * and params/search schemas precisely.
+ *
+ * @example
+ * ```ts
+ * import { defineRoutes } from '@sigx/lynx-navigation';
+ * import { z } from 'zod';
+ *
+ * export const routes = defineRoutes({
+ *     home: { component: lazy(() => import('./Home')) },
+ *     profile: {
+ *         params: z.object({ id: z.string() }),
+ *         component: lazy(() => import('./Profile')),
+ *         path: '/users/:id',
+ *     },
+ * });
+ *
+ * // Then in app entry:
+ * declare module '@sigx/lynx-navigation' {
+ *     interface Register { routes: typeof routes }
+ * }
+ * ```
+ */
+export function defineRoutes(routes) {
+    return routes;
+}
+//# sourceMappingURL=define-routes.js.map

package/dist/define-routes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-routes.js","sourceRoot":"","sources":["../src/define-routes.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,UAAU,YAAY,CAA2B,MAAS;IAC5D,OAAO,MAAM,CAAC;AAClB,CAAC"}

package/dist/hooks/use-hardware-back.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Wire the Android hardware back button to the active navigator.
+ *
+ * Listens for `hardwareBackPress` events from `@sigx/lynx-linking`'s
+ * `BackHandler` (which the native side dispatches from
+ * `MainActivity.onBackPressed`). On press:
+ *
+ *   - If `nav.canGoBack` → `nav.pop()`.
+ *   - Otherwise → `BackHandler.exitApp()` (Android: `moveTaskToBack(true)`,
+ *     keeps the bundle warm; iOS: rejects, since iOS doesn't permit
+ *     programmatic termination).
+ *
+ * Call this once in any component under `<NavigationRoot>` (typically a
+ * thin wrapper sibling to `<Stack />`). iOS doesn't fire the event so the
+ * hook is a no-op there.
+ *
+ * @example
+ * ```tsx
+ * const BackHandlerWiring = component(() => {
+ *     useHardwareBack();
+ *     return () => null;
+ * });
+ *
+ * <NavigationRoot routes={routes}>
+ *     <BackHandlerWiring />
+ *     <Stack />
+ * </NavigationRoot>
+ * ```
+ */
+export declare function useHardwareBack(): void;
+//# sourceMappingURL=use-hardware-back.d.ts.map

package/dist/hooks/use-hardware-back.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-hardware-back.d.ts","sourceRoot":"","sources":["../../src/hooks/use-hardware-back.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAgBtC"}

package/dist/hooks/use-nav-internal.d.ts

@@ -0,0 +1,37 @@
+import { type SharedValue } from '@sigx/lynx';
+import type { RouteMap } from '../types.js';
+/**
+ * Internal injectable: the route registry passed into `<NavigationRoot>`.
+ * Components (Stack, Screen) read this to look up route definitions by name.
+ *
+ * Not exported from the package barrel — use `useNav()` for navigation, and
+ * the registry is implicit from `<NavigationRoot routes={...}>`.
+ */
+export declare const useNavRoutes: import("@sigx/runtime-core").InjectableFunction<RouteMap>;
+/**
+ * Internal injectable: low-level navigator handles used by the edge-back
+ * gesture. Holds the progress SharedValue (so gesture worklets can write it
+ * directly on MT) plus BG-side begin/commit/cancel functions invoked via
+ * `runOnBackground` from gesture worklets.
+ *
+ * `progress` is `null` when the navigator was created with `animated={false}`
+ * (e.g. tests). `beginBackGesture` is also a no-op in that case.
+ */
+export interface NavInternals {
+    /** MT-driven transition progress; null when animations are disabled. */
+    readonly progress: SharedValue<number> | null;
+    /**
+     * Set transition state for a gesture-driven pop. Does not start any
+     * automatic animation — the gesture worklet writes `progress` directly
+     * per frame, then animates to the commit/cancel endpoint on release.
+     */
+    beginBackGesture(): void;
+    /** Commit the back gesture: pop top entry + clear transition. */
+    commitBackGesture(): void;
+    /** Cancel the back gesture: clear transition without popping. */
+    cancelBackGesture(): void;
+    /** Whether the user opted into the edge-swipe-back gesture. */
+    readonly edgeSwipeEnabled: boolean;
+}
+export declare const useNavInternals: import("@sigx/runtime-core").InjectableFunction<NavInternals>;
+//# sourceMappingURL=use-nav-internal.d.ts.map

package/dist/hooks/use-nav-internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-nav-internal.d.ts","sourceRoot":"","sources":["../../src/hooks/use-nav-internal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,WAAW,EAAE,MAAM,YAAY,CAAC;AAChE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,2DAIvB,CAAC;AAEH;;;;;;;;GAQG;AACH,MAAM,WAAW,YAAY;IACzB,wEAAwE;IACxE,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;IAC9C;;;;OAIG;IACH,gBAAgB,IAAI,IAAI,CAAC;IACzB,iEAAiE;IACjE,iBAAiB,IAAI,IAAI,CAAC;IAC1B,iEAAiE;IACjE,iBAAiB,IAAI,IAAI,CAAC;IAC1B,+DAA+D;IAC/D,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;CACtC;AAED,eAAO,MAAM,eAAe,+DAI1B,CAAC"}

package/dist/hooks/use-nav-internal.js

@@ -0,0 +1,12 @@
+import { defineInjectable } from '@sigx/lynx';
+/**
+ * Internal injectable: the route registry passed into `<NavigationRoot>`.
+ * Components (Stack, Screen) read this to look up route definitions by name.
+ *
+ * Not exported from the package barrel — use `useNav()` for navigation, and
+ * the registry is implicit from `<NavigationRoot routes={...}>`.
+ */
+export const useNavRoutes = defineInjectable(() => {
+    throw new Error('[lynx-navigation] No <NavigationRoot> found in the component tree.');
+});
+//# sourceMappingURL=use-nav-internal.js.map

package/dist/hooks/use-nav-internal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-nav-internal.js","sourceRoot":"","sources":["../../src/hooks/use-nav-internal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAG9C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,gBAAgB,CAAW,GAAG,EAAE;IACxD,MAAM,IAAI,KAAK,CACX,oEAAoE,CACvE,CAAC;AACN,CAAC,CAAC,CAAC"}

package/dist/hooks/use-nav.d.ts

@@ -0,0 +1,77 @@
+import type { RegisteredRoutes, RouteId, RouteParams, RouteSearch } from '../register.js';
+import type { PopOptions, PushOptions, RouteRequiresParams, StackEntry, TransitionState } from '../types.js';
+/**
+ * Subset of registered route names that declare a `params` schema (and so
+ * require a `params` argument when navigating).
+ *
+ * Computed via mapped-type filtering rather than a conditional inside the
+ * method signature: when a conditional like `RouteRequiresParams<R[K]>` is
+ * embedded inside a generic method parameter, TS evaluates it at definition
+ * time with K bound to the *whole* union of route ids — which distributes
+ * `RouteRequiresParams` over every route and collapses the result to
+ * `boolean`, breaking the conditional. Filtering once at the type level avoids
+ * the issue and produces clean overload candidates.
+ */
+export type RoutesWithParams = {
+    [K in RouteId]: RouteRequiresParams<RegisteredRoutes[K]> extends true ? K : never;
+}[RouteId];
+/** Routes that don't declare a `params` schema. */
+export type RoutesWithoutParams = Exclude<RouteId, RoutesWithParams>;
+/**
+ * The navigator handle returned by `useNav()`.
+ *
+ * Read access (`current`, `stack`, `canGoBack`) is reactive — these properties
+ * are getters that read from the underlying stack signal, so accessing them
+ * inside a component's render function (or inside `effect` / `computed`) takes
+ * a reactive dependency. Mutating methods (`push`, `pop`, etc.) trigger the
+ * dependents to update.
+ *
+ * `push` and `replace` are split into two overloads — one for routes without a
+ * params schema (no params arg) and one for routes with a params schema
+ * (params required). See `RoutesWithParams` above for why this isn't a single
+ * conditional return type.
+ */
+export interface Nav {
+    /** Push a route that has no params schema. */
+    push<K extends RoutesWithoutParams>(name: K, search?: RouteSearch<K>, options?: PushOptions): void;
+    /** Push a route that requires params. */
+    push<K extends RoutesWithParams>(name: K, params: RouteParams<K>, search?: RouteSearch<K>, options?: PushOptions): void;
+    /** Replace the top entry — same overload pattern as push. */
+    replace<K extends RoutesWithoutParams>(name: K, search?: RouteSearch<K>, options?: PushOptions): void;
+    replace<K extends RoutesWithParams>(name: K, params: RouteParams<K>, search?: RouteSearch<K>, options?: PushOptions): void;
+    /** Pop one or more entries off the top of the stack. */
+    pop(count?: number, options?: PopOptions): void;
+    /** Pop entries until the named route is at the top. */
+    popTo<K extends RouteId>(name: K): void;
+    /** Pop all the way to the root entry. */
+    popToRoot(): void;
+    /** Wholesale-replace the stack. */
+    reset(state: {
+        stack: ReadonlyArray<StackEntry>;
+    }): void;
+    /** Dismiss the topmost modal stack (no-op if none active). */
+    dismiss(): void;
+    /** Currently-focused entry. Reactive via property access. */
+    readonly current: StackEntry;
+    /** Full stack, top last. Reactive. */
+    readonly stack: ReadonlyArray<StackEntry>;
+    /** Whether the user can go back from the current entry. Reactive. */
+    readonly canGoBack: boolean;
+    /** Parent navigator (e.g. the Tabs above this Stack), or null at the root. */
+    readonly parent: Nav | null;
+    /**
+     * In-flight transition, or null when navigation is at rest. Reactive —
+     * `<Stack>` reads this to decide whether to render one screen or two
+     * (during a slide transition both the outgoing and incoming screens
+     * stay mounted with `useAnimatedStyle`-driven transforms).
+     */
+    readonly transition: TransitionState | null;
+}
+/**
+ * Access the innermost navigator. Provided by `<NavigationRoot>` via
+ * `defineProvide`. Throws when called outside a NavigationRoot subtree.
+ *
+ * Mirrors `@sigx/router`'s `useRouter` pattern (`packages/router/src/router.ts:30`).
+ */
+export declare const useNav: import("@sigx/runtime-core").InjectableFunction<Nav>;
+//# sourceMappingURL=use-nav.d.ts.map

package/dist/hooks/use-nav.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-nav.d.ts","sourceRoot":"","sources":["../../src/hooks/use-nav.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC1F,OAAO,KAAK,EACR,UAAU,EACV,WAAW,EACX,mBAAmB,EACnB,UAAU,EACV,eAAe,EAClB,MAAM,aAAa,CAAC;AAErB;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,gBAAgB,GAAG;KAC1B,CAAC,IAAI,OAAO,GAAG,mBAAmB,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,CAAC,GAAG,KAAK;CACpF,CAAC,OAAO,CAAC,CAAC;AAEX,mDAAmD;AACnD,MAAM,MAAM,mBAAmB,GAAG,OAAO,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC;AAErE;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,GAAG;IAChB,8CAA8C;IAC9C,IAAI,CAAC,CAAC,SAAS,mBAAmB,EAC9B,IAAI,EAAE,CAAC,EACP,MAAM,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,EACvB,OAAO,CAAC,EAAE,WAAW,GACtB,IAAI,CAAC;IACR,yCAAyC;IACzC,IAAI,CAAC,CAAC,SAAS,gBAAgB,EAC3B,IAAI,EAAE,CAAC,EACP,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,EACtB,MAAM,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,EACvB,OAAO,CAAC,EAAE,WAAW,GACtB,IAAI,CAAC;IAER,6DAA6D;IAC7D,OAAO,CAAC,CAAC,SAAS,mBAAmB,EACjC,IAAI,EAAE,CAAC,EACP,MAAM,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,EACvB,OAAO,CAAC,EAAE,WAAW,GACtB,IAAI,CAAC;IACR,OAAO,CAAC,CAAC,SAAS,gBAAgB,EAC9B,IAAI,EAAE,CAAC,EACP,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,EACtB,MAAM,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,EACvB,OAAO,CAAC,EAAE,WAAW,GACtB,IAAI,CAAC;IAER,wDAAwD;IACxD,GAAG,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;IAEhD,uDAAuD;IACvD,KAAK,CAAC,CAAC,SAAS,OAAO,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;IAExC,yCAAyC;IACzC,SAAS,IAAI,IAAI,CAAC;IAElB,mCAAmC;IACnC,KAAK,CAAC,KAAK,EAAE;QAAE,KAAK,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;KAAE,GAAG,IAAI,CAAC;IAEzD,8DAA8D;IAC9D,OAAO,IAAI,IAAI,CAAC;IAEhB,6DAA6D;IAC7D,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAE7B,sCAAsC;IACtC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC;IAE1C,qEAAqE;IACrE,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAE5B,8EAA8E;IAC9E,QAAQ,CAAC,MAAM,EAAE,GAAG,GAAG,IAAI,CAAC;IAE5B;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,EAAE,eAAe,GAAG,IAAI,CAAC;CAC/C;AAED;;;;;GAKG;AACH,eAAO,MAAM,MAAM,sDAIjB,CAAC"}

package/dist/hooks/use-nav.js

@@ -0,0 +1,11 @@
+import { defineInjectable } from '@sigx/lynx';
+/**
+ * Access the innermost navigator. Provided by `<NavigationRoot>` via
+ * `defineProvide`. Throws when called outside a NavigationRoot subtree.
+ *
+ * Mirrors `@sigx/router`'s `useRouter` pattern (`packages/router/src/router.ts:30`).
+ */
+export const useNav = defineInjectable(() => {
+    throw new Error('[lynx-navigation] useNav() called but no <NavigationRoot> is mounted in the component tree.');
+});
+//# sourceMappingURL=use-nav.js.map

package/dist/hooks/use-nav.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-nav.js","sourceRoot":"","sources":["../../src/hooks/use-nav.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AA6F9C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,gBAAgB,CAAM,GAAG,EAAE;IAC7C,MAAM,IAAI,KAAK,CACX,6FAA6F,CAChG,CAAC;AACN,CAAC,CAAC,CAAC"}

package/dist/hooks/use-params.d.ts

@@ -0,0 +1,19 @@
+import type { RouteId, RouteParams } from '../register.js';
+/**
+ * Read the typed params for the current screen, asserted against the named
+ * route from the registry.
+ *
+ * Returns the current entry's params snapshot. The `name` arg is the type
+ * discriminator at compile time; we don't currently runtime-check that the
+ * caller's route matches the active entry — the dev-mode warning lands in a
+ * later slice along with schema validation.
+ *
+ * **Reactivity**: each `nav.push` / `replace` produces a new entry with a
+ * fresh `key`. `<Stack>` keys the rendered component on `entry.key`, so the
+ * screen component fully remounts on every navigation — useParams runs again
+ * during the new mount and reads the new params. There is no "in-place params
+ * update for the same mounted screen" path in v0.1, so a snapshot at setup
+ * time is correct.
+ */
+export declare function useParams<K extends RouteId>(_name: K): RouteParams<K>;
+//# sourceMappingURL=use-params.d.ts.map

package/dist/hooks/use-params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-params.d.ts","sourceRoot":"","sources":["../../src/hooks/use-params.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAG3D;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,OAAO,EAAE,KAAK,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAGrE"}