@equinor/fusion-framework-module-navigation 7.0.0-next.1 → 7.0.0

package/dist/types/NavigationConfigurator.interface.d.ts

@@ -3,15 +3,35 @@ import type { ITelemetryProvider } from '@equinor/fusion-framework-module-teleme
 import type { IEventModuleProvider } from '@equinor/fusion-framework-module-event';
 /**
  * Configuration object for the navigation module.
- * Provides options for customizing history, basename, telemetry, and event settings.
+ *
+ * Provides options for customizing the history implementation, basename prefix,
+ * telemetry tracking, and event dispatching used by the {@link NavigationProvider}.
  */
 export interface INavigationConfigurator {
-    /** Optional base pathname for the application (e.g., "/app") */
+    /**
+     * Base pathname prefix for the application (e.g. `"/apps/my-app"`).
+     *
+     * When set, the navigation provider automatically prepends this prefix to
+     * outgoing paths and strips it from incoming paths, so consumer code
+     * operates on clean, basename-free paths.
+     */
     basename?: string;
-    /** Optional custom history instance (browser, hash, or memory). If not provided, defaults to browser history. */
+    /**
+     * Custom {@link History} instance for navigation.
+     *
+     * If not provided, defaults to browser history in browser environments
+     * or memory history in Node.js environments. Create instances with
+     * {@link createHistory}.
+     */
     history?: History;
-    /** Optional telemetry provider for tracking navigation events */
+    /**
+     * Telemetry provider for tracking navigation events, location changes,
+     * and errors for monitoring and debugging.
+     */
     telemetry?: ITelemetryProvider;
-    /** Optional event provider for dispatching navigation events */
+    /**
+     * Event provider for dispatching {@link NavigateEvent} and {@link NavigatedEvent}.
+     * Allows other modules to listen for and react to navigation changes.
+     */
     eventProvider?: IEventModuleProvider;
 }

package/dist/types/NavigationProvider.d.ts

@@ -6,27 +6,38 @@ import type { INavigationConfigurator } from './NavigationConfigurator.interface
 import type { History, NavigateOptions, NavigationUpdate, Path, To } from './lib/types';
 /**
  * Navigation provider implementation.
- * Manages routing and navigation state with basename localization.
+ *
+ * Manages routing and navigation state with automatic basename localization.
+ * Wraps a {@link History} instance to expose observable state, path localization,
+ * and router creation.
  *
  * @remarks
- * This provider:
- * - Wraps the Navigator to provide observable navigation state
- * - Localizes paths by removing basename prefix
- * - Creates routers compatible with industry-standard routers (Remix/React Router)
- * - Handles navigation actions (push, replace, createHref, etc.)
+ * - Emits localized paths (basename removed) to consumers via {@link NavigationProvider.state$ | state$}
+ * - Internally prefixes paths with the basename before forwarding to the history stack
+ * - Creates routers compatible with Remix / React Router via {@link NavigationProvider.createRouter | createRouter}
+ * - Dispatches {@link NavigatedEvent} and telemetry on navigation changes
  *
- * Path localization ensures that consumers receive paths relative to the basename,
- * while internally we work with full paths including basename.
+ * @example
+ * ```ts
+ * const provider = new NavigationProvider({ version, config });
+ * provider.push('/users');
+ * console.log(provider.path.pathname); // '/users'
+ * ```
  */
 export declare class NavigationProvider extends BaseModuleProvider<INavigationConfigurator> implements INavigationProvider {
     #private;
     /**
      * Observable stream of navigation state updates.
-     * Emits localized paths (with basename removed) for consumers.
+     *
+     * Emits localized paths (with basename removed) and filters to only
+     * paths within the basename scope. Late subscribers receive the last
+     * emitted value immediately.
      */
     get state$(): Observable<NavigationUpdate>;
     /**
-     * Gets the basename.
+     * Gets the basename prefix configured for this provider.
+     *
+     * @returns The basename string, or an empty string if none is configured
      */
     get basename(): string;
     /**
@@ -34,16 +45,22 @@ export declare class NavigationProvider extends BaseModuleProvider<INavigationCo
      */
     get navigator(): History;
     /**
-     * Gets the history instance.
+     * Gets the underlying history instance.
+     *
+     * @returns The {@link History} instance used for navigation
      */
     get history(): History;
     /**
-     * Gets the current localized path (basename removed).
+     * Gets the current localized path with the basename prefix removed.
+     *
+     * @returns A {@link Path} object representing the current location without basename
      */
     get path(): Path;
     /**
+     * Creates a new {@link NavigationProvider}.
+     *
      * @param args - Configuration arguments containing module config
-     * @throws {Error} If no history is provided in the configuration
+     * @throws {Error} If no history instance is provided in the configuration
      */
     constructor(args: BaseModuleProviderCtorArgs<INavigationConfigurator>);
     /**
@@ -58,22 +75,30 @@ export declare class NavigationProvider extends BaseModuleProvider<INavigationCo
     /**
      * Creates a router instance from route configuration.
      *
-     * @deprecated Use `@equinor/fusion-framework-react-router` instead
+     * @deprecated Use `@equinor/fusion-framework-react-router` instead.
      *
-     * @param routes - Route configuration objects compatible with industry-standard routers (Remix/React Router)
-     * @returns A configured and initialized router instance
+     * @param routes - Route configuration objects compatible with Remix/React Router
+     * @returns A configured and initialized {@link Router} instance with basename applied
      */
     createRouter(routes: AgnosticRouteObject[]): import("@remix-run/router").Router;
     /**
-     * Creates a localized href string for navigation.
+     * Creates a localized href string including the basename prefix.
      *
-     * @param to - Optional path or location (defaults to current path)
+     * @param to - Path or location to resolve (defaults to current path)
+     * @returns Fully-qualified href string with basename included
+     *
+     * @example
+     * ```ts
+     * // basename = '/apps/my-app'
+     * provider.createHref('/users'); // '/apps/my-app/users'
+     * ```
      */
     createHref(to?: To): string;
     /**
-     * Creates a full URL object for navigation.
+     * Creates a full {@link URL} object including the basename prefix.
      *
-     * @param to - Optional path or location (defaults to current path)
+     * @param to - Path or location to resolve (defaults to current path)
+     * @returns A {@link URL} instance representing the resolved navigation target
      */
     createURL(to?: To): URL;
     /**
@@ -98,15 +123,24 @@ export declare class NavigationProvider extends BaseModuleProvider<INavigationCo
      */
     navigate(to?: To, options?: Partial<NavigateOptions>): void;
     /**
-     * Checks if a pathname is within the basename scope.
+     * Checks whether a pathname falls within the configured basename scope.
+     *
+     * @param pathname - The pathname to check
+     * @returns `true` if the pathname starts with the basename (or no basename is set)
      */
     protected _isWithinBasenameScope(pathname: string): boolean;
     /**
-     * Localizes a path by removing the basename prefix.
+     * Localizes a path by stripping the basename prefix from the pathname.
+     *
+     * @param location - The full path to localize
+     * @returns A new {@link Path} with the basename removed from the pathname
      */
     protected _localizePath(location: Path): Path;
     /**
-     * Creates a full path object from a target location, adding basename prefix.
+     * Creates a full path object from a target location, prepending the basename prefix.
+     *
+     * @param to - The target location (string path or partial {@link Path} object)
+     * @returns A partial {@link Path} with basename prepended to the pathname
      */
     protected _createToPath(to: To): Partial<Path>;
 }

package/dist/types/NavigationProvider.interface.d.ts

@@ -5,7 +5,17 @@ import type { Observable } from 'rxjs';
 import type { IModuleProvider } from '@equinor/fusion-framework-module';
 /**
  * Navigation provider interface.
- * Provides routing and navigation capabilities with basename localization.
+ *
+ * Provides routing and navigation capabilities with automatic basename
+ * localization. Consumers work with clean paths (e.g. `/users`) while the
+ * underlying history operates on full paths (e.g. `/apps/my-app/users`).
+ *
+ * @example
+ * ```ts
+ * const nav: INavigationProvider = framework.modules.navigation;
+ * nav.push('/users');
+ * console.log(nav.path.pathname); // '/users'
+ * ```
  */
 export interface INavigationProvider extends IModuleProvider {
     /**
@@ -35,20 +45,23 @@ export interface INavigationProvider extends IModuleProvider {
     /**
      * Creates a router instance from route configuration.
      *
-     * @param routes - Route configuration objects compatible with industry-standard routers (Remix/React Router)
-     * @returns A configured and initialized router instance
+     * @deprecated Use `@equinor/fusion-framework-react-router` instead.
+     * @param routes - Route configuration objects compatible with Remix/React Router
+     * @returns A configured and initialized {@link Router} instance with basename applied
      */
     createRouter(routes: AgnosticRouteObject[]): Router;
     /**
-     * Creates a localized href string for navigation.
+     * Creates a localized href string including the basename prefix.
      *
-     * @param to - Optional path or location (defaults to current path)
+     * @param to - Path or location to resolve (defaults to current path)
+     * @returns Fully-qualified href string with basename included
      */
     createHref(to?: To): string;
     /**
-     * Creates a full URL object for navigation.
+     * Creates a full {@link URL} object including the basename prefix.
      *
-     * @param to - Optional path or location (defaults to current path)
+     * @param to - Path or location to resolve (defaults to current path)
+     * @returns A {@link URL} instance representing the resolved navigation target
      */
     createURL(to?: To): URL;
     /**

package/dist/types/events.d.ts

@@ -12,7 +12,16 @@ export interface NavigateEventDetail {
 }
 /**
  * Event emitted before navigation occurs.
- * Can be canceled by calling `preventDefault()`.
+ * Can be canceled by calling `preventDefault()` to block the navigation.
+ *
+ * @example
+ * ```ts
+ * eventProvider.addEventListener('onNavigate', (event) => {
+ *   if (hasUnsavedChanges) {
+ *     event.preventDefault();
+ *   }
+ * });
+ * ```
  */
 export declare class NavigateEvent extends FrameworkEvent<FrameworkEventInit<NavigateEventDetail, INavigationProvider>> {
     constructor(detail: NavigateEventDetail, source: INavigationProvider);
@@ -29,8 +38,16 @@ export interface NavigatedEventDetail {
     previous: NavigationUpdate;
 }
 /**
- * Event emitted after navigation occurs.
- * Contains the navigation action and location details.
+ * Event emitted after navigation completes.
+ * Contains the navigation action type and both current and previous locations.
+ *
+ * @example
+ * ```ts
+ * eventProvider.addEventListener('onNavigated', (event) => {
+ *   const { action, current, previous } = event.detail;
+ *   console.log(`${action}: ${previous.location.pathname} → ${current.location.pathname}`);
+ * });
+ * ```
  */
 export declare class NavigatedEvent extends FrameworkEvent<FrameworkEventInit<NavigatedEventDetail, INavigationProvider>> {
     constructor(detail: NavigatedEventDetail, source: INavigationProvider);

package/dist/types/index.d.ts

@@ -1,3 +1,26 @@
+/**
+ * @module @equinor/fusion-framework-module-navigation
+ *
+ * Navigation module for Fusion Framework providing routing and navigation capabilities.
+ *
+ * Manages observable navigation state with automatic basename localization,
+ * so consumers work with clean paths while the underlying history receives
+ * full paths including the basename prefix.
+ *
+ * @remarks
+ * Supports browser, hash, and memory history types. Integrates with
+ * `@remix-run/router` for router creation and is compatible with
+ * industry-standard routers (Remix / React Router).
+ *
+ * @example
+ * ```ts
+ * import { enableNavigation, createHistory } from '@equinor/fusion-framework-module-navigation';
+ *
+ * enableNavigation(configurator, '/apps/my-app');
+ * ```
+ *
+ * @packageDocumentation
+ */
 export type { INavigationConfigurator } from './NavigationConfigurator.interface';
 export { NavigationConfigurator } from './NavigationConfigurator';
 export { NavigationModule, module, moduleKey } from './module';
@@ -8,6 +31,6 @@ export { createHistory } from './lib/create-history';
 export { NavigateEvent, NavigatedEvent, type NavigateEventDetail, type NavigatedEventDetail, } from './events';
 export type { Path, To, Location, History, NavigationBlocker, NavigationListener, } from './lib/types';
 /**
- * @deprecated use History instead
+ * @deprecated Use {@link History} instead.
  */
 export type { History as INavigator } from './lib';

package/dist/types/lib/BaseHistory.d.ts

@@ -3,17 +3,23 @@ import type { Actions, HistoryState } from './state';
 import type { NavigateOptions, NavigationListener, Path, To, History, NavigationBlocker } from './types';
 /**
  * Abstract base class for history implementations.
- * Provides common state management and navigation logic that can be shared
- * across different history implementations (browser, memory, etc.).
+ *
+ * Provides common state management, navigation logic, and subscription
+ * lifecycle that is shared across different history backends (browser,
+ * hash, memory).
  */
 export declare abstract class BaseHistory implements History {
     #private;
     /**
-     * Gets the current location.
+     * Gets the current location in the history stack.
+     *
+     * @returns The current {@link Location} including pathname, search, hash, state, and key
      */
     get location(): History['location'];
     /**
-     * Gets the current action.
+     * Gets the current navigation action type.
+     *
+     * @returns The most recent {@link Action} (`Pop`, `Push`, or `Replace`)
      */
     get action(): History['action'];
     /**
@@ -26,20 +32,31 @@ export declare abstract class BaseHistory implements History {
      */
     get action$(): History['action$'];
     /**
-     * Checks if there are any active navigation blockers.
+     * Checks whether there are any active navigation blockers.
+     *
+     * @returns `true` if one or more blockers are registered
      */
     get hasBlockers(): boolean;
     protected constructor(state: HistoryState);
     /**
      * Creates a valid href string for a given path.
+     *
+     * @param to - Target path or partial path object
+     * @returns Fully-qualified href string
      */
     createHref(to: To): string;
     /**
-     * Creates a URL object for a given path.
+     * Creates a {@link URL} object for a given path.
+     *
+     * @param to - Target path or partial path object
+     * @returns Resolved {@link URL} instance
      */
     createURL(to: To): URL;
     /**
      * Encodes a location by properly URL-encoding the pathname.
+     *
+     * @param to - Target path or partial path object
+     * @returns A {@link Path} with URL-encoded components
      */
     encodeLocation(to: To): Path;
     /**

package/dist/types/lib/BrowserHistoryStack.d.ts

@@ -1,16 +1,15 @@
 import type { HistoryStack, Location, To } from './types';
 /**
- * Browser history stack implementation using native browser APIs.
+ * Browser history stack implementation using the native History API.
  *
- * Manages navigation state using the browser's History API (pushState/replaceState).
- * Stores location state in history.state and uses relative paths for navigation.
- * This is the base implementation for regular (non-hash) routing.
+ * Manages navigation state via `pushState` / `replaceState` and stores
+ * location state in `history.state`. This is the default stack for
+ * pathname-based (non-hash) routing.
  *
  * @example
  * ```ts
  * const stack = new BrowserHistoryStack(window);
- * stack.push({ pathname: '/users', key: 'abc123', state: { userId: 1 } });
- * // Updates URL to /users and adds entry to history
+ * stack.push({ pathname: '/users', search: '', hash: '', key: 'abc', state: null });
  * ```
  */
 export declare class BrowserHistoryStack implements HistoryStack {

package/dist/types/lib/MemoryHistory.d.ts

@@ -12,11 +12,11 @@ export type MemoryHistoryOptions = {
 /**
  * Memory history implementation using in-memory storage.
  *
- * Useful for:
- * - Testing: Control navigation state in tests without browser APIs
- * - SSR: Server-side rendering where window is not available
- * - Widgets: Serving applications as widgets without affecting the main browser history
- * - Node.js environments: Environments without browser APIs
+ * Does not touch browser APIs, making it suitable for:
+ * - **Testing** — deterministic navigation state without a DOM
+ * - **SSR** — server-side rendering where `window` is unavailable
+ * - **Widgets** — embedded apps that must not alter the host page URL
+ * - **Node.js** — any environment without browser history APIs
  */
 export declare class MemoryHistory extends BaseHistory {
     constructor(options?: MemoryHistoryOptions);

package/dist/types/lib/create-history.d.ts

@@ -9,25 +9,19 @@ type HistoryCtorMap = {
  * Creates a history instance based on the specified type.
  *
  * Factory function for creating different history implementations:
- * - `'browser'`: Creates a {@link BrowserHistory} instance using regular routing (pathname-based)
- * - `'hash'`: Creates a {@link BrowserHistory} instance using hash routing (hash-based)
- * - `'memory'`: Creates a {@link MemoryHistory} instance for testing or SSR (in-memory)
+ * - `'browser'`: Creates a {@link BrowserHistory} using pathname-based routing
+ * - `'hash'`: Creates a {@link BrowserHistory} using hash-based routing (`#/path`)
+ * - `'memory'`: Creates a {@link MemoryHistory} for testing, SSR, or widget apps
  *
- * All returned instances are compatible with industry-standard routers (Remix/React Router).
- *
- * @param type - The type of history to create ('browser', 'hash', or 'memory')
- * @param args - Optional arguments for the history type
- * @returns A History instance compatible with industry-standard routers (Remix/React Router)
+ * @param type - The type of history to create (`'browser'`, `'hash'`, or `'memory'`)
+ * @param args - Optional arguments forwarded to the history constructor
+ * @returns A {@link History} instance of the requested type
+ * @throws {Error} If `type` is not one of `'browser'`, `'hash'`, or `'memory'`
  *
  * @example
  * ```ts
- * // Regular browser routing
  * const history = createHistory('browser');
- *
- * // Hash-based routing
  * const hashHistory = createHistory('hash');
- *
- * // In-memory history for testing
  * const memoryHistory = createHistory('memory', { initialLocation: { ... } });
  * ```
  */

package/dist/types/lib/index.d.ts

@@ -1,3 +1,12 @@
+/**
+ * Internal history implementations, stacks, and types.
+ *
+ * @remarks
+ * This sub-module is re-exported as `@equinor/fusion-framework-module-navigation/lib`
+ * and provides the low-level building blocks for navigation state management.
+ *
+ * @packageDocumentation
+ */
 export { BaseHistory } from './BaseHistory';
 export { BrowserHistory } from './BrowserHistory';
 export { MemoryHistory } from './MemoryHistory';

package/dist/types/lib/state/history.flows.d.ts

@@ -74,19 +74,14 @@ export declare const validateCurrentLocation: HistoryFlowCreator;
 /**
  * Creates a combined history flow from multiple flow creators.
  *
- * Execution flow:
- * 1. Creates a preprocessing step that applies blocker checking (unless skipped)
- * 2. Initializes each flow creator with the stack to create individual flows
- * 3. Merges all flows so they process actions in parallel
- * 4. Returns a combined flow that:
- *    - First applies preprocessing (blocker checking)
- *    - Then processes actions through all merged flows
- *    - Emits results from any flow that matches the action
+ * Merges all provided flows so they process actions in parallel.
+ * Optionally prepends a blocker-checking step that gates navigation
+ * actions through registered {@link NavigationBlocker | blockers}.
  *
  * @param flowCreators - Array of flow creators to combine
- * @param options - Optional configuration options
- * @param options.skipBlockCheck - If true, skip blocker checking
- * @returns A combined history flow creator
+ * @param options - Optional configuration
+ * @param options.skipBlockCheck - If `true`, skip blocker checking
+ * @returns A combined {@link HistoryFlowCreator} that merges all provided flows
  */
 export declare const createFlow: (flowCreators: HistoryFlowCreator[], options?: {
     skipBlockCheck?: boolean;

package/dist/types/lib/state/history.reducer.d.ts

@@ -2,10 +2,14 @@ import type { LocationState, NavigationUpdate } from '../types';
 /**
  * Creates a reducer for history state management.
  *
- * @param initial - Initial navigation update or function that returns initial state
- * @param options - Optional configuration options
- * @param options.maxHistory - Maximum number of history entries to keep (default: 100)
- * @returns A reducer for history state
+ * Handles navigate, go, and pop success actions by updating the
+ * history array and current location. Enforces a maximum history
+ * length to prevent unbounded memory growth.
+ *
+ * @param initial - Initial navigation update or factory returning initial state
+ * @param options - Optional configuration
+ * @param options.maxHistory - Maximum number of history entries to keep (default: `100`)
+ * @returns A reducer with initial state for use with {@link createStore}
  */
 export declare const createHistoryReducer: (initial: NavigationUpdate | (() => LocationState), options?: {
     maxHistory?: number;

package/dist/types/lib/state/history.state.d.ts

@@ -15,10 +15,16 @@ export declare const defaultFlows: HistoryFlowCreator[];
 /**
  * Creates a history store with the specified stack and reducer.
  *
- * @param stack - The history stack implementation
- * @param reducer - The reducer for history state
+ * Combines the reactive state container with a {@link HistoryStack} and wires
+ * up navigation flows for action processing.
+ *
+ * @param stack - The history stack implementation (browser, hash, or memory)
+ * @param reducer - The reducer that handles state transitions
  * @param options - Optional configuration options
- * @returns A HistoryState instance
+ * @param options.flows - Custom flow creators (defaults to {@link defaultFlows})
+ * @param options.skipBlockCheck - Skip blocker checking in flows
+ * @param options.validateCurrentLocation - Add location validation flow
+ * @returns A fully-initialized {@link HistoryState} with flows attached
  */
 export declare const createStore: (stack: HistoryStack, reducer: ReducerWithInitialState<LocationState, Actions>, options?: {
     flows?: HistoryFlowCreator[];

package/dist/types/lib/types.d.ts

@@ -38,11 +38,15 @@ export type Path = {
 };
 /**
  * Location object representing a navigation entry.
- * Extends Path with state and a unique key.
+ * Extends {@link Path} with arbitrary state data and a unique key.
+ *
+ * @template T - The type of the state payload stored in this location entry
  */
 export type Location<T = any> = Path & {
     state: T;
     key: string;
+    /** Masked path used by react-router 7.13+ for unstable view-transition masking. */
+    unstable_mask: Path | undefined;
 };
 /**
  * Internal state for history management.
@@ -57,7 +61,10 @@ export type LocationState = {
  */
 export type NavigationListener = (update: Readonly<NavigationUpdate>) => void;
 /**
- * Navigation update event containing action and location.
+ * Navigation update event containing the action, location, and stack delta.
+ *
+ * @template A - The type of navigation action (defaults to {@link Action})
+ * @template T - The type of the state payload in the location
  */
 export type NavigationUpdate<A extends string = Action, T = unknown> = {
     delta: number;
@@ -96,7 +103,16 @@ export interface NavigateOptions {
 }
 /**
  * History interface for managing navigation state.
- * Compatible with industry-standard routers (Remix/React Router) and provides observable state management.
+ *
+ * Compatible with Remix / React Router and provides observable
+ * state management via RxJS.
+ *
+ * @example
+ * ```ts
+ * const history = createHistory('browser');
+ * history.push('/dashboard');
+ * history.state$.subscribe(update => console.log(update.location.pathname));
+ * ```
  */
 export interface History extends Disposable {
     /** Observable stream of navigation state updates. */
@@ -107,11 +123,20 @@ export interface History extends Disposable {
     readonly action: Action;
     /** Current location in the history stack. */
     readonly location: Location;
-    /** Creates a valid href string for a given path. */
+    /** Creates a valid href string for a given path.
+     * @param to - Target path or partial path object
+     * @returns Fully-qualified href string
+     */
     createHref(to: To): string;
-    /** Creates a URL object for a given path. */
+    /** Creates a {@link URL} object for a given path.
+     * @param to - Target path or partial path object
+     * @returns Resolved {@link URL} instance
+     */
     createURL(to: To): URL;
-    /** Encodes a location by properly URL-encoding the pathname. */
+    /** Encodes a location by properly URL-encoding the pathname.
+     * @param to - Target path or partial path object
+     * @returns A {@link Path} with URL-encoded components
+     */
     encodeLocation(to: To): Path;
     /** Pushes a new navigation entry onto the history stack. */
     push(to: To, state?: unknown): void;
@@ -121,9 +146,15 @@ export interface History extends Disposable {
     navigate(to: To, options?: NavigateOptions): void;
     /** Navigates backward or forward in the history stack. */
     go(delta: number): void;
-    /** Sets up a listener for navigation changes. */
+    /** Sets up a listener for navigation changes.
+     * @param listener - Callback invoked on POP actions (browser back/forward)
+     * @returns A function that unsubscribes the listener when called
+     */
     listen(listener: NavigationListener): () => void;
-    /** Registers a blocker to intercept navigation attempts. */
+    /** Registers a blocker to intercept navigation attempts.
+     * @param blocker - Callback invoked before each navigation to allow or prevent it
+     * @returns A function that removes the blocker when called
+     */
     block(blocker: NavigationBlocker): VoidFunction;
 }
 /**

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const version = "7.0.0-next.1";
+export declare const version = "7.0.0";