@react-motion-router/core 2.0.0-beta.sha-8be3578 → 2.0.0-beta.sha-7188e1e

package/build/Anchor.d.ts

@@ -1,22 +1,24 @@
 import { default as React, RefObject } from 'react';
+import { EventHandler } from './common/types';
 type AnchorState = {
     href?: string | null;
 };
 interface AnchorBaseProps extends Omit<AnchorProps, 'ref'> {
     ref?: RefObject<AnchorBase | null>;
 }
-export declare class AnchorBase extends React.Component<AnchorBaseProps, AnchorState> {
+export declare class AnchorBase extends React.Component<AnchorBaseProps, AnchorState> implements EventHandler {
     constructor(props: AnchorBaseProps);
     readonly anchorRef: React.RefObject<HTMLAnchorElement | null>;
-    private static directionFromRel;
-    private static findClosestEntryByHref;
-    private static findClosestEntry;
+    static directionFromRel(rel: string | undefined): "next" | "prev";
+    static findClosestEntryByHref(href: string, rel: string | undefined, entries: NavigationHistoryEntry[], index: number): NavigationHistoryEntry | undefined;
+    static findClosestEntry(rel: string | undefined, entries: NavigationHistoryEntry[], index: number): NavigationHistoryEntry;
     componentDidMount(): void;
     componentWillUnmount(): void;
-    private readonly onNavigate;
+    handleEvent(e: Event): void;
+    onnavigatesuccess(): void;
+    onclick(event: MouseEvent): void;
     private get href();
     private get search();
-    private readonly handleClick;
     render(): import("react/jsx-runtime").JSX.Element;
 }
 export interface AnchorProps extends React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement> {

package/build/NavigationBase.d.ts

@@ -1,10 +1,9 @@
-import { RouterBaseHTMLElement } from './common/types';
 import { MetaData } from './MetaData';
 export interface NavigationBaseConfig {
-    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: RouterBaseHTMLElement, ev: HTMLElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions): () => void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions): () => void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): () => void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): () => void;
-    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: RouterBaseHTMLElement, ev: HTMLElementEventMap[K]) => void, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => void, options?: boolean | EventListenerOptions | undefined): void;
     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
     dispatchEvent(event: Event): Promise<boolean>;
@@ -18,12 +17,12 @@ export declare abstract class NavigationBase {
     private static rootNavigatorRef;
     readonly metaData: MetaData;
     readonly addEventListener: {
-        <K extends keyof HTMLElementEventMap>(type: K, listener: (this: RouterBaseHTMLElement, ev: HTMLElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions): () => void;
+        <K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions): () => void;
         (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): () => void;
         (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): () => void;
     };
     readonly removeEventListener: {
-        <K extends keyof HTMLElementEventMap>(type: K, listener: (this: RouterBaseHTMLElement, ev: HTMLElementEventMap[K]) => void, options?: boolean | EventListenerOptions | undefined): void;
+        <K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => void, options?: boolean | EventListenerOptions | undefined): void;
         (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
         (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
     };

package/build/RoutePropContext.d.ts

@@ -1,2 +1,2 @@
 import { RoutePropBase } from './common/types';
-export declare const RoutePropContext: import('react').Context<RoutePropBase<{}, import('./common/types').PlainObject<any>>>;
+export declare const RoutePropContext: import('react').Context<RoutePropBase<{}, import('.').PlainObject<any>>>;

package/build/RouterBase.d.ts

@@ -1,9 +1,10 @@
 import { NavigationBase } from './NavigationBase';
 import { ScreenTransitionLayer } from './ScreenTransitionLayer';
-import { ScreenChild, RouterBaseHTMLElement, EventHandler } from './common/types';
+import { ScreenChild, EventHandler } from './common/types';
 import { NestedRouterContext } from './RouterContext';
-import { Component } from 'react';
+import { Component, RefObject } from 'react';
 import { ScreenBase, ScreenBaseConfig } from './ScreenBase';
+import { LoadEvent } from './common/events';
 type ScreenType<T> = T extends ScreenChild<infer S> | ScreenChild<infer S>[] ? S : never;
 export interface RouterBaseConfig {
     screenConfig?: ScreenBaseConfig;
@@ -17,12 +18,11 @@ export interface RouterBaseProps<S extends ScreenBase = ScreenBase> {
 export type RouterBaseState = object;
 export declare abstract class RouterBase<P extends RouterBaseProps = RouterBaseProps, S extends RouterBaseState = RouterBaseState> extends Component<P, S> implements EventHandler {
     #private;
-    protected readonly ref: import('react').RefObject<RouterBaseHTMLElement | null>;
-    protected screenTransitionLayer: import('react').RefObject<ScreenTransitionLayer | null>;
+    protected abstract readonly ref: RefObject<HTMLElement | null>;
+    protected screenTransitionLayer: RefObject<ScreenTransitionLayer | null>;
     abstract readonly navigation: NavigationBase;
     readonly parent: RouterBase | null;
     private loadDispatched;
-    private hasUAVisualTransition;
     readonly parentScreen: ScreenBase | null;
     private static rootRouterRef;
     static readonly contextType: import('react').Context<{
@@ -34,20 +34,23 @@ export declare abstract class RouterBase<P extends RouterBaseProps = RouterBaseP
     private static get events();
     componentDidMount(): void;
     componentWillUnmount(): void;
+    interceptHandler: () => Promise<void>;
     onnavigate(e: NavigateEvent): void;
     getRouterById(routerId: string, target?: RouterBase): RouterBase | null;
     dispatchEvent(event: Event): Promise<boolean>;
-    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: RouterBaseHTMLElement, ev: HTMLElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions): () => void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions): () => void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): () => void;
-    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: RouterBaseHTMLElement, ev: HTMLElementEventMap[K]) => void, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => void, options?: boolean | EventListenerOptions | undefined): void;
     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     handleEvent(e: Event): void;
     protected screenChildFromPathname(pathname: string): {
         child: ScreenChild<ScreenType<P["children"]>>;
-        matchInfo: import('./common/types').MatchedRoute;
+        matchInfo: import('.').MatchedRoute;
     } | null;
     protected preloadScreen(screen: ScreenChild): Promise<void>;
     includesRoute(pathname: string, baseURLPattern?: string): boolean;
+    get activeEvent(): LoadEvent | NavigateEvent | null;
+    get hasUAVisualTransition(): boolean;
     get id(): string;
     get isRoot(): boolean;
     get baseURL(): URL;

package/build/ScreenBase.d.ts

@@ -1,6 +1,6 @@
-import { Component, ElementType } from 'react';
+import { Component, RefObject } from 'react';
 import { ScreenTransitionProvider } from './ScreenTransitionProvider';
-import { AnimationEffectFactory, LazyExoticComponent, PlainObject, RoutePropBase } from './common/types';
+import { AnimationEffectFactory, EventHandler, LazyExoticComponent, PlainObject, RoutePropBase } from './common/types';
 import { RouterContext } from './RouterContext';
 import { NavigationBase } from './NavigationBase';
 import { SharedElementScene } from './SharedElementScene';
@@ -46,12 +46,11 @@ export interface ScreenBaseState<C extends ScreenBaseProps['config'] = ScreenBas
     focused: boolean;
     config: C;
     params: P;
-    elementType: ElementType;
 }
-export declare abstract class ScreenBase<P extends ScreenBaseProps = ScreenBaseProps, S extends ScreenBaseState<P['config']> = ScreenBaseState<P['config']>, R extends RoutePropBase<P['config']> = RoutePropBase<P['config']>> extends Component<P, S> {
+export declare abstract class ScreenBase<P extends ScreenBaseProps = ScreenBaseProps, S extends ScreenBaseState<P['config']> = ScreenBaseState<P['config']>, R extends RoutePropBase<P['config']> = RoutePropBase<P['config']>> extends Component<P, S> implements EventHandler {
     #private;
     readonly sharedElementScene: SharedElementScene;
-    protected readonly ref: import('react').RefObject<HTMLDivElement | null>;
+    protected abstract readonly ref: RefObject<HTMLElement | null>;
     protected readonly nestedRouterData: {
         parentScreen: ScreenBase;
         parentRouter: import('./RouterBase').RouterBase<import('./RouterBase').RouterBaseProps<ScreenBase<ScreenBaseProps, ScreenBaseState<ScreenBaseConfig<RoutePropBase<{}, PlainObject<any>>, NavigationBase> | undefined, PlainObject>, RoutePropBase<ScreenBaseConfig<RoutePropBase<{}, PlainObject<any>>, NavigationBase> | undefined, PlainObject<any>>>>, object>;
@@ -60,6 +59,7 @@ export declare abstract class ScreenBase<P extends ScreenBaseProps = ScreenBaseP
     context: React.ContextType<typeof RouterContext>;
     state: S;
     constructor(props: P, context: React.ContextType<typeof RouterContext>);
+    handleEvent(e: Event): void;
     protected setParams(newParams: PlainObject): void;
     protected setConfig(newConfig: R['config']): void;
     get focused(): boolean;
@@ -74,11 +74,12 @@ export declare abstract class ScreenBase<P extends ScreenBaseProps = ScreenBaseP
     abstract get params(): R['params'];
     abstract get resolvedPathname(): string;
     abstract get id(): string;
+    abstract get viewTransitionName(): string;
     onExited(signal: AbortSignal): Promise<void>;
     onExit(signal: AbortSignal): Promise<void>;
     onEnter(signal: AbortSignal): Promise<void>;
     onEntered(signal: AbortSignal): Promise<void>;
     get path(): P["path"];
-    get transitionProvider(): import('react').RefObject<ScreenTransitionProvider | null>;
+    get transitionProvider(): RefObject<ScreenTransitionProvider | null>;
     render(): import("react/jsx-runtime").JSX.Element;
 }

package/build/ScreenTransitionLayer.d.ts

@@ -5,7 +5,6 @@ import { ScreenChild } from './common/types';
 import { NavigationBase } from './NavigationBase';
 import { ScreenBase } from './ScreenBase';
 interface ScreenTransitionLayerProps {
-    id: string;
     children: ScreenChild | ScreenChild[];
     navigation: NavigationBase;
     hasUAVisualTransition: boolean;

package/build/ScreenTransitionProvider.d.ts

@@ -1,31 +1,16 @@
-import { ScreenTransitionLayerContext } from './ScreenTransitionLayerContext';
 import { AnimationEffectFactory } from './common/types';
-import { NavigationBase } from './NavigationBase';
-import { Component, ElementType } from 'react';
-interface ScreenTransitionProviderProps {
-    id: string;
-    animation?: AnimationEffectFactory;
-    children: React.ReactNode;
-    navigation: NavigationBase;
-    renderAs: ElementType;
-    focused: boolean;
-}
-interface ScreenTransitionProviderState {
-    zIndex: React.CSSProperties['zIndex'];
-}
-export declare class ScreenTransitionProvider extends Component<ScreenTransitionProviderProps, ScreenTransitionProviderState> {
-    readonly ref: import('react').RefObject<HTMLElement | null>;
-    static readonly contextType: import('react').Context<import('./ScreenTransitionLayer').ScreenTransitionLayer>;
-    context: React.ContextType<typeof ScreenTransitionLayerContext>;
+import { RefObject } from 'react';
+export interface ScreenTransitionProvider {
     index: number;
     exiting: boolean;
-    state: ScreenTransitionProviderState;
-    private onroutertransitionend;
-    private onroutertransitionstart;
-    componentDidMount(): void;
-    componentWillUnmount(): void;
-    get animationEffect(): AnimationEffect | null;
-    setZIndex(zIndex: React.CSSProperties['zIndex']): Promise<void>;
-    render(): import("react/jsx-runtime").JSX.Element;
+    readonly animationEffect: AnimationEffect | null;
+    readonly screenElementRef: RefObject<HTMLElement | null>;
+}
+export interface ScreenTransitionProviderProps {
+    viewTransitionName: string;
+    animation?: AnimationEffectFactory;
+    children: React.ReactNode;
+    screenElementRef: RefObject<HTMLElement | null>;
+    ref?: RefObject<ScreenTransitionProvider | null>;
 }
-export {};
+export declare function ScreenTransitionProvider(props: ScreenTransitionProviderProps): import('react').ReactNode;

package/build/ViewTransitionSharedElement.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+import { SharedElementTransitionType } from './common/types';
+type SharedElement = {
+    [T in keyof React.JSX.IntrinsicElements]: ReturnType<typeof createSharedElement<T>>;
+};
+interface SharedElementConfig extends OptionalEffectTiming {
+    type?: SharedElementTransitionType;
+}
+interface SharedElementProps {
+    id: string;
+    config?: SharedElementConfig;
+}
+export declare const createSharedElement: <T extends keyof React.JSX.IntrinsicElements>(tag: T) => ({ ref: forwardedRef, ...props }: React.JSX.IntrinsicElements[T] & SharedElementProps) => import("react/jsx-runtime").JSX.Element;
+export declare const SharedElement: SharedElement;
+export {};

package/build/__tests__/Anchor/common/constants.d.ts

@@ -0,0 +1 @@
+export declare const SECOND_INDEX = 1;

package/build/__tests__/common/utils.d.ts

@@ -6,6 +6,7 @@ import { ScreenBase } from '../../ScreenBase';
 export declare class TestNavigation extends NavigationBase {
 }
 export declare class TestRouter extends RouterBase {
+    protected ref: React.RefObject<HTMLDivElement | null>;
     navigation: TestNavigation;
     state: {
         screens: RouterBase["screens"];
@@ -13,16 +14,19 @@ export declare class TestRouter extends RouterBase {
     constructor(props: RouterBaseProps, context: React.ContextType<typeof NestedRouterContext>);
     protected canIntercept(): boolean;
     protected shouldIntercept(): boolean;
-    protected get screens(): React.CElement<import('../../ScreenBase').ScreenBaseProps, ScreenBase<import('../../ScreenBase').ScreenBaseProps, import('../../ScreenBase').ScreenBaseState<import('../../ScreenBase').ScreenBaseConfig<import('../..').RoutePropBase<{}, import('../..').PlainObject<any>>, NavigationBase> | undefined, import('../..').PlainObject>, import('../..').RoutePropBase<import('../../ScreenBase').ScreenBaseConfig<import('../..').RoutePropBase<{}, import('../..').PlainObject<any>>, NavigationBase> | undefined, import('../..').PlainObject<any>>>> | React.CElement<import('../../ScreenBase').ScreenBaseProps, ScreenBase<import('../../ScreenBase').ScreenBaseProps, import('../../ScreenBase').ScreenBaseState<import('../../ScreenBase').ScreenBaseConfig<import('../..').RoutePropBase<{}, import('../..').PlainObject<any>>, NavigationBase> | undefined, import('../..').PlainObject>, import('../..').RoutePropBase<import('../../ScreenBase').ScreenBaseConfig<import('../..').RoutePropBase<{}, import('../..').PlainObject<any>>, NavigationBase> | undefined, import('../..').PlainObject<any>>>>[];
+    protected get screens(): React.CElement<import('../..').ScreenBaseProps, ScreenBase<import('../..').ScreenBaseProps, import('../..').ScreenBaseState<import('../..').ScreenBaseConfig<import('../..').RoutePropBase<{}, import('../..').PlainObject<any>>, NavigationBase> | undefined, import('../..').PlainObject>, import('../..').RoutePropBase<import('../..').ScreenBaseConfig<import('../..').RoutePropBase<{}, import('../..').PlainObject<any>>, NavigationBase> | undefined, import('../..').PlainObject<any>>>> | React.CElement<import('../..').ScreenBaseProps, ScreenBase<import('../..').ScreenBaseProps, import('../..').ScreenBaseState<import('../..').ScreenBaseConfig<import('../..').RoutePropBase<{}, import('../..').PlainObject<any>>, NavigationBase> | undefined, import('../..').PlainObject>, import('../..').RoutePropBase<import('../..').ScreenBaseConfig<import('../..').RoutePropBase<{}, import('../..').PlainObject<any>>, NavigationBase> | undefined, import('../..').PlainObject<any>>>>[];
     protected intercept(e: NavigateEvent): void;
+    render(): import("react/jsx-runtime").JSX.Element;
 }
 export declare class TestScreen extends ScreenBase {
+    protected ref: React.RefObject<HTMLDivElement | null>;
     get id(): string;
     get params(): import('../..').PlainObject;
-    get config(): import('../../ScreenBase').ScreenBaseConfig<import('../..').RoutePropBase<{}, import('../..').PlainObject<any>>, NavigationBase>;
+    get config(): import('../..').ScreenBaseConfig<import('../..').RoutePropBase<{}, import('../..').PlainObject<any>>, NavigationBase>;
     get resolvedPathname(): string;
+    get viewTransitionName(): string;
     protected get routeProp(): {
-        config: import('../../ScreenBase').ScreenBaseConfig<import('../..').RoutePropBase<{}, import('../..').PlainObject<any>>, NavigationBase>;
+        config: import('../..').ScreenBaseConfig<import('../..').RoutePropBase<{}, import('../..').PlainObject<any>>, NavigationBase>;
         params: import('../..').PlainObject;
         focused: boolean;
         path: string;
@@ -30,4 +34,5 @@ export declare class TestScreen extends ScreenBase {
         setConfig(): void;
         setParams(): void;
     };
+    render(): import("react/jsx-runtime").JSX.Element;
 }

package/build/common/events.d.ts

@@ -1,5 +1,5 @@
 import { LoadNavigationTransition } from './types';
-export declare class LoadEvent extends Event implements Omit<NavigateEvent, 'navigationType' | 'commit'> {
+export declare class LoadEvent extends Event implements Omit<NavigateEvent, 'navigationType'> {
     #private;
     readonly hasUAVisualTransition = false;
     constructor(navigationType: 'load' | 'preload', loadEventInitDict?: {

package/build/common/test-utils.d.ts

@@ -1,10 +1,12 @@
+import { LoadEvent } from './events';
 export declare function useRerender(): CSSNumberish | null;
 export declare function useRerenderCallback<T extends () => unknown>(callback: T): void;
 export declare function triggerRerender(): void;
 export declare function createHistoryEntry(url: string, index: number): NavigationHistoryEntry;
 export declare function assertNavigationAvailable(): void;
-export declare function waitForNavigateSuccess(): Promise<void>;
-export declare function navTo(url: string): Promise<void>;
+export declare function waitForNavigateSuccess(): Promise<unknown>;
+export declare function waitForNavigation(type: NavigateEvent['navigationType'] | LoadEvent['navigationType']): Promise<unknown>;
+export declare function navTo(url: string, history?: NavigationNavigateOptions['history']): Promise<NavigationHistoryEntry>;
 export declare function traverseTo(key: string): Promise<void>;
 export declare function traverseToStart(): Promise<void>;
 export declare function seedHistory(): Promise<void>;

package/build/common/types.d.ts

@@ -4,6 +4,7 @@ import { StandardPropertiesHyphen } from 'csstype';
 export type ScreenChild<E extends ScreenBase = ScreenBase> = E extends ScreenBase<infer P> ? React.CElement<P, E> : never;
 export interface AnimationEffectFactoryProps<R extends HTMLElement = HTMLElement> {
     ref: R | null;
+    viewTransitionName: string;
     index: number;
     screens: string[];
     exiting: boolean;
@@ -43,18 +44,19 @@ declare global {
         'routertransitioncancel': TransitionEvent;
         'routertransitionend': TransitionEvent;
     }
+    interface NavigationPrecommitController {
+        redirect(url: string, options?: NavigationNavigateOptions): void;
+        addHandler(handler: NavigationInterceptOptions['handler']): void;
+    }
+    interface NavigationInterceptOptions {
+        precommitHandler?(controller: NavigationPrecommitController): Promise<void>;
+    }
 }
 export type EventHandler = {
     [K in keyof HTMLElementEventMap as `on${K}`]?: (e: HTMLElementEventMap[K]) => void;
 } & {
     handleEvent: (e: Event) => void;
 };
-export type RouterBaseHTMLElement<T extends HTMLElement = HTMLDivElement> = T & {
-    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: T, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
-    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
-    removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: T, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
-    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
-};
 export type CustomElementType = `${string}-${string}`;
 export interface MatchedRoute {
     params: PlainObject<string | undefined>;
@@ -87,11 +89,7 @@ export declare function isStylableElement(element: any): element is StylableElem
 export interface LoadNavigationTransition extends Omit<NavigationTransition, 'navigationType'> {
     navigationType: 'load' | 'preload';
 }
-declare global {
-    interface NavigateEvent extends Event {
-        commit?(): void;
-    }
-}
 export type ElementPropType<C> = C extends React.CElement<infer P, infer T> ? P & React.ClassAttributes<T> : never;
 export type ClonedElementType<C, IP extends Partial<ElementPropType<C>>> = C extends React.CElement<infer P, infer T> ? React.CElement<P & Partial<IP>, T & React.Component<P & IP>> : never;
+export type ElementForTag<T extends keyof JSX.IntrinsicElements> = T extends keyof (HTMLElementTagNameMap & SVGElementTagNameMap) ? (HTMLElementTagNameMap & SVGElementTagNameMap)[T] : HTMLElement;
 export {};

package/build/common/utils.d.ts

@@ -13,4 +13,4 @@ export declare function PromiseAllSequential<T>(values: Iterable<T | PromiseLike
 export declare function toCamelCase(value: string): string;
 export declare function cloneAndInject<C extends React.CElement<any, any>, IP extends Partial<ElementPropType<C>>>(element: C, injectProps: IP): ClonedElementType<C, IP>;
 export declare function omit<T extends object, K extends readonly (keyof T)[]>(obj: T, keys: K): Omit<T, K[number]>;
-export declare function historyEntryFromDestination(destination: NavigationDestination): NavigationHistoryEntry;
+export declare function historyEntryFromDestination(destination: NavigationDestination, index?: number): NavigationHistoryEntry;