feat: Fluent UI Outlook Lite + connections mockup

node_modules/tabster/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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

node_modules/tabster/README.md

@@ -0,0 +1,55 @@
+# Tabster
+
+_Tabindex on steroids._
+
+A set of tools and concepts for making a dynamic web application properly accessible and keyboard-navigable.
+
+[https://tabster.io](https://tabster.io).
+
+## About
+
+The way a browser and the screen readers handle a web application is evolved from the static web era. A process of making a modern dynamic web application accessible presents a number of challenges like, for example, the proper focus management between modal dialogs, popups, lists and other parts of the dynamically changing application. This project is an attempt to solve some of those challenges.
+
+## Dependencies
+
+This project is framework-agnostic. It operates on the DOM level and has no external runtime dependencies. Though it is possible that your framework or application might have own logic to achieve similar result, in that case runtime conflicts and behavioural inconsistencies are definitely possible. At the same time, it does not do things automatically and parts of it should be explicitly enabled.
+
+## Parts
+
+### Focusable
+
+An API for traversing focusable elements.
+
+### Deloser
+
+When you remove, for example, a button which has focus from the DOM, the focus gets lost which is confusing for the screen reader and keyboard navigation users. Deloser is a concept which helps to automatically restore the focus when it gets lost without manually calling `.focus()` method from the application code.
+
+### FocusedElementState
+
+An event and a couple of methods to track and change currently focused element.
+
+### KeyboardNavigationState
+
+An event and a method to determine if the user is using keyboard to navigate through the application.
+
+### Groupper
+
+Keyboard navigation for the lists should allow to avoid going through every list item when the users use Tab key (only one item of the list should be tabbable), also the arrow keys and Home/End/PageUp/PageDown keys should be handled to move between the list items. This is an API to easily make properly behaving lists.
+
+### Modalizer
+
+When you show, for example, a modal dialog, the rest of the application might need to be excluded from the keyboard and screen reader navigation flow. Modalizer is a concept to conveniently make that possible.
+
+### Outline
+
+When people navigate with the keyboard, the currently focused element should be properly highlighted. There is a CSS property called `outline`, which is unfortunately insufficient: the outline of an element gets cropped when a parent element has `overflow: hidden`, there is no way to limit the outline visibility to only the cases when the user is navigating with keyboard. So, we have a custom outline component which is supposed to solve both of the problems.
+
+## Contributing
+
+Contributions are welcome (see the [CONTRIBUTING](./CONTRIBUTING.md) file), though please keep in mind the work-in-progress proof-of-concept state. Might make sense to just observe/discuss until the thing gets stable and well-documented.
+
+The repo now has an examples project powered by Storybook. Just run `npm start`
+
+## License
+
+This project is licensed under the MIT License, see the [LICENSE](LICENSE) file for details.

node_modules/tabster/dist/dts/AttributeHelpers.d.ts

@@ -0,0 +1,25 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import * as Types from "./Types";
+export declare function getTabsterAttribute(props: Types.TabsterAttributeProps): Types.TabsterDOMAttribute;
+export declare function getTabsterAttribute(props: Types.TabsterAttributeProps, plain: true): string;
+/**
+ * Updates Tabster props object with new props.
+ * @param element an element to set data-tabster attribute on.
+ * @param props current Tabster props to update.
+ * @param newProps new Tabster props to add.
+ *  When the value of a property in newProps is undefined, the property
+ *  will be removed from the attribute.
+ */
+export declare function mergeTabsterProps(props: Types.TabsterAttributeProps, newProps: Types.TabsterAttributeProps): void;
+/**
+ * Sets or updates Tabster attribute of the element.
+ * @param element an element to set data-tabster attribute on.
+ * @param newProps new Tabster props to set.
+ * @param update if true, newProps will be merged with the existing props.
+ *  When true and the value of a property in newProps is undefined, the property
+ *  will be removed from the attribute.
+ */
+export declare function setTabsterAttribute(element: HTMLElement, newProps: Types.TabsterAttributeProps, update?: boolean): void;

node_modules/tabster/dist/dts/Consts.d.ts

@@ -0,0 +1,93 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export declare const TABSTER_ATTRIBUTE_NAME: "data-tabster";
+export declare const TABSTER_DUMMY_INPUT_ATTRIBUTE_NAME: "data-tabster-dummy";
+export declare const FOCUSABLE_SELECTOR: string;
+export declare const AsyncFocusSources: {
+    readonly EscapeGroupper: 1;
+    readonly Restorer: 2;
+    readonly Deloser: 3;
+};
+export declare const ObservedElementAccessibilities: {
+    readonly Any: 0;
+    readonly Accessible: 1;
+    readonly Focusable: 2;
+};
+export declare const ObservedElementRequestStatuses: {
+    readonly Waiting: 0;
+    readonly Succeeded: 1;
+    readonly Canceled: 2;
+    readonly TimedOut: 3;
+};
+export declare const ObservedElementFailureReasons: {
+    readonly CanceledFocusChange: 1;
+    readonly TimeoutElementNotInDOM: 2;
+    readonly TimeoutElementNotAccessible: 3;
+    readonly TimeoutElementNotFocusable: 4;
+    readonly TimeoutElementNotReady: 5;
+    readonly SupersededByNewRequest: 6;
+    readonly FocusCallFailed: 7;
+};
+export declare const RestoreFocusOrders: {
+    readonly History: 0;
+    readonly DeloserDefault: 1;
+    readonly RootDefault: 2;
+    readonly DeloserFirst: 3;
+    readonly RootFirst: 4;
+};
+export declare const DeloserStrategies: {
+    /**
+     * If the focus is lost, the focus will be restored automatically using all available focus history.
+     * This is the default strategy.
+     */
+    readonly Auto: 0;
+    /**
+     * If the focus is lost from this Deloser instance, the focus will not be restored automatically.
+     * The application might listen to the event and restore the focus manually.
+     * But if it is lost from another Deloser instance, the history of this Deloser could be used finding
+     * the element to focus.
+     */
+    readonly Manual: 1;
+};
+export declare const Visibilities: {
+    readonly Invisible: 0;
+    readonly PartiallyVisible: 1;
+    readonly Visible: 2;
+};
+export declare const RestorerTypes: {
+    readonly Source: 0;
+    readonly Target: 1;
+};
+export declare const MoverDirections: {
+    readonly Both: 0;
+    readonly Vertical: 1;
+    readonly Horizontal: 2;
+    readonly Grid: 3;
+    readonly GridLinear: 4;
+};
+export declare const MoverKeys: {
+    readonly ArrowUp: 1;
+    readonly ArrowDown: 2;
+    readonly ArrowLeft: 3;
+    readonly ArrowRight: 4;
+    readonly PageUp: 5;
+    readonly PageDown: 6;
+    readonly Home: 7;
+    readonly End: 8;
+};
+export declare const GroupperTabbabilities: {
+    readonly Unlimited: 0;
+    readonly Limited: 1;
+    readonly LimitedTrapFocus: 2;
+};
+export declare const GroupperMoveFocusActions: {
+    readonly Enter: 1;
+    readonly Escape: 2;
+};
+export declare const SysDummyInputsPositions: {
+    readonly Auto: 0;
+    readonly Inside: 1;
+    readonly Outside: 2;
+};

node_modules/tabster/dist/dts/CrossOrigin.d.ts

@@ -0,0 +1,130 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { Subscribable } from "./State/Subscribable";
+import * as Types from "./Types";
+interface CrossOriginInstanceContext {
+    ignoreKeyboardNavigationStateUpdate: boolean;
+    focusOwner?: string;
+    focusOwnerTimestamp?: number;
+    deloserByUId: {
+        [uid: string]: Types.Deloser;
+    };
+    origOutlineSetup?: (props?: Partial<Types.OutlineProps>) => void;
+}
+interface KnownTargets {
+    [id: string]: {
+        send: (payload: Types.CrossOriginTransactionData<any, any>) => void;
+        last?: number;
+    };
+}
+declare abstract class CrossOriginTransaction<I, O> {
+    abstract type: Types.CrossOriginTransactionType;
+    readonly id: string;
+    readonly beginData: I;
+    readonly timeout?: number;
+    protected tabster: Types.TabsterCore;
+    protected endData: O | undefined;
+    protected owner: Types.GetWindow;
+    protected ownerId: string;
+    protected sendUp: Types.CrossOriginTransactionSend | undefined;
+    private _promise;
+    protected _resolve: ((endData?: O | PromiseLike<O>) => void) | undefined;
+    private _reject;
+    private _knownTargets;
+    private _sentTo;
+    protected targetId: string | undefined;
+    private _inProgress;
+    private _isDone;
+    private _isSelfResponding;
+    private _sentCount;
+    constructor(tabster: Types.TabsterCore, getOwner: Types.GetWindow, knownTargets: KnownTargets, value: I, timeout?: number, sentTo?: Types.CrossOriginSentTo, targetId?: string, sendUp?: Types.CrossOriginTransactionSend);
+    protected getTargets(knownTargets: KnownTargets): KnownTargets | null;
+    begin(selfResponse?: (data: Types.CrossOriginTransactionData<I, O>) => Promise<O | undefined>): Promise<O | undefined>;
+    private _send;
+    end(error?: string): void;
+    onResponse(data: Types.CrossOriginTransactionData<I, O>): void;
+}
+interface CrossOriginTransactionClass<I, O> {
+    new (tabster: Types.TabsterCore, getOwner: Types.GetWindow, knownTargets: KnownTargets, value: I, timeout?: number, sentTo?: Types.CrossOriginSentTo, targetId?: string, sendUp?: Types.CrossOriginTransactionSend): CrossOriginTransaction<I, O>;
+    shouldForward?(tabster: Types.TabsterCore, data: Types.CrossOriginTransactionData<I, O>, getOwner: Types.GetWindow, ownerId: string): boolean;
+    makeResponse(tabster: Types.TabsterCore, data: Types.CrossOriginTransactionData<I, O>, getOwner: Types.GetWindow, ownerId: string, transactions: CrossOriginTransactions, forwardResult: Promise<O | undefined>, isSelfResponse?: boolean): Promise<O>;
+    shouldSelfRespond?(tabster: Types.TabsterCore, data: I, getOwner: Types.GetWindow, ownerId: string): boolean;
+}
+declare class CrossOriginTransactions {
+    private _owner;
+    private _ownerUId;
+    private _knownTargets;
+    private _transactions;
+    private _tabster;
+    private _pingTimer;
+    private _isDefaultSendUp;
+    private _deadPromise;
+    isSetUp: boolean;
+    sendUp: Types.CrossOriginTransactionSend | undefined;
+    ctx: CrossOriginInstanceContext;
+    constructor(tabster: Types.TabsterCore, getOwner: Types.GetWindow, context: CrossOriginInstanceContext);
+    setup(sendUp?: Types.CrossOriginTransactionSend | null): (msg: Types.CrossOriginMessage) => void;
+    setSendUp(sendUp?: Types.CrossOriginTransactionSend | null): (msg: Types.CrossOriginMessage) => void;
+    dispose(): Promise<void>;
+    beginTransaction<I, O>(Transaction: CrossOriginTransactionClass<I, O>, value: I, timeout?: number, sentTo?: Types.CrossOriginSentTo, targetId?: string, withReject?: boolean): Promise<O | undefined>;
+    removeTarget(uid: string): void;
+    private _beginTransaction;
+    forwardTransaction(data: Types.CrossOriginTransactionData<any, any>): Promise<any>;
+    private _getTransactionClass;
+    private _onMessage;
+    private _onPageHide;
+    private _dead;
+    private _ping;
+    private _onBrowserMessage;
+}
+export declare class CrossOriginElement implements Types.CrossOriginElement {
+    private _tabster;
+    readonly uid: string;
+    readonly ownerId: string;
+    readonly id?: string;
+    readonly rootId?: string;
+    readonly observedName?: string;
+    readonly observedDetails?: string;
+    constructor(tabster: Types.TabsterCore, uid: string, ownerId: string, id?: string, rootId?: string, observedName?: string, observedDetails?: string);
+    focus(noFocusedProgrammaticallyFlag?: boolean, noAccessibleCheck?: boolean): Promise<boolean>;
+}
+export declare class CrossOriginFocusedElementState extends Subscribable<CrossOriginElement | undefined, Types.FocusedElementDetail> implements Types.CrossOriginFocusedElementState {
+    private _transactions;
+    constructor(transactions: CrossOriginTransactions);
+    focus(element: Types.CrossOriginElement, noFocusedProgrammaticallyFlag?: boolean, noAccessibleCheck?: boolean): Promise<boolean>;
+    focusById(elementId: string, rootId?: string, noFocusedProgrammaticallyFlag?: boolean, noAccessibleCheck?: boolean): Promise<boolean>;
+    focusByObservedName(observedName: string, timeout?: number, rootId?: string, noFocusedProgrammaticallyFlag?: boolean, noAccessibleCheck?: boolean): Promise<boolean>;
+    private _focus;
+    static setVal(instance: Types.CrossOriginFocusedElementState, val: CrossOriginElement | undefined, detail: Types.FocusedElementDetail): void;
+}
+export declare class CrossOriginObservedElementState extends Subscribable<CrossOriginElement, Types.ObservedElementProps> implements Types.CrossOriginObservedElementState {
+    private _tabster;
+    private _transactions;
+    private _lastRequestFocusId;
+    constructor(tabster: Types.TabsterCore, transactions: CrossOriginTransactions);
+    getElement(observedName: string, accessibility?: Types.ObservedElementAccessibility): Promise<CrossOriginElement | null>;
+    waitElement(observedName: string, timeout: number, accessibility?: Types.ObservedElementAccessibility): Promise<CrossOriginElement | null>;
+    requestFocus(observedName: string, timeout: number): Promise<boolean>;
+    static trigger(instance: Types.CrossOriginObservedElementState, element: CrossOriginElement, details: Types.ObservedElementProps): void;
+}
+export declare class CrossOriginAPI implements Types.CrossOriginAPI {
+    private _tabster;
+    private _win;
+    private _transactions;
+    private _blurTimer;
+    private _ctx;
+    focusedElement: Types.CrossOriginFocusedElementState;
+    observedElement: Types.CrossOriginObservedElementState;
+    constructor(tabster: Types.TabsterCore);
+    setup(sendUp?: Types.CrossOriginTransactionSend | null): (msg: Types.CrossOriginMessage) => void;
+    isSetUp(): boolean;
+    private _init;
+    dispose(): void;
+    private _onKeyboardNavigationStateChanged;
+    private _onFocus;
+    private _onObserved;
+    private _outlineSetup;
+}
+export {};

node_modules/tabster/dist/dts/DOMAPI.d.ts

@@ -0,0 +1,7 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { DOMAPI } from "./Types";
+export declare const dom: DOMAPI;
+export declare function setDOMAPI(domapi: Partial<DOMAPI>): void;

node_modules/tabster/dist/dts/Deloser.d.ts

@@ -0,0 +1,104 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import * as Types from "./Types";
+import { TabsterPart } from "./Utils";
+export declare abstract class DeloserItemBase<C> {
+    abstract resetFocus(): Promise<boolean>;
+    abstract belongsTo(deloser: C): boolean;
+}
+export declare class DeloserItem extends DeloserItemBase<Types.Deloser> {
+    readonly uid: string;
+    private _tabster;
+    private _deloser;
+    constructor(tabster: Types.TabsterCore, deloser: Types.Deloser);
+    belongsTo(deloser: Types.Deloser): boolean;
+    unshift(element: HTMLElement): void;
+    focusAvailable(): Promise<boolean | null>;
+    resetFocus(): Promise<boolean>;
+}
+export declare abstract class DeloserHistoryByRootBase<I, D extends DeloserItemBase<I>> {
+    protected _tabster: Types.TabsterCore;
+    protected _history: D[];
+    readonly rootUId: string;
+    constructor(tabster: Types.TabsterCore, rootUId: string);
+    getLength(): number;
+    removeDeloser(deloser: I): void;
+    hasDeloser(deloser: I): boolean;
+    abstract focusAvailable(from: I | null): Promise<boolean | null>;
+    abstract resetFocus(from: I | null): Promise<boolean>;
+}
+export declare class DeloserHistory {
+    private _tabster;
+    private _history;
+    constructor(tabster: Types.TabsterCore);
+    dispose(): void;
+    process(element: HTMLElement): Types.Deloser | undefined;
+    make<I, D extends DeloserItemBase<I>, C extends DeloserHistoryByRootBase<I, D>>(rootUId: string, createInstance: () => C): C;
+    removeDeloser(deloser: Types.Deloser): void;
+    focusAvailable(from: Types.Deloser | null): Promise<boolean | null>;
+    resetFocus(from: Types.Deloser | null): Promise<boolean>;
+}
+export declare class Deloser extends TabsterPart<Types.DeloserProps> implements Types.Deloser {
+    readonly uid: string;
+    readonly strategy: Types.DeloserStrategy;
+    private _isActive;
+    private _history;
+    private _snapshotIndex;
+    private _onDispose;
+    constructor(tabster: Types.TabsterCore, element: HTMLElement, onDispose: (deloser: Deloser) => void, props: Types.DeloserProps);
+    dispose(): void;
+    isActive: () => boolean;
+    setActive(active: boolean): void;
+    getActions(): Types.DeloserElementActions;
+    setSnapshot: (index: number) => void;
+    focusFirst: () => boolean;
+    unshift(element: HTMLElement): void;
+    focusDefault: () => boolean;
+    resetFocus: () => boolean;
+    findAvailable(): HTMLElement | null;
+    clearHistory: (preserveExisting?: boolean) => void;
+    customFocusLostHandler(element: HTMLElement): boolean;
+    private _findInHistory;
+    private _findFirst;
+    private _remove;
+}
+export declare class DeloserAPI implements Types.DeloserAPI {
+    private _tabster;
+    private _win;
+    /**
+     * Tracks if focus is inside a deloser
+     */
+    private _inDeloser;
+    private _curDeloser;
+    private _history;
+    private _restoreFocusTimer;
+    private _isRestoringFocus;
+    private _isPaused;
+    private _autoDeloser;
+    private _autoDeloserInstance;
+    constructor(tabster: Types.TabsterCore, props?: {
+        autoDeloser: Types.DeloserProps;
+    });
+    dispose(): void;
+    createDeloser(element: HTMLElement, props: Types.DeloserProps): Types.Deloser;
+    getActions(element: HTMLElement): Types.DeloserElementActions | undefined;
+    pause(): void;
+    resume(restore?: boolean): void;
+    private _onRestoreFocus;
+    private _onFocus;
+    /**
+     * Activates and sets the current deloser
+     */
+    private _activate;
+    /**
+     * Called when focus should no longer be in a deloser
+     */
+    private _deactivate;
+    private _scheduleRestoreFocus;
+    static getDeloser(tabster: Types.TabsterCore, element: HTMLElement): Types.Deloser | undefined;
+    private _onDeloserDispose;
+    static getHistory(instance: Types.DeloserAPI): DeloserHistory;
+    static forceRestoreFocus(instance: Types.DeloserAPI): void;
+}

node_modules/tabster/dist/dts/Deprecated.d.ts

@@ -0,0 +1,11 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { GroupperMoveFocusAction, MoverKey } from "./Types";
+/** @deprecated This function is obsolete, use native element.dispatchEvent(new GroupperMoveFocusEvent(...)). */
+export declare function dispatchGroupperMoveFocusEvent(target: HTMLElement, action: GroupperMoveFocusAction): boolean;
+/** @deprecated This function is obsolete, use native element.dispatchEvent(new MoverMoveFocusEvent(...)). */
+export declare function dispatchMoverMoveFocusEvent(target: HTMLElement, key: MoverKey): boolean;
+/** @deprecated This function is obsolete, use native element.dispatchEvent(new MoverMemorizedElementEvent(...)). */
+export declare function dispatchMoverMemorizedElementEvent(target: HTMLElement, memorizedElement: HTMLElement | undefined): boolean;

node_modules/tabster/dist/dts/Events.d.ts

@@ -0,0 +1,124 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import * as Types from "./Types";
+import * as EventsTypes from "./EventsTypes";
+/**
+ * Events sent by Tabster.
+ */
+export declare const TabsterFocusInEventName = "tabster:focusin";
+export declare const TabsterFocusOutEventName = "tabster:focusout";
+export declare const TabsterMoveFocusEventName = "tabster:movefocus";
+/**
+ * Events sent by Deloser.
+ */
+export declare const DeloserFocusLostEventName = "tabster:deloser:focus-lost";
+/**
+ * Events to be sent to Deloser by the application.
+ */
+export declare const DeloserRestoreFocusEventName = "tabster:deloser:restore-focus";
+/**
+ * Events sent by Modalizer.
+ */
+export declare const ModalizerActiveEventName = "tabster:modalizer:active";
+export declare const ModalizerInactiveEventName = "tabster:modalizer:inactive";
+export declare const ModalizerFocusInEventName = "tabster:modalizer:focusin";
+export declare const ModalizerFocusOutEventName = "tabster:modalizer:focusout";
+/**
+ * Events sent by Mover.
+ */
+export declare const MoverStateEventName = "tabster:mover:state";
+/**
+ * Events to be sent to Mover by the application.
+ */
+export declare const MoverMoveFocusEventName = "tabster:mover:movefocus";
+export declare const MoverMemorizedElementEventName = "tabster:mover:memorized-element";
+/**
+ * Events sent by Groupper.
+ */
+/**
+ * Events to be sent to Groupper by the application.
+ */
+export declare const GroupperMoveFocusEventName = "tabster:groupper:movefocus";
+/**
+ * Events sent by Restorer.
+ */
+export declare const RestorerRestoreFocusEventName = "tabster:restorer:restore-focus";
+/**
+ * Events sent by Root.
+ */
+export declare const RootFocusEventName = "tabster:root:focus";
+export declare const RootBlurEventName = "tabster:root:blur";
+declare const CustomEvent_: {
+    new <T>(type: string, eventInitDict?: CustomEventInit<T>): CustomEvent<T>;
+    prototype: CustomEvent;
+};
+export declare abstract class TabsterCustomEvent<D> extends CustomEvent_<D> {
+    /**
+     * @deprecated use `detail`.
+     */
+    details?: D;
+    constructor(type: string, detail?: D);
+}
+export declare class TabsterFocusInEvent extends TabsterCustomEvent<Types.FocusedElementDetail> {
+    constructor(detail: Types.FocusedElementDetail);
+}
+export declare class TabsterFocusOutEvent extends TabsterCustomEvent<Types.FocusedElementDetail> {
+    constructor(detail: Types.FocusedElementDetail);
+}
+export declare class TabsterMoveFocusEvent extends TabsterCustomEvent<EventsTypes.TabsterMoveFocusEventDetail> {
+    constructor(detail: EventsTypes.TabsterMoveFocusEventDetail);
+}
+export declare class MoverStateEvent extends TabsterCustomEvent<Types.MoverElementState> {
+    constructor(detail: Types.MoverElementState);
+}
+export declare class MoverMoveFocusEvent extends TabsterCustomEvent<EventsTypes.MoverMoveFocusEventDetail> {
+    constructor(detail: EventsTypes.MoverMoveFocusEventDetail);
+}
+export declare class MoverMemorizedElementEvent extends TabsterCustomEvent<EventsTypes.MoverMemorizedElementEventDetail> {
+    constructor(detail: EventsTypes.MoverMemorizedElementEventDetail);
+}
+export declare class GroupperMoveFocusEvent extends TabsterCustomEvent<EventsTypes.GroupperMoveFocusEventDetail> {
+    constructor(detail: EventsTypes.GroupperMoveFocusEventDetail);
+}
+export declare class ModalizerActiveEvent extends TabsterCustomEvent<EventsTypes.ModalizerEventDetail> {
+    constructor(detail: EventsTypes.ModalizerEventDetail);
+}
+export declare class ModalizerInactiveEvent extends TabsterCustomEvent<EventsTypes.ModalizerEventDetail> {
+    constructor(detail: EventsTypes.ModalizerEventDetail);
+}
+export declare class DeloserFocusLostEvent extends TabsterCustomEvent<Types.DeloserElementActions> {
+    constructor(detail: Types.DeloserElementActions);
+}
+export declare class DeloserRestoreFocusEvent extends TabsterCustomEvent<undefined> {
+    constructor();
+}
+export declare class RestorerRestoreFocusEvent extends TabsterCustomEvent<undefined> {
+    constructor();
+}
+export declare class RootFocusEvent extends TabsterCustomEvent<EventsTypes.RootFocusEventDetail> {
+    constructor(detail: EventsTypes.RootFocusEventDetail);
+}
+export declare class RootBlurEvent extends TabsterCustomEvent<EventsTypes.RootFocusEventDetail> {
+    constructor(detail: EventsTypes.RootFocusEventDetail);
+}
+declare global {
+    interface GlobalEventHandlersEventMap {
+        [TabsterFocusInEventName]: TabsterFocusInEvent;
+        [TabsterFocusOutEventName]: TabsterFocusOutEvent;
+        [TabsterMoveFocusEventName]: TabsterMoveFocusEvent;
+        [MoverStateEventName]: MoverStateEvent;
+        [MoverMoveFocusEventName]: MoverMoveFocusEvent;
+        [MoverMemorizedElementEventName]: MoverMemorizedElementEvent;
+        [GroupperMoveFocusEventName]: GroupperMoveFocusEvent;
+        [ModalizerActiveEventName]: ModalizerActiveEvent;
+        [ModalizerInactiveEventName]: ModalizerInactiveEvent;
+        [DeloserFocusLostEventName]: DeloserFocusLostEvent;
+        [DeloserRestoreFocusEventName]: DeloserRestoreFocusEvent;
+        [RestorerRestoreFocusEventName]: RestorerRestoreFocusEvent;
+        [RootFocusEventName]: RootFocusEvent;
+        [RootBlurEventName]: RootBlurEvent;
+    }
+}
+export {};

node_modules/tabster/dist/dts/EventsTypes.d.ts

@@ -0,0 +1,27 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import * as Types from "./Types";
+export interface TabsterMoveFocusEventDetail {
+    by: "mover" | "groupper" | "modalizer" | "root" | "deloser";
+    owner: HTMLElement;
+    next: HTMLElement | null;
+    relatedEvent?: KeyboardEvent;
+}
+export interface MoverMoveFocusEventDetail {
+    key: Types.MoverKey;
+}
+export interface MoverMemorizedElementEventDetail {
+    memorizedElement: HTMLElement | undefined;
+}
+export interface GroupperMoveFocusEventDetail {
+    action: Types.GroupperMoveFocusAction;
+}
+export interface ModalizerEventDetail {
+    id: string;
+    element: HTMLElement;
+}
+export interface RootFocusEventDetail {
+    element: HTMLElement;
+}

node_modules/tabster/dist/dts/Focusable.d.ts

@@ -0,0 +1,25 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import * as Types from "./Types";
+export declare class FocusableAPI implements Types.FocusableAPI {
+    private _tabster;
+    constructor(tabster: Types.TabsterCore);
+    dispose(): void;
+    getProps(element: HTMLElement): Types.FocusableProps;
+    isFocusable(el: HTMLElement, includeProgrammaticallyFocusable?: boolean, noVisibleCheck?: boolean, noAccessibleCheck?: boolean): boolean;
+    isVisible(el: HTMLElement): boolean;
+    isAccessible(el: HTMLElement): boolean;
+    private _isDisabled;
+    private _isHidden;
+    findFirst(options: Types.FindFirstProps, out?: Types.FindFocusableOutputProps): HTMLElement | null | undefined;
+    findLast(options: Types.FindFirstProps, out?: Types.FindFocusableOutputProps): HTMLElement | null | undefined;
+    findNext(options: Types.FindNextProps, out?: Types.FindFocusableOutputProps): HTMLElement | null | undefined;
+    findPrev(options: Types.FindNextProps, out?: Types.FindFocusableOutputProps): HTMLElement | null | undefined;
+    findDefault(options: Types.FindDefaultProps, out?: Types.FindFocusableOutputProps): HTMLElement | null;
+    findAll(options: Types.FindAllProps): HTMLElement[];
+    findElement(options: Types.FindFocusableProps, out?: Types.FindFocusableOutputProps): HTMLElement | null | undefined;
+    private _findElements;
+    private _acceptElement;
+}

node_modules/tabster/dist/dts/Groupper.d.ts

@@ -0,0 +1,46 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import * as Types from "./Types";
+import { DummyInputManager, TabsterPart, WeakHTMLElement } from "./Utils";
+declare class GroupperDummyManager extends DummyInputManager {
+    constructor(element: WeakHTMLElement, groupper: Groupper, tabster: Types.TabsterCore, sys: Types.SysProps | undefined);
+}
+export declare class Groupper extends TabsterPart<Types.GroupperProps> implements Types.Groupper {
+    private _shouldTabInside;
+    private _first;
+    private _onDispose;
+    dummyManager: GroupperDummyManager | undefined;
+    constructor(tabster: Types.TabsterCore, element: HTMLElement, onDispose: (groupper: Groupper) => void, props: Types.GroupperProps, sys: Types.SysProps | undefined);
+    dispose(): void;
+    findNextTabbable(currentElement?: HTMLElement, referenceElement?: HTMLElement, isBackward?: boolean, ignoreAccessibility?: boolean): Types.NextTabbable | null;
+    makeTabbable(isTabbable: boolean): void;
+    isActive(noIfFirstIsFocused?: boolean): boolean | undefined;
+    getFirst(orContainer: boolean): HTMLElement | undefined;
+    setFirst(element: HTMLElement | undefined): void;
+    acceptElement(element: HTMLElement, state: Types.FocusableAcceptElementState): number | undefined;
+}
+export declare class GroupperAPI implements Types.GroupperAPI {
+    private _tabster;
+    private _updateTimer;
+    private _win;
+    private _current;
+    private _grouppers;
+    constructor(tabster: Types.TabsterCore, getWindow: Types.GetWindow);
+    private _init;
+    dispose(): void;
+    createGroupper(element: HTMLElement, props: Types.GroupperProps, sys: Types.SysProps | undefined): Groupper;
+    forgetCurrentGrouppers(): void;
+    private _onGroupperDispose;
+    private _onFocus;
+    private _onMouseDown;
+    private _updateCurrent;
+    private _onKeyDown;
+    private _onMoveFocus;
+    private _enterGroupper;
+    private _escapeGroupper;
+    moveFocus(element: HTMLElement, action: Types.GroupperMoveFocusAction): HTMLElement | null;
+    handleKeyPress(element: HTMLElement, event: KeyboardEvent, fromModalizer?: boolean): void;
+}
+export {};

node_modules/tabster/dist/dts/Instance.d.ts

@@ -0,0 +1,7 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import * as Types from "./Types";
+export declare function getTabsterOnElement(tabster: Types.TabsterCore, element: HTMLElement): Types.TabsterOnElement | undefined;
+export declare function updateTabsterByAttribute(tabster: Types.TabsterCore, element: HTMLElement, dispose?: boolean): void;

node_modules/tabster/dist/dts/Keys.d.ts

@@ -0,0 +1,19 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export declare const Keys: {
+    Tab: "Tab";
+    Enter: "Enter";
+    Escape: "Escape";
+    Space: " ";
+    PageUp: "PageUp";
+    PageDown: "PageDown";
+    End: "End";
+    Home: "Home";
+    ArrowLeft: "ArrowLeft";
+    ArrowUp: "ArrowUp";
+    ArrowRight: "ArrowRight";
+    ArrowDown: "ArrowDown";
+};
+export type Key = (typeof Keys)[keyof typeof Keys];

node_modules/tabster/dist/dts/Modalizer.d.ts

@@ -0,0 +1,71 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import * as Types from "./Types";
+import { DummyInputManager, TabsterPart, WeakHTMLElement } from "./Utils";
+/**
+ * Manages the dummy inputs for the Modalizer.
+ */
+declare class ModalizerDummyManager extends DummyInputManager {
+    constructor(element: WeakHTMLElement, tabster: Types.TabsterCore, sys: Types.SysProps | undefined);
+}
+export declare class Modalizer extends TabsterPart<Types.ModalizerProps> implements Types.Modalizer {
+    userId: string;
+    private _isActive;
+    private _wasFocused;
+    private _onDispose;
+    private _activeElements;
+    dummyManager: ModalizerDummyManager | undefined;
+    constructor(tabster: Types.TabsterCore, element: HTMLElement, onDispose: (modalizer: Modalizer) => void, props: Types.ModalizerProps, sys: Types.SysProps | undefined, activeElements: WeakHTMLElement<HTMLElement>[]);
+    makeActive(isActive: boolean): void;
+    focused(noIncrement?: boolean): number;
+    setProps(props: Types.ModalizerProps): void;
+    dispose(): void;
+    isActive(): boolean;
+    contains(element: HTMLElement): boolean;
+    findNextTabbable(currentElement?: HTMLElement, referenceElement?: HTMLElement, isBackward?: boolean, ignoreAccessibility?: boolean): Types.NextTabbable | null;
+    private _dispatchEvent;
+    private _remove;
+}
+export declare class ModalizerAPI implements Types.ModalizerAPI {
+    private _tabster;
+    private _win;
+    private _restoreModalizerFocusTimer;
+    private _modalizers;
+    private _parts;
+    private _augMap;
+    private _aug;
+    private _hiddenUpdateTimer;
+    private _alwaysAccessibleSelector;
+    private _accessibleCheck;
+    private _activationHistory;
+    activeId: string | undefined;
+    currentIsOthersAccessible: boolean | undefined;
+    activeElements: WeakHTMLElement<HTMLElement>[];
+    constructor(tabster: Types.TabsterCore, alwaysAccessibleSelector?: string, accessibleCheck?: Types.ModalizerElementAccessibleCheck);
+    dispose(): void;
+    createModalizer(element: HTMLElement, props: Types.ModalizerProps, sys: Types.SysProps | undefined): Types.Modalizer;
+    private _onModalizerDispose;
+    private _onKeyDown;
+    isAugmented(element: HTMLElement): boolean;
+    hiddenUpdate(): void;
+    setActive(modalizer: Types.Modalizer | undefined): void;
+    focus(elementFromModalizer: HTMLElement, noFocusFirst?: boolean, noFocusDefault?: boolean): boolean;
+    activate(modalizerElementOrContainer: HTMLElement | undefined): boolean;
+    acceptElement(element: HTMLElement, state: Types.FocusableAcceptElementState): number | undefined;
+    private _hiddenUpdate;
+    /**
+     * Subscribes to the focus state and handles modalizer related focus events
+     * @param focusedElement - Element that is focused
+     * @param detail - Additional data about the focus event
+     */
+    private _onFocus;
+    /**
+     * Called when an element is focused outside of an active modalizer.
+     * Attempts to pull focus back into the active modalizer
+     * @param outsideElement - An element being focused outside of the modalizer
+     */
+    private _restoreModalizerFocus;
+}
+export {};

node_modules/tabster/dist/dts/Mover.d.ts

@@ -0,0 +1,57 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import * as Types from "./Types";
+import { DummyInputManager, TabsterPart, WeakHTMLElement } from "./Utils";
+declare class MoverDummyManager extends DummyInputManager {
+    private _tabster;
+    private _getMemorized;
+    constructor(element: WeakHTMLElement, tabster: Types.TabsterCore, getMemorized: () => WeakHTMLElement | undefined, sys: Types.SysProps | undefined);
+    private _onFocusDummyInput;
+}
+export declare class Mover extends TabsterPart<Types.MoverProps> implements Types.Mover {
+    private _unobserve;
+    private _intersectionObserver;
+    private _setCurrentTimer;
+    private _current;
+    private _prevCurrent;
+    private _visible;
+    private _fullyVisible;
+    private _win;
+    private _onDispose;
+    private _allElements;
+    private _updateQueue;
+    private _updateTimer;
+    visibilityTolerance: number;
+    dummyManager: MoverDummyManager | undefined;
+    constructor(tabster: Types.TabsterCore, element: HTMLElement, onDispose: (mover: Mover) => void, props: Types.MoverProps, sys: Types.SysProps | undefined);
+    dispose(): void;
+    setCurrent(element: HTMLElement | undefined): void;
+    getCurrent(): HTMLElement | null;
+    findNextTabbable(currentElement?: HTMLElement, referenceElement?: HTMLElement, isBackward?: boolean, ignoreAccessibility?: boolean): Types.NextTabbable | null;
+    acceptElement(element: HTMLElement, state: Types.FocusableAcceptElementState): number | undefined;
+    private _onIntersection;
+    private _observeState;
+    getState(element: HTMLElement): Types.MoverElementState | undefined;
+}
+export declare class MoverAPI implements Types.MoverAPI {
+    private _tabster;
+    private _win;
+    private _movers;
+    private _ignoredInputTimer;
+    private _ignoredInputResolve;
+    constructor(tabster: Types.TabsterCore, getWindow: Types.GetWindow);
+    private _init;
+    dispose(): void;
+    createMover(element: HTMLElement, props: Types.MoverProps, sys: Types.SysProps | undefined): Types.Mover;
+    private _onMoverDispose;
+    private _onFocus;
+    moveFocus(fromElement: HTMLElement, key: Types.MoverKey): HTMLElement | null;
+    private _moveFocus;
+    private _onKeyDown;
+    private _onMoveFocus;
+    private _onMemorizedElement;
+    private _isIgnoredInput;
+}
+export {};

node_modules/tabster/dist/dts/MutationEvent.d.ts

@@ -0,0 +1,7 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import * as Types from "./Types";
+import { HTMLElementWithUID } from "./Utils";
+export declare function observeMutations(doc: Document, tabster: Types.TabsterCore, updateTabsterByAttribute: (tabster: Types.TabsterCore, element: HTMLElementWithUID, dispose?: boolean) => void, syncState: boolean): () => void;

node_modules/tabster/dist/dts/Outline.d.ts

@@ -0,0 +1,34 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import * as Types from "./Types";
+export declare class OutlineAPI implements Types.OutlineAPI {
+    private _tabster;
+    private _win;
+    private _updateTimer;
+    private _outlinedElement;
+    private _curPos;
+    private _isVisible;
+    private _curOutlineElements;
+    private _allOutlineElements;
+    private _fullScreenElement;
+    private _fullScreenEventName;
+    private _fullScreenElementName;
+    constructor(tabster: Types.TabsterCore);
+    private _init;
+    setup(props?: Partial<Types.OutlineProps>): void;
+    dispose(): void;
+    private _onFullScreenChanged;
+    private _onKeyboardNavigationStateChanged;
+    private _shouldShowCustomOutline;
+    private _onFocus;
+    private _updateElement;
+    private _onScroll;
+    private _updateOutline;
+    private _setVisibility;
+    private _setOutlinePosition;
+    private _getDOM;
+    private _removeDOM;
+    private static _isParentChild;
+}

node_modules/tabster/dist/dts/Restorer.d.ts

@@ -0,0 +1,27 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import type { Restorer as RestorerInterface, RestorerAPI as RestorerAPIType, RestorerProps, TabsterCore } from "./Types";
+import { TabsterPart } from "./Utils";
+declare class Restorer extends TabsterPart<RestorerProps> implements RestorerInterface {
+    private _hasFocus;
+    constructor(tabster: TabsterCore, element: HTMLElement, props: RestorerProps);
+    dispose(): void;
+    private _onFocusOut;
+    private _onFocusIn;
+}
+export declare class RestorerAPI implements RestorerAPIType {
+    private _tabster;
+    private _history;
+    private _keyboardNavState;
+    private _focusedElementState;
+    private _getWindow;
+    constructor(tabster: TabsterCore);
+    dispose(): void;
+    private _onRestoreFocus;
+    private _onFocusIn;
+    private _restoreFocus;
+    createRestorer(element: HTMLElement, props: RestorerProps): Restorer;
+}
+export {};

node_modules/tabster/dist/dts/Root.d.ts

@@ -0,0 +1,56 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import * as Types from "./Types";
+import { TabsterPart } from "./Utils";
+export interface WindowWithTabsterInstance extends Window {
+    __tabsterInstance?: Types.TabsterCore;
+}
+export declare class Root extends TabsterPart<Types.RootProps, undefined> implements Types.Root {
+    readonly uid: string;
+    private _dummyManager?;
+    private _sys?;
+    private _isFocused;
+    private _setFocusedTimer;
+    private _onDispose;
+    constructor(tabster: Types.TabsterCore, element: HTMLElement, onDispose: (root: Root) => void, props: Types.RootProps, sys: Types.SysProps | undefined);
+    addDummyInputs(): void;
+    dispose(): void;
+    moveOutWithDefaultAction(isBackward: boolean, relatedEvent: KeyboardEvent): void;
+    private _setFocused;
+    private _onFocusIn;
+    private _onFocusOut;
+    private _add;
+    private _remove;
+}
+export declare class RootAPI implements Types.RootAPI {
+    private _tabster;
+    private _win;
+    private _autoRoot;
+    private _autoRootWaiting;
+    private _roots;
+    private _forceDummy;
+    rootById: {
+        [id: string]: Types.Root;
+    };
+    constructor(tabster: Types.TabsterCore, autoRoot?: Types.RootProps);
+    private _autoRootCreate;
+    private _autoRootUnwait;
+    dispose(): void;
+    createRoot(element: HTMLElement, props: Types.RootProps, sys: Types.SysProps | undefined): Types.Root;
+    addDummyInputs(): void;
+    static getRootByUId(getWindow: Types.GetWindow, id: string): Types.Root | undefined;
+    /**
+     * Fetches the tabster context for an element walking up its ancestors
+     *
+     * @param tabster Tabster instance
+     * @param element The element the tabster context should represent
+     * @param options Additional options
+     * @returns undefined if the element is not a child of a tabster root, otherwise all applicable tabster behaviours and configurations
+     */
+    static getTabsterContext(tabster: Types.TabsterCore, element: Node, options?: Types.GetTabsterContextOptions): Types.TabsterContext | undefined;
+    static getRoot(tabster: Types.TabsterCore, element: HTMLElement): Types.Root | undefined;
+    onRoot(root: Types.Root, removed?: boolean): void;
+    private _onRootDispose;
+}

node_modules/tabster/dist/dts/Shadowdomize/DOMFunctions.d.ts

@@ -0,0 +1,20 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export declare function getActiveElement(doc: Document): Element | null;
+export declare function nodeContains(node: Node | null | undefined, otherNode: Node | null | undefined): boolean;
+export declare function getParentNode(node: Node | null | undefined): ParentNode | null;
+export declare function getParentElement(element: HTMLElement | null | undefined): HTMLElement | null;
+export declare function getFirstChild(node: Node | null | undefined): ChildNode | null;
+export declare function getLastChild(node: Node | null | undefined): ChildNode | null;
+export declare function getNextSibling(node: Node | null | undefined): ChildNode | null;
+export declare function getPreviousSibling(node: Node | null | undefined): ChildNode | null;
+export declare function getFirstElementChild(element: Element | null | undefined): Element | null;
+export declare function getLastElementChild(element: Element | null | undefined): Element | null;
+export declare function getNextElementSibling(element: Element | null | undefined): Element | null;
+export declare function getPreviousElementSibling(element: Element | null | undefined): Element | null;
+export declare function appendChild(parent: Node, child: Node): Node;
+export declare function insertBefore(parent: Node, child: Node, referenceChild: Node | null): Node;
+export declare function getSelection(ref: Node): Selection | null;
+export declare function getElementsByName(referenceElement: HTMLElement, name: string): NodeListOf<HTMLElement>;

node_modules/tabster/dist/dts/Shadowdomize/ShadowMutationObserver.d.ts

@@ -0,0 +1,22 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export declare class ShadowMutationObserver implements MutationObserver {
+    private static _shadowObservers;
+    private _root?;
+    private _options?;
+    private _callback;
+    private _observer;
+    private _subObservers;
+    private _isObserving;
+    private static _overrideAttachShadow;
+    constructor(callback: MutationCallback);
+    private _callbackWrapper;
+    private _addSubObserver;
+    disconnect(): void;
+    observe(target: Node, options?: MutationObserverInit): void;
+    private _walkShadows;
+    takeRecords(): MutationRecord[];
+}
+export declare function createShadowMutationObserver(callback: MutationCallback): MutationObserver;

node_modules/tabster/dist/dts/Shadowdomize/ShadowTreeWalker.d.ts

@@ -0,0 +1,25 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export declare class ShadowTreeWalker implements TreeWalker {
+    readonly filter: NodeFilter | null;
+    readonly root: Node;
+    readonly whatToShow: number;
+    private _doc;
+    private _walkerStack;
+    private _currentNode;
+    private _currentSetFor;
+    constructor(doc: Document, root: Node, whatToShow?: number, filter?: NodeFilter | null);
+    private _acceptNode;
+    get currentNode(): Node;
+    set currentNode(node: Node);
+    firstChild(): Node | null;
+    lastChild(): Node | null;
+    nextNode(): Node | null;
+    previousNode(): Node | null;
+    nextSibling(): Node | null;
+    previousSibling(): Node | null;
+    parentNode(): Node | null;
+}
+export declare function createShadowTreeWalker(doc: Document, root: Node, whatToShow?: number, filter?: NodeFilter | null): ShadowTreeWalker;

node_modules/tabster/dist/dts/Shadowdomize/index.d.ts

@@ -0,0 +1,8 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export { createShadowTreeWalker as createTreeWalker } from "./ShadowTreeWalker";
+export { createShadowMutationObserver as createMutationObserver } from "./ShadowMutationObserver";
+export { appendChild, getActiveElement, getFirstChild, getFirstElementChild, getLastChild, getLastElementChild, getNextElementSibling, getNextSibling, getParentElement, getParentNode, getPreviousElementSibling, getPreviousSibling, getSelection, getElementsByName, insertBefore, nodeContains, } from "./DOMFunctions";
+export { getElementById, querySelector, querySelectorAll, } from "./querySelector";

node_modules/tabster/dist/dts/Shadowdomize/querySelector.d.ts

@@ -0,0 +1,7 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export declare function querySelectorAll(node: ParentNode, selector: string): Element[];
+export declare function querySelector(node: ParentNode, selector: string): Element | null;
+export declare function getElementById(doc: Document, id: string): HTMLElement | null;

node_modules/tabster/dist/dts/State/FocusedElement.d.ts

@@ -0,0 +1,40 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import * as Types from "../Types";
+import { Subscribable } from "./Subscribable";
+export declare class FocusedElementState extends Subscribable<HTMLElement | undefined, Types.FocusedElementDetail> implements Types.FocusedElementState {
+    private static _lastResetElement;
+    private static _isTabbingTimer;
+    static isTabbing: boolean;
+    private _tabster;
+    private _win;
+    private _nextVal;
+    private _lastVal;
+    private _asyncFocus?;
+    constructor(tabster: Types.TabsterCore, getWindow: Types.GetWindow);
+    private _init;
+    dispose(): void;
+    static forgetMemorized(instance: Types.FocusedElementState, parent: HTMLElement): void;
+    getFocusedElement(): HTMLElement | undefined;
+    getLastFocusedElement(): HTMLElement | undefined;
+    focus(element: HTMLElement, noFocusedProgrammaticallyFlag?: boolean, noAccessibleCheck?: boolean, preventScroll?: boolean): boolean;
+    focusDefault(container: HTMLElement): boolean;
+    getFirstOrLastTabbable(isFirst: boolean, props: Pick<Types.FindFocusableProps, "container" | "ignoreAccessibility">): HTMLElement | undefined;
+    private _focusFirstOrLast;
+    focusFirst(props: Types.FindFirstProps): boolean;
+    focusLast(props: Types.FindFirstProps): boolean;
+    resetFocus(container: HTMLElement): boolean;
+    requestAsyncFocus(source: Types.AsyncFocusSource, callback: () => void, delay: number): void;
+    cancelAsyncFocus(source: Types.AsyncFocusSource): void;
+    private _setOrRemoveAttribute;
+    private _setFocusedElement;
+    protected setVal(val: HTMLElement | undefined, detail: Types.FocusedElementDetail): void;
+    private _onFocusIn;
+    private _onFocusOut;
+    static findNextTabbable(tabster: Types.TabsterCore, ctx: Types.TabsterContext, container?: HTMLElement, currentElement?: HTMLElement, referenceElement?: HTMLElement, isBackward?: boolean, ignoreAccessibility?: boolean): Types.NextTabbable | null;
+    private _validateFocusedElement;
+    private _onKeyDown;
+    _onChanged: (element: HTMLElement | undefined, detail: Types.FocusedElementDetail) => void;
+}

node_modules/tabster/dist/dts/State/KeyboardNavigation.d.ts

@@ -0,0 +1,14 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import * as Types from "../Types";
+import { Subscribable } from "./Subscribable";
+export declare class KeyboardNavigationState extends Subscribable<boolean> implements Types.KeyboardNavigationState {
+    private _keyborg?;
+    constructor(getWindow: Types.GetWindow);
+    dispose(): void;
+    private _onChange;
+    setNavigatingWithKeyboard(isNavigatingWithKeyboard: boolean): void;
+    isNavigatingWithKeyboard(): boolean;
+}

node_modules/tabster/dist/dts/State/ObservedElement.d.ts

@@ -0,0 +1,54 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import * as Types from "../Types";
+import { Subscribable } from "./Subscribable";
+export declare class ObservedElementAPI extends Subscribable<HTMLElement, Types.ObservedElementDetails> implements Types.ObservedElementAPI {
+    private _win;
+    private _tabster;
+    private _waiting;
+    private _lastRequestFocusId;
+    private _observedById;
+    private _observedByName;
+    private _currentRequest;
+    private _currentRequestTimestamp;
+    onObservedElementChange?: (change: Types.ObservedElementChange) => void;
+    constructor(tabster: Types.TabsterCore);
+    dispose(): void;
+    private _onFocus;
+    private _rejectWaiting;
+    private _populateTimeoutDiagnostics;
+    private _isObservedNamesUpdated;
+    private _notifyObservedElementChange;
+    /**
+     * Returns all registered observed names with their respective elements and full names arrays
+     *
+     * @returns Map<string, Array<{ element: HTMLElement; names: string[] }>> A map where keys are observed names
+     * and values are arrays of objects containing the element and its complete names array (in the order they were defined)
+     */
+    getAllObservedElements(): Map<string, Array<{
+        element: HTMLElement;
+        names: string[];
+    }>>;
+    /**
+     * Returns existing element by observed name
+     *
+     * @param observedName An observed name
+     * @param accessibility Optionally, return only if the element is accessible or focusable
+     * @returns HTMLElement | null
+     */
+    getElement(observedName: string, accessibility?: Types.ObservedElementAccessibility): HTMLElement | null;
+    /**
+     * Waits for the element to appear in the DOM and returns it.
+     *
+     * @param observedName An observed name
+     * @param timeout Wait no longer than this timeout
+     * @param accessibility Optionally, wait for the element to also become accessible or focusable before returning it
+     * @returns Promise<HTMLElement | null>
+     */
+    waitElement(observedName: string, timeout: number, accessibility?: Types.ObservedElementAccessibility): Types.ObservedElementAsyncRequest<HTMLElement | null>;
+    requestFocus(observedName: string, timeout: number, options?: Pick<FocusOptions, "preventScroll">): Types.ObservedElementAsyncRequest<boolean>;
+    onObservedElementUpdate: (element: HTMLElement) => void;
+    private _waitConditional;
+}

node_modules/tabster/dist/dts/State/Subscribable.d.ts

@@ -0,0 +1,17 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import * as Types from "../Types";
+export declare abstract class Subscribable<A, B = undefined> implements Types.Subscribable<A, B> {
+    protected _val: A | undefined;
+    private _callbacks;
+    dispose(): void;
+    subscribe(callback: Types.SubscribableCallback<A, B>): void;
+    subscribeFirst(callback: Types.SubscribableCallback<A, B>): void;
+    unsubscribe(callback: Types.SubscribableCallback<A, B>): void;
+    protected setVal(val: A, detail: B): void;
+    protected getVal(): A | undefined;
+    protected trigger(val: A, detail: B): void;
+    private _callCallbacks;
+}

node_modules/tabster/dist/dts/Tabster.d.ts

@@ -0,0 +1,70 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import * as Types from "./Types";
+import { getDummyInputContainer } from "./Utils";
+export { getDummyInputContainer };
+export declare function forceCleanup(tabster: Types.Tabster): void;
+/**
+ * Creates an instance of Tabster, returns the current window instance if it already exists.
+ */
+export declare function createTabster(win: Window, props?: Types.TabsterCoreProps): Types.Tabster;
+/**
+ * Returns an instance of Tabster if it was created before or null.
+ */
+export declare function getTabster(win: Window): Types.Tabster | null;
+export declare function getShadowDOMAPI(): Types.DOMAPI;
+/**
+ * Creates a new groupper instance or returns an existing one
+ * @param tabster Tabster instance
+ */
+export declare function getGroupper(tabster: Types.Tabster): Types.GroupperAPI;
+/**
+ * Creates a new mover instance or returns an existing one
+ * @param tabster Tabster instance
+ */
+export declare function getMover(tabster: Types.Tabster): Types.MoverAPI;
+export declare function getOutline(tabster: Types.Tabster): Types.OutlineAPI;
+/**
+ * Creates a new new deloser instance or returns an existing one
+ * @param tabster Tabster instance
+ * @param props Deloser props
+ */
+export declare function getDeloser(tabster: Types.Tabster, props?: {
+    autoDeloser: Types.DeloserProps;
+}): Types.DeloserAPI;
+/**
+ * Creates a new modalizer instance or returns an existing one
+ * @param tabster Tabster instance
+ * @param alwaysAccessibleSelector When Modalizer is active, we put
+ * aria-hidden to everything else to hide it from screen readers. This CSS
+ * selector allows to exclude some elements from this behaviour. For example,
+ * this could be used to exclude aria-live region with the application-wide
+ * status announcements.
+ * @param accessibleCheck An optional callback that will be called when
+ * active Modalizer wants to hide an element that doesn't belong to it from
+ * the screen readers by setting aria-hidden. Similar to alwaysAccessibleSelector
+ * but allows to address the elements programmatically rather than with a selector.
+ * If the callback returns true, the element will not receive aria-hidden.
+ */
+export declare function getModalizer(tabster: Types.Tabster, alwaysAccessibleSelector?: string, accessibleCheck?: Types.ModalizerElementAccessibleCheck): Types.ModalizerAPI;
+export declare function getObservedElement(tabster: Types.Tabster): Types.ObservedElementAPI;
+export declare function getCrossOrigin(tabster: Types.Tabster): Types.CrossOriginAPI;
+export declare function getInternal(tabster: Types.Tabster): Types.InternalAPI;
+export declare function getRestorer(tabster: Types.Tabster): Types.RestorerAPI;
+export declare function disposeTabster(tabster: Types.Tabster, allInstances?: boolean): void;
+/**
+ * Returns an instance of Tabster if it already exists on the window .
+ * @param win window instance that could contain an Tabster instance.
+ */
+export declare function getCurrentTabster(win: Window): Types.TabsterCore | undefined;
+/**
+ * Allows to make Tabster non operational. Intended for performance debugging (and other
+ * kinds of debugging), you can switch Tabster off without changing the application code
+ * that consumes it.
+ * @param tabster a reference created by createTabster().
+ * @param noop true if you want to make Tabster noop, false if you want to turn it back.
+ */
+export declare function makeNoOp(tabster: Types.Tabster, noop: boolean): void;
+export declare function isNoOp(tabster: Types.TabsterCore): boolean;

node_modules/tabster/dist/dts/Types.d.ts

@@ -0,0 +1,846 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import type { TABSTER_ATTRIBUTE_NAME } from "./Consts";
+export interface HTMLElementWithTabsterFlags extends HTMLElement {
+    __tabsterElementFlags?: {
+        /**
+         * @deprecated This option is added to support interop between Fluent UI V9 and Fluent UI V8.
+         * Once Fluent UI V8 is not supported anymore, this option should be removed.
+         */
+        noDirectAriaHidden?: boolean;
+    };
+}
+export interface TabsterDOMAttribute {
+    [TABSTER_ATTRIBUTE_NAME]: string | undefined;
+}
+export interface TabsterCoreProps {
+    autoRoot?: RootProps;
+    /**
+     * Allows all tab key presses under the tabster root to be controlled by tabster
+     * @default true
+     */
+    controlTab?: boolean;
+    /**
+     * When controlTab is false, Root doesn't have dummy inputs by default.
+     * This option allows to enable dummy inputs on Root.
+     */
+    rootDummyInputs?: boolean;
+    /**
+     * A callback that will be called for the uncontrolled areas when Tabster wants
+     * to know is the uncontrolled element wants complete control (for example it
+     * is trapping focus) and Tabster should not interfere with handling Tab.
+     * If the callback returns undefined, then the default behaviour is to return
+     * the uncontrolled.completely value from the element. If the callback returns
+     * non-undefined value, the callback's value will dominate the element's
+     * uncontrolled.completely value.
+     */
+    checkUncontrolledCompletely?: (element: HTMLElement, completely: boolean) => boolean | undefined;
+    /**
+     * @deprecated use checkUncontrolledCompletely.
+     */
+    checkUncontrolledTrappingFocus?: (element: HTMLElement) => boolean;
+    /**
+     * Custom getter for parent elements. Defaults to the default .parentElement call
+     * Currently only used to detect tabster contexts
+     */
+    getParent?(el: Node): Node | null;
+    /**
+     * Ability to redefine all DOM API calls used by Tabster. For example, for
+     * ShadowDOM support.
+     */
+    DOMAPI?: Partial<DOMAPI>;
+}
+export interface DOMAPI {
+    createMutationObserver: (callback: MutationCallback) => MutationObserver;
+    createTreeWalker(doc: Document, root: Node, whatToShow?: number, filter?: NodeFilter | null): TreeWalker;
+    getParentNode(node: Node | null | undefined): ParentNode | null;
+    getParentElement(element: HTMLElement | null | undefined): HTMLElement | null;
+    nodeContains(parent: Node | null | undefined, child: Node | null | undefined): boolean;
+    getActiveElement(doc: Document): Element | null;
+    querySelector(element: ParentNode, selector: string): Element | null;
+    querySelectorAll(element: ParentNode, selector: string): Element[];
+    getElementById(doc: Document, id: string): HTMLElement | null;
+    getFirstChild(node: Node | null | undefined): ChildNode | null;
+    getLastChild(node: Node | null | undefined): ChildNode | null;
+    getNextSibling(node: Node | null | undefined): ChildNode | null;
+    getPreviousSibling(node: Node | null | undefined): ChildNode | null;
+    getFirstElementChild(element: Element | null | undefined): Element | null;
+    getLastElementChild(element: Element | null | undefined): Element | null;
+    getNextElementSibling(element: Element | null | undefined): Element | null;
+    getPreviousElementSibling(element: Element | null | undefined): Element | null;
+    appendChild(parent: Node, child: Node): Node;
+    insertBefore(parent: Node, child: Node, referenceChild: Node | null): Node;
+    getSelection(ref: Node): Selection | null;
+    getElementsByName(referenceElement: HTMLElement, name: string): NodeListOf<HTMLElement>;
+}
+export type GetTabster = () => TabsterCore;
+export type GetWindow = () => Window;
+export type SubscribableCallback<A, B = undefined> = (val: A, detail: B) => void;
+export interface Disposable {
+}
+export interface Subscribable<A, B = undefined> {
+    subscribe(callback: SubscribableCallback<A, B>): void;
+    unsubscribe(callback: SubscribableCallback<A, B>): void;
+}
+export interface KeyboardNavigationState extends Subscribable<boolean>, Disposable {
+    isNavigatingWithKeyboard(): boolean;
+    setNavigatingWithKeyboard(isNavigatingWithKeyboard: boolean): void;
+}
+export interface FocusedElementDetail {
+    relatedTarget?: HTMLElement;
+    isFocusedProgrammatically?: boolean;
+    modalizerId?: string;
+}
+import { AsyncFocusSources as _AsyncFocusSources } from "./Consts";
+export type AsyncFocusSources = typeof _AsyncFocusSources;
+export type AsyncFocusSource = AsyncFocusSources[keyof AsyncFocusSources];
+export interface FocusedElementState extends Subscribable<HTMLElement | undefined, FocusedElementDetail>, Disposable {
+    getFocusedElement(): HTMLElement | undefined;
+    getLastFocusedElement(): HTMLElement | undefined;
+    focus(element: HTMLElement, noFocusedProgrammaticallyFlag?: boolean, noAccessibleCheck?: boolean, preventScroll?: boolean): boolean;
+    focusDefault(container: HTMLElement): boolean;
+    focusFirst(props: FindFirstProps): boolean;
+    focusLast(props: FindFirstProps): boolean;
+    resetFocus(container: HTMLElement): boolean;
+}
+export interface WeakHTMLElement<D = undefined> {
+    get(): HTMLElement | undefined;
+    getData(): D | undefined;
+}
+export interface TabsterPart<P> {
+    readonly id: string;
+    getElement(): HTMLElement | undefined;
+    getProps(): P;
+    setProps(props: P): void;
+}
+export interface TabsterPartWithFindNextTabbable {
+    findNextTabbable(current?: HTMLElement, reference?: HTMLElement, isBackward?: boolean, ignoreAccessibility?: boolean): NextTabbable | null;
+}
+export interface TabsterPartWithAcceptElement {
+    acceptElement(element: HTMLElement, state: FocusableAcceptElementState): number | undefined;
+}
+export interface ObservedElementProps {
+    names: string[];
+    details?: any;
+}
+export interface ObservedElementDetails extends ObservedElementProps {
+    accessibility?: ObservedElementAccessibility;
+}
+export type ObservedElementChangeType = "added" | "removed" | "updated";
+/**
+ * Changes to observed elements in the DOM.
+ */
+export interface ObservedElementChange {
+    /**
+     * The HTML element that was added, removed, or updated.
+     */
+    element: HTMLElement;
+    /**
+     * The type of change that occurred:
+     * - "added": A new element with observed names was added to the DOM
+     * - "removed": An observed element was completely removed from the DOM
+     * - "updated": An existing observed element had its names modified (added or removed)
+     */
+    type: ObservedElementChangeType;
+    /**
+     * The current array of observed names associated with this element.
+     * - For "added" events: Contains all names for the new element
+     * - For "removed" events: Empty array (since element is being removed)
+     * - For "updated" events: Contains the complete current list of names after the update
+     */
+    names: string[];
+    /**
+     * Optional array of names that were added in this change.
+     * - For "added" events: Contains all names (same as `names`)
+     * - For "removed" events: undefined
+     * - For "updated" events: Contains only the newly added names, or undefined if no names were added
+     */
+    addedNames?: string[];
+    /**
+     * Optional array of names that were removed in this change.
+     * - For "added" events: undefined
+     * - For "removed" events: Contains all previous names that the element had
+     * - For "updated" events: Contains only the removed names, or undefined if no names were removed
+     */
+    removedNames?: string[];
+}
+import { ObservedElementAccessibilities as _ObservedElementAccessibilities } from "./Consts";
+export type ObservedElementAccessibilities = typeof _ObservedElementAccessibilities;
+export type ObservedElementAccessibility = ObservedElementAccessibilities[keyof ObservedElementAccessibilities];
+import { ObservedElementRequestStatuses as _ObservedElementRequestStatuses } from "./Consts";
+export type ObservedElementRequestStatuses = typeof _ObservedElementRequestStatuses;
+export type ObservedElementRequestStatus = ObservedElementRequestStatuses[keyof ObservedElementRequestStatuses];
+import { ObservedElementFailureReasons as _ObservedElementFailureReasons } from "./Consts";
+export type ObservedElementFailureReasons = typeof _ObservedElementFailureReasons;
+export type ObservedElementFailureReason = ObservedElementFailureReasons[keyof ObservedElementFailureReasons];
+export interface ObservedElementAsyncRequestDiagnostics {
+    /**
+     * Reason for failure when status is Canceled or TimedOut.
+     */
+    reason?: ObservedElementFailureReason;
+    /**
+     * Time spent waiting for element to appear in DOM (ms).
+     */
+    waitForElementDuration?: number;
+    /**
+     * State of the target element at the time of failure.
+     * Only present for timeout or failure cases.
+     */
+    targetState?: {
+        inDOM: boolean;
+        isAccessible?: boolean;
+        isFocusable?: boolean;
+    };
+    /**
+     * Callback to access the element that received focus, causing cancellation.
+     * Only present when canceled due to focus change.
+     * Returns null if the element is no longer available.
+     */
+    getCancelTriggeringElement?: () => HTMLElement | null;
+}
+export interface ObservedElementAsyncRequest<T> {
+    result: Promise<T>;
+    cancel(): void;
+    status?: ObservedElementRequestStatus;
+    /**
+     * Detailed diagnostic information about the request.
+     */
+    diagnostics: ObservedElementAsyncRequestDiagnostics;
+}
+interface ObservedElementAPIInternal {
+}
+export interface ObservedElementAPI extends Subscribable<HTMLElement, ObservedElementDetails>, Disposable, ObservedElementAPIInternal {
+    getElement(observedName: string, accessibility?: ObservedElementAccessibility): HTMLElement | null;
+    waitElement(observedName: string, timeout: number, accessibility?: ObservedElementAccessibility): ObservedElementAsyncRequest<HTMLElement | null>;
+    requestFocus(observedName: string, timeout: number, options?: Pick<FocusOptions, "preventScroll">): ObservedElementAsyncRequest<boolean>;
+    /**
+     * Returns all currently registered observed elements grouped by their observed names.
+     *
+     * @returns A Map where each key is an observed name, and each value is an array of elements
+     * associated with that name along with their complete names arrays.
+     *
+     * @example
+     * ```typescript
+     * const allObserved = observedElement.getAllObservedElements();
+     * // Map might contain:
+     * // "button-1" -> [{ element: <button>, names: ["button-1", "primary"] }]
+     * // "primary" -> [{ element: <button>, names: ["button-1", "primary"] }]
+     * ```
+     */
+    getAllObservedElements(): Map<string, Array<{
+        element: HTMLElement;
+        names: string[];
+    }>>;
+    /**
+     * Optional callback that is invoked whenever an observed element is added, removed, or updated in the DOM.
+     */
+    onObservedElementChange?: (change: ObservedElementChange) => void;
+}
+export interface CrossOriginElement {
+    readonly uid: string;
+    readonly ownerId: string;
+    readonly id?: string;
+    readonly rootId?: string;
+    readonly observedName?: string;
+    readonly observedDetails?: string;
+    focus(noFocusedProgrammaticallyFlag?: boolean, noAccessibleCheck?: boolean): Promise<boolean>;
+}
+export interface CrossOriginSentTo {
+    [id: string]: true;
+}
+export interface CrossOriginTransactionTypes {
+    Bootstrap: 1;
+    FocusElement: 2;
+    State: 3;
+    GetElement: 4;
+    RestoreFocusInDeloser: 5;
+    Ping: 6;
+}
+export type CrossOriginTransactionType = CrossOriginTransactionTypes[keyof CrossOriginTransactionTypes];
+export interface CrossOriginTransactionData<I, O> {
+    transaction: string;
+    type: CrossOriginTransactionType;
+    isResponse: boolean;
+    timestamp: number;
+    owner: string;
+    sentto: CrossOriginSentTo;
+    timeout?: number;
+    target?: string;
+    beginData?: I;
+    endData?: O;
+}
+export type CrossOriginTransactionSend = (data: CrossOriginTransactionData<any, any>) => void;
+export interface CrossOriginMessage {
+    data: CrossOriginTransactionData<any, any>;
+    send: CrossOriginTransactionSend;
+}
+export interface CrossOriginFocusedElementState extends Subscribable<CrossOriginElement | undefined, FocusedElementDetail>, Disposable {
+    focus(element: CrossOriginElement, noFocusedProgrammaticallyFlag?: boolean, noAccessibleCheck?: boolean): Promise<boolean>;
+    focusById(elementId: string, rootId?: string, noFocusedProgrammaticallyFlag?: boolean, noAccessibleCheck?: boolean): Promise<boolean>;
+    focusByObservedName(observedName: string, timeout?: number, rootId?: string, noFocusedProgrammaticallyFlag?: boolean, noAccessibleCheck?: boolean): Promise<boolean>;
+}
+export interface CrossOriginObservedElementState extends Subscribable<CrossOriginElement, ObservedElementProps>, Disposable {
+    getElement(observedName: string, accessibility?: ObservedElementAccessibility): Promise<CrossOriginElement | null>;
+    waitElement(observedName: string, timeout: number, accessibility?: ObservedElementAccessibility): Promise<CrossOriginElement | null>;
+    requestFocus(observedName: string, timeout: number): Promise<boolean>;
+}
+export interface CrossOriginAPI {
+    focusedElement: CrossOriginFocusedElementState;
+    observedElement: CrossOriginObservedElementState;
+    setup(sendUp?: CrossOriginTransactionSend | null): (msg: CrossOriginMessage) => void;
+    isSetUp(): boolean;
+    dispose(): void;
+}
+export interface OutlineProps {
+    areaClass: string;
+    outlineClass: string;
+    outlineColor: string;
+    outlineWidth: number;
+    zIndex: number;
+}
+export interface OutlinedElementProps {
+    isIgnored?: boolean;
+}
+export interface OutlineAPI extends Disposable {
+    setup(props?: Partial<OutlineProps>): void;
+}
+export interface DeloserElementActions {
+    focusDefault: () => boolean;
+    focusFirst: () => boolean;
+    resetFocus: () => boolean;
+    clearHistory: (preserveExisting?: boolean) => void;
+    setSnapshot: (index: number) => void;
+    isActive: () => boolean;
+}
+import { RestoreFocusOrders as _RestoreFocusOrders } from "./Consts";
+export type RestoreFocusOrders = typeof _RestoreFocusOrders;
+export type RestoreFocusOrder = RestoreFocusOrders[keyof RestoreFocusOrders];
+import { DeloserStrategies as _DeloserStrategies } from "./Consts";
+export type DeloserStrategies = typeof _DeloserStrategies;
+export type DeloserStrategy = DeloserStrategies[keyof DeloserStrategies];
+export interface DeloserProps {
+    restoreFocusOrder?: RestoreFocusOrder;
+    noSelectorCheck?: boolean;
+    strategy?: DeloserStrategy;
+}
+export interface Deloser extends TabsterPart<DeloserProps> {
+    readonly uid: string;
+    readonly strategy: DeloserStrategy;
+    dispose(): void;
+    isActive(): boolean;
+    setActive(active: boolean): void;
+    getActions(): DeloserElementActions;
+    setSnapshot(index: number): void;
+    focusFirst(): boolean;
+    unshift(element: HTMLElement): void;
+    focusDefault(): boolean;
+    resetFocus(): boolean;
+    findAvailable(): HTMLElement | null;
+    clearHistory(preserveExisting?: boolean): void;
+    customFocusLostHandler(element: HTMLElement): boolean;
+}
+export type DeloserConstructor = (element: HTMLElement, props: DeloserProps) => Deloser;
+interface DeloserInterfaceInternal {
+}
+export interface DeloserAPI extends DeloserInterfaceInternal, Disposable {
+    getActions(element: HTMLElement): DeloserElementActions | undefined;
+    pause(): void;
+    resume(restore?: boolean): void;
+}
+export interface FocusableProps {
+    isDefault?: boolean;
+    isIgnored?: boolean;
+    /**
+     * Do not determine an element's focusability based on aria-disabled.
+     */
+    ignoreAriaDisabled?: boolean;
+    /**
+     * Exclude element (and all subelements) from Mover navigation.
+     */
+    excludeFromMover?: boolean;
+    /**
+     * Prevents tabster from handling the keydown event
+     */
+    ignoreKeydown?: {
+        Tab?: boolean;
+        Escape?: boolean;
+        Enter?: boolean;
+        ArrowUp?: boolean;
+        ArrowDown?: boolean;
+        ArrowLeft?: boolean;
+        ArrowRight?: boolean;
+        PageUp?: boolean;
+        PageDown?: boolean;
+        Home?: boolean;
+        End?: boolean;
+    };
+}
+export interface RadioButtonGroup {
+    name: string;
+    buttons: Set<HTMLInputElement>;
+    checked?: HTMLInputElement;
+}
+export interface FocusableAcceptElementState {
+    container: HTMLElement;
+    modalizerUserId?: string;
+    currentCtx?: TabsterContext;
+    from: HTMLElement;
+    fromCtx?: TabsterContext;
+    isBackward?: boolean;
+    found?: boolean;
+    foundElement?: HTMLElement;
+    foundBackward?: HTMLElement;
+    rejectElementsFrom?: HTMLElement;
+    uncontrolled?: HTMLElement;
+    acceptCondition: (el: HTMLElement) => boolean;
+    hasCustomCondition?: boolean;
+    includeProgrammaticallyFocusable?: boolean;
+    ignoreAccessibility?: boolean;
+    cachedGrouppers: {
+        [id: string]: {
+            isActive: boolean | undefined;
+            first?: HTMLElement | null;
+        };
+    };
+    cachedRadioGroups: {
+        [name: string]: RadioButtonGroup;
+    };
+    isFindAll?: boolean;
+    /**
+     * A flag that indicates that some focusable elements were skipped
+     * during the search and the found element is not the one the browser
+     * would normally focus if the user pressed Tab.
+     */
+    skippedFocusable?: boolean;
+}
+export interface FindFocusableProps {
+    /**
+     * The container used for the search.
+     */
+    container: HTMLElement;
+    /**
+     * The elemet to start from.
+     */
+    currentElement?: HTMLElement;
+    /**
+     * See `referenceElement` of GetTabsterContextOptions for description.
+     */
+    referenceElement?: HTMLElement;
+    /**
+     * Includes elements that can be focused programmatically.
+     */
+    includeProgrammaticallyFocusable?: boolean;
+    /**
+     * Ignore accessibility check.
+     */
+    ignoreAccessibility?: boolean;
+    /**
+     * Take active modalizer into account when searching for elements
+     * (the elements out of active modalizer will not be returned).
+     */
+    useActiveModalizer?: boolean;
+    /**
+     * Search withing the specified modality, null for everything outside of modalizers, string within
+     * a specific id, undefined for search within the current application state.
+     */
+    modalizerId?: string | null;
+    /**
+     * If true, find previous element instead of the next one.
+     */
+    isBackward?: boolean;
+    /**
+     * @param el element visited.
+     * @returns if an element should be accepted.
+     */
+    acceptCondition?(el: HTMLElement): boolean;
+    /**
+     * A callback that will be called for every focusable element found during findAll().
+     * If false is returned from this callback, the search will stop.
+     */
+    onElement?: FindElementCallback;
+}
+export interface FindFocusableOutputProps {
+    /**
+     * An output parameter. Will be true after the findNext/findPrev() call if some focusable
+     * elements were skipped during the search and the result element not immediately next
+     * focusable after the currentElement.
+     */
+    outOfDOMOrder?: boolean;
+    /**
+     * An output parameter. Will be true if the found element is uncontrolled.
+     */
+    uncontrolled?: HTMLElement | null;
+}
+export type FindFirstProps = Pick<FindFocusableProps, "container" | "modalizerId" | "includeProgrammaticallyFocusable" | "useActiveModalizer" | "ignoreAccessibility">;
+export type FindNextProps = Pick<FindFocusableProps, "currentElement" | "referenceElement" | "container" | "modalizerId" | "includeProgrammaticallyFocusable" | "useActiveModalizer" | "ignoreAccessibility">;
+export type FindDefaultProps = Pick<FindFocusableProps, "container" | "modalizerId" | "includeProgrammaticallyFocusable" | "useActiveModalizer" | "ignoreAccessibility">;
+export type FindAllProps = Pick<FindFocusableProps, "container" | "modalizerId" | "currentElement" | "isBackward" | "includeProgrammaticallyFocusable" | "useActiveModalizer" | "acceptCondition" | "ignoreAccessibility" | "onElement">;
+/**
+ * A callback that is called for every found element during search. Returning false stops search.
+ */
+export type FindElementCallback = (element: HTMLElement) => boolean;
+export interface FocusableAPI extends Disposable {
+    getProps(element: HTMLElement): FocusableProps;
+    isFocusable(element: HTMLElement, includeProgrammaticallyFocusable?: boolean, noVisibleCheck?: boolean, noAccessibleCheck?: boolean): boolean;
+    isVisible(element: HTMLElement): boolean;
+    isAccessible(element: HTMLElement): boolean;
+    findFirst(options: FindFirstProps, out?: FindFocusableOutputProps): HTMLElement | null | undefined;
+    findLast(options: FindFirstProps, out?: FindFocusableOutputProps): HTMLElement | null | undefined;
+    findNext(options: FindNextProps, out?: FindFocusableOutputProps): HTMLElement | null | undefined;
+    findPrev(options: FindNextProps, out?: FindFocusableOutputProps): HTMLElement | null | undefined;
+    findDefault(options: FindDefaultProps, out?: FindFocusableOutputProps): HTMLElement | null;
+    /**
+     * @returns All focusables in a given context that satisfy an given condition
+     */
+    findAll(options: FindAllProps): HTMLElement[];
+    findElement(options: FindFocusableProps, out?: FindFocusableOutputProps): HTMLElement | null | undefined;
+}
+export interface DummyInputManager {
+    moveOut: (backwards: boolean) => void;
+    moveOutWithDefaultAction: (backwards: boolean, relatedEvent: KeyboardEvent) => void;
+}
+import { Visibilities as _Visibilities } from "./Consts";
+export type Visibilities = typeof _Visibilities;
+export type Visibility = Visibilities[keyof Visibilities];
+export interface MoverElementState {
+    isCurrent: boolean | undefined;
+    visibility: Visibility;
+}
+import { RestorerTypes as _RestorerTypes } from "./Consts";
+export type RestorerTypes = typeof _RestorerTypes;
+export type RestorerType = RestorerTypes[keyof RestorerTypes];
+import { MoverDirections as _MoverDirections } from "./Consts";
+export type MoverDirections = typeof _MoverDirections;
+export type MoverDirection = MoverDirections[keyof MoverDirections];
+export interface NextTabbable {
+    element: HTMLElement | null | undefined;
+    uncontrolled?: HTMLElement | null;
+    outOfDOMOrder?: boolean;
+}
+export interface MoverProps {
+    direction?: MoverDirection;
+    memorizeCurrent?: boolean;
+    tabbable?: boolean;
+    /**
+     * Whether to allow cyclic navigation in the mover
+     * Can only be applied if navigationType is MoverKeys.Arrows
+     *
+     * @defaultValue false
+     */
+    cyclic?: boolean;
+    /**
+     * In case we need a rich state of the elements inside a Mover,
+     * we can track it. It takes extra resourses and might affect
+     * performance when a Mover has many elements inside, so make sure
+     * you use this prop when it is really needed.
+     */
+    trackState?: boolean;
+    /**
+     * When set to Visibility.Visible or Visibility.PartiallyVisible,
+     * uses the visibility part of the trackState prop to be able to
+     * go to first/last visible element (instead of first/last focusable
+     * element in DOM) when tabbing from outside of the mover.
+     */
+    visibilityAware?: Visibility;
+    /**
+     * When true, Mover will try to locate a focusable with Focusable.isDefault
+     * property as a prioritized element to focus. True by default.
+     */
+    hasDefault?: boolean;
+    /**
+     * A value between 0 and 1 that specifies the tolerance allowed
+     * when testing for visibility.
+     *
+     * @example
+     * an element of height 100px has 10px that are above the viewport
+     * hidden by scroll. This element is a valid visible element to focus.
+     *
+     * @default 0.8
+     */
+    visibilityTolerance?: number;
+}
+export interface Mover extends TabsterPart<MoverProps>, TabsterPartWithFindNextTabbable, TabsterPartWithAcceptElement {
+    readonly id: string;
+    readonly dummyManager: DummyInputManager | undefined;
+    readonly visibilityTolerance: NonNullable<MoverProps["visibilityTolerance"]>;
+    dispose(): void;
+    setCurrent(element: HTMLElement | undefined): void;
+    getCurrent(): HTMLElement | null;
+    getState(element: HTMLElement): MoverElementState | undefined;
+}
+export type MoverConstructor = (tabster: TabsterCore, element: HTMLElement, props: MoverProps) => Mover;
+interface MoverAPIInternal {
+}
+import { MoverKeys as _MoverKeys } from "./Consts";
+export type MoverKeys = typeof _MoverKeys;
+export type MoverKey = MoverKeys[keyof MoverKeys];
+export interface MoverAPI extends MoverAPIInternal, Disposable {
+}
+import { GroupperTabbabilities as _GroupperTabbabilities } from "./Consts";
+export type GroupperTabbabilities = typeof _GroupperTabbabilities;
+export type GroupperTabbability = GroupperTabbabilities[keyof GroupperTabbabilities];
+export interface GroupperProps {
+    tabbability?: GroupperTabbability;
+    delegated?: boolean;
+}
+export interface Groupper extends TabsterPart<GroupperProps>, TabsterPartWithFindNextTabbable, TabsterPartWithAcceptElement {
+    readonly id: string;
+    readonly dummyManager: DummyInputManager | undefined;
+    dispose(): void;
+    makeTabbable(isUnlimited: boolean): void;
+    isActive(noIfFirstIsFocused?: boolean): boolean | undefined;
+    setFirst(element: HTMLElement | undefined): void;
+    getFirst(orContainer: boolean): HTMLElement | undefined;
+}
+export type GroupperConstructor = (tabster: TabsterCore, element: HTMLElement, props: GroupperProps) => Groupper;
+export interface GroupperAPIInternal {
+}
+import { GroupperMoveFocusActions as _GroupperMoveFocusActions } from "./Consts";
+export type GroupperMoveFocusActions = typeof _GroupperMoveFocusActions;
+export type GroupperMoveFocusAction = GroupperMoveFocusActions[keyof GroupperMoveFocusActions];
+export interface GroupperAPI extends GroupperAPIInternal, Disposable {
+}
+export interface GroupperAPIInternal {
+    forgetCurrentGrouppers(): void;
+}
+export interface ModalizerProps {
+    id: string;
+    isOthersAccessible?: boolean;
+    isAlwaysAccessible?: boolean;
+    isNoFocusFirst?: boolean;
+    isNoFocusDefault?: boolean;
+    /** A focus trap variant, keeps focus inside the modal when tabbing */
+    isTrapped?: boolean;
+}
+export interface Modalizer extends TabsterPart<ModalizerProps>, TabsterPartWithFindNextTabbable {
+    readonly userId: string;
+    readonly dummyManager: DummyInputManager | undefined;
+    /**
+     * @returns - Whether the element is inside the modalizer
+     */
+    contains(element: HTMLElement): boolean;
+    dispose(): void;
+    isActive(): boolean;
+    makeActive(isActive: boolean): void;
+    focused(noIncrement?: boolean): number;
+}
+export type ModalizerConstructor = (tabster: TabsterCore, element: HTMLElement, props: ModalizerProps) => Modalizer;
+export interface RootProps {
+    restoreFocusOrder?: RestoreFocusOrder;
+}
+export interface Root extends TabsterPart<RootProps> {
+    readonly uid: string;
+    dispose(): void;
+    moveOutWithDefaultAction(backwards: boolean, relatedEvent: KeyboardEvent): void;
+}
+export type RootConstructor = (tabster: TabsterCore, element: HTMLElement, props: RootProps) => Root;
+import { SysDummyInputsPositions as _SysDummyInputsPositions } from "./Consts";
+export type SysDummyInputsPositions = typeof _SysDummyInputsPositions;
+export type SysDummyInputsPosition = SysDummyInputsPositions[keyof SysDummyInputsPositions];
+/**
+ * Ability to fine-tune Tabster internal behaviour in rare cases of need.
+ * Normally, should not be used. A deep understanding of the intention and the effect
+ * is required.
+ */
+export interface SysProps {
+    /**
+     * Force dummy input position outside or inside of the element.
+     * By default (when undefined), the position is determined dynamically
+     * (for example inside for <li> elements and outside for <table> elements,
+     * plus a default Groupper/Mover/Modalizer implementation position).
+     * Setting to true will force the dummy inputs to be always outside of the element,
+     * setting to false will force the dummy inputs to be always inside.
+     */
+    dummyInputsPosition?: SysDummyInputsPosition;
+}
+export interface GetTabsterContextOptions {
+    /**
+     * Should visit **all** element ancestors to verify if `dir='rtl'` is set
+     */
+    checkRtl?: boolean;
+    /**
+     * The element to start computing the context from. Useful when dealing
+     * with nested structures. For example, if we have an element inside a groupper
+     * inside another groupper, the `groupper` prop in this element's contexts will
+     * be the inner groupper, but when we pass the inner groupper's parent element
+     * as `referenceElement`, the context groupper will be the outer one. Having
+     * this option simplifies searching for the next tabbable element in the
+     * environment of nested movers and grouppers.
+     */
+    referenceElement?: HTMLElement;
+}
+export type TabsterContextMoverGroupper = {
+    isMover: true;
+    mover: Mover;
+} | {
+    isMover: false;
+    groupper: Groupper;
+};
+export interface TabsterContext {
+    root: Root;
+    modalizer?: Modalizer;
+    groupper?: Groupper;
+    mover?: Mover;
+    groupperBeforeMover?: boolean;
+    modalizerInGroupper?: Groupper;
+    /**
+     * Whether `dir='rtl'` is set on an ancestor
+     */
+    rtl?: boolean;
+    excludedFromMover?: boolean;
+    uncontrolled?: HTMLElement | null;
+    ignoreKeydown: (e: KeyboardEvent) => boolean;
+}
+interface RootAPIInternal {
+}
+export interface RootAPI extends Disposable, RootAPIInternal {
+}
+export interface UncontrolledAPI {
+    isUncontrolledCompletely(element: HTMLElement, completely: boolean): boolean;
+}
+interface ModalizerAPIInternal extends TabsterPartWithAcceptElement {
+}
+export interface ModalizerAPI extends ModalizerAPIInternal, Disposable {
+    /**
+     * Activates a Modalizer and focuses the first or default element within
+     *
+     * @param elementFromModalizer An element that belongs to a Modalizer
+     * @param noFocusFirst Do not focus on the first element in the Modalizer
+     * @param noFocusDefault Do not focus the default element in the Modalizre
+     */
+    focus(elementFromModalizer: HTMLElement, noFocusFirst?: boolean, noFocusDefault?: boolean): boolean;
+    /**
+     * Just activates the modalizer without focusing on any element. Might be useful,
+     * when the modalizer doesn't have focusable elements yet (but you want it active
+     * already).
+     *
+     * @param modalizerElementOrContainer The element that belongs to a Modalizer or the Modalizer container,
+     * or undefined to activate main app (deactivating any active modalizer).
+     * @returns true if the modalizer was activated.
+     */
+    activate(modalizerElementOrContainer: HTMLElement | undefined): boolean;
+}
+interface RestorerAPIInternal {
+}
+export interface RestorerAPI extends RestorerAPIInternal, Disposable {
+}
+export interface Restorer extends Disposable, TabsterPart<RestorerProps> {
+}
+/**
+ * A signature for the accessibleCheck callback from getModalizer().
+ * It is called when active Modalizer sets aria-hidden on elements outsidef of it.
+ *
+ * @param element The element that is about to receive aria-hidden.
+ * @param activeModalizerElements The container elements of the active modalizer.
+ * @returns true if the element should remain accessible and should not receive
+ * aria-hidden.
+ */
+export type ModalizerElementAccessibleCheck = (element: HTMLElement, activeModalizerElements?: HTMLElement[]) => boolean;
+export interface UncontrolledProps {
+    completely?: boolean;
+}
+export interface DeloserOnElement {
+    deloser: Deloser;
+}
+export interface RootOnElement {
+    root: Root;
+}
+export interface ModalizerOnElement {
+    modalizer: Modalizer;
+}
+export interface RestorerOnElement {
+    restorer: Restorer;
+}
+export interface FocusableOnElement {
+    focusable: FocusableProps;
+}
+export interface MoverOnElement {
+    mover: Mover;
+}
+export interface GroupperOnElement {
+    groupper: Groupper;
+}
+export interface UncontrolledOnElement {
+    uncontrolled: UncontrolledProps;
+}
+export interface ObservedOnElement {
+    observed: ObservedElementProps;
+}
+export interface OutlineOnElement {
+    outline: OutlinedElementProps;
+}
+export interface SysOnElement {
+    sys: SysProps;
+}
+export interface RestorerProps {
+    type: RestorerType;
+    id?: string;
+}
+export type TabsterAttributeProps = Partial<{
+    deloser: DeloserProps;
+    root: RootProps;
+    uncontrolled: UncontrolledProps;
+    modalizer: ModalizerProps;
+    focusable: FocusableProps;
+    groupper: GroupperProps;
+    mover: MoverProps;
+    observed: ObservedElementProps;
+    outline: OutlinedElementProps;
+    sys: SysProps;
+    restorer: RestorerProps;
+}>;
+export interface TabsterAttributeOnElement {
+    string: string;
+    object: TabsterAttributeProps;
+}
+export interface TabsterAugmentedAttributes {
+    [name: string]: string | null;
+}
+export type TabsterOnElement = Partial<RootOnElement & DeloserOnElement & ModalizerOnElement & FocusableOnElement & MoverOnElement & GroupperOnElement & ObservedOnElement & OutlineOnElement & UncontrolledOnElement & SysOnElement & RestorerOnElement>;
+export interface OutlineElements {
+    container: HTMLDivElement;
+    left: HTMLDivElement;
+    top: HTMLDivElement;
+    right: HTMLDivElement;
+    bottom: HTMLDivElement;
+}
+export interface TabsterElementStorageEntry {
+    tabster?: TabsterOnElement;
+    attr?: TabsterAttributeOnElement;
+    aug?: TabsterAugmentedAttributes;
+}
+export interface TabsterElementStorage {
+    [uid: string]: TabsterElementStorageEntry;
+}
+export type DisposeFunc = () => void;
+export interface InternalAPI {
+    stopObserver(): void;
+    resumeObserver(syncState: boolean): void;
+}
+export interface DummyInputObserver {
+    add(dummy: HTMLElement, callback: () => void): void;
+    remove(dummy: HTMLElement): void;
+    dispose(): void;
+    domChanged?(parent: HTMLElement): void;
+    updatePositions(compute: (scrollTopLeftCache: Map<HTMLElement, {
+        scrollTop: number;
+        scrollLeft: number;
+    } | null>) => () => void): void;
+}
+interface TabsterCoreInternal {
+}
+export interface Tabster {
+    keyboardNavigation: KeyboardNavigationState;
+    focusedElement: FocusedElementState;
+    focusable: FocusableAPI;
+    root: RootAPI;
+    uncontrolled: UncontrolledAPI;
+}
+export interface TabsterCore extends Pick<TabsterCoreProps, "controlTab" | "rootDummyInputs">, Disposable, TabsterCoreInternal, Omit<Tabster, "core"> {
+}
+export interface TabsterCompat {
+    attributeTransform?: <P>(old: P) => TabsterAttributeProps;
+}
+export {};

node_modules/tabster/dist/dts/Uncontrolled.d.ts

@@ -0,0 +1,14 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import * as Types from "./Types";
+/**
+ * Allows default or user focus behaviour on the DOM subtree
+ * i.e. Tabster will not control focus events within an uncontrolled area
+ */
+export declare class UncontrolledAPI implements Types.UncontrolledAPI {
+    private _isUncontrolledCompletely?;
+    constructor(isUncontrolledCompletely?: (element: HTMLElement, completely: boolean) => boolean | undefined);
+    isUncontrolledCompletely(element: HTMLElement, completely: boolean): boolean;
+}

node_modules/tabster/dist/dts/Utils.d.ts

@@ -0,0 +1,179 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { DummyInputObserver as DummyInputObserverInterface, GetWindow, RadioButtonGroup, SysProps, TabsterAttributeProps, TabsterCore, TabsterPart as TabsterPartInterface, Visibility, WeakHTMLElement as WeakHTMLElementInterface } from "./Types";
+interface HTMLElementWithBoundingRectCacheId extends HTMLElement {
+    __tabsterCacheId?: string;
+}
+export interface WindowWithUID extends Window {
+    __tabsterCrossOriginWindowUID?: string;
+}
+export interface HTMLElementWithUID extends HTMLElement {
+    __tabsterElementUID?: string;
+}
+export interface TabsterDOMRect {
+    bottom: number;
+    left: number;
+    right: number;
+    top: number;
+}
+export interface InstanceContext {
+    elementByUId: {
+        [uid: string]: WeakHTMLElement<HTMLElementWithUID>;
+    };
+    basics: InternalBasics;
+    WeakRef?: WeakRefConstructor;
+    containerBoundingRectCache: {
+        [id: string]: {
+            rect: TabsterDOMRect;
+            element: HTMLElementWithBoundingRectCacheId;
+        };
+    };
+    lastContainerBoundingRectCacheId: number;
+    containerBoundingRectCacheTimer?: number;
+    fakeWeakRefs: TabsterWeakRef<unknown>[];
+    fakeWeakRefsTimer?: number;
+    fakeWeakRefsStarted: boolean;
+}
+export declare function getInstanceContext(getWindow: GetWindow): InstanceContext;
+export declare function disposeInstanceContext(win: Window): void;
+export declare function createWeakMap<K extends object, V>(win: Window): WeakMap<K, V>;
+export declare function hasSubFocusable(element: HTMLElement): boolean;
+interface TabsterWeakRef<T> {
+    deref(): T | undefined;
+}
+export declare class WeakHTMLElement<T extends HTMLElement = HTMLElement, D = undefined> implements WeakHTMLElementInterface<D> {
+    private _ref;
+    private _data;
+    constructor(getWindow: GetWindow, element: T, data?: D);
+    get(): T | undefined;
+    getData(): D | undefined;
+}
+export declare function cleanupFakeWeakRefs(getWindow: GetWindow, forceRemove?: boolean): void;
+export declare function startFakeWeakRefsCleanup(getWindow: GetWindow): void;
+export declare function stopFakeWeakRefsCleanupAndClearStorage(getWindow: GetWindow): void;
+export declare function createElementTreeWalker(doc: Document, root: Node, acceptNode: (node: Node) => number): TreeWalker | undefined;
+export declare function getBoundingRect(getWindow: GetWindow, element: HTMLElementWithBoundingRectCacheId): TabsterDOMRect;
+export declare function isElementVerticallyVisibleInContainer(getWindow: GetWindow, element: HTMLElement, tolerance: number): boolean;
+export declare function isElementVisibleInContainer(getWindow: GetWindow, element: HTMLElement, gap?: number): Visibility;
+export declare function scrollIntoView(getWindow: GetWindow, element: HTMLElement, alignToTop: boolean): void;
+export declare function getScrollableContainer(element: HTMLElement): HTMLElement | null;
+export declare function makeFocusIgnored(element: HTMLElement): void;
+export declare function shouldIgnoreFocus(element: HTMLElement): boolean;
+export declare function getUId(wnd: Window & {
+    msCrypto?: Crypto;
+}): string;
+export declare function getElementUId(getWindow: GetWindow, element: HTMLElementWithUID): string;
+export declare function getElementByUId(context: InstanceContext, uid: string): WeakHTMLElement<HTMLElementWithUID, undefined> | undefined;
+export declare function getWindowUId(win: WindowWithUID): string;
+export declare function clearElementCache(getWindow: GetWindow, parent?: HTMLElement): void;
+export declare function documentContains(doc: HTMLDocument | null | undefined, element: HTMLElement): boolean;
+export declare function matchesSelector(element: HTMLElement, selector: string): boolean;
+export declare function getPromise(getWindow: GetWindow): PromiseConstructor;
+export declare function getWeakRef(context: InstanceContext): WeakRefConstructor | undefined;
+interface InternalBasics {
+    Promise?: PromiseConstructor;
+    WeakRef?: WeakRefConstructor;
+    WeakMap?: WeakMapConstructor;
+}
+export declare function setBasics(win: Window, basics: InternalBasics): void;
+export declare abstract class TabsterPart<P, D = undefined> implements TabsterPartInterface<P> {
+    protected _tabster: TabsterCore;
+    protected _element: WeakHTMLElement<HTMLElement, D>;
+    protected _props: P;
+    readonly id: string;
+    constructor(tabster: TabsterCore, element: HTMLElement, props: P);
+    getElement(): HTMLElement | undefined;
+    getProps(): P;
+    setProps(props: P): void;
+}
+export interface DummyInputProps {
+    /** The input is created to be used only once and autoremoved when focused. */
+    isPhantom?: boolean;
+    /** Whether the input is before or after the content it is guarding.  */
+    isFirst: boolean;
+}
+export type DummyInputFocusCallback = (dummyInput: DummyInput, isBackward: boolean, relatedTarget: HTMLElement | null) => void;
+/**
+ * Dummy HTML elements that are used as focus sentinels for the DOM enclosed within them
+ */
+export declare class DummyInput {
+    private _isPhantom;
+    private _fixedTarget?;
+    private _disposeTimer;
+    private _clearDisposeTimeout;
+    input: HTMLElement | undefined;
+    useDefaultAction?: boolean;
+    isFirst: DummyInputProps["isFirst"];
+    isOutside: boolean;
+    /** Called when the input is focused */
+    onFocusIn?: DummyInputFocusCallback;
+    /** Called when the input is blurred */
+    onFocusOut?: DummyInputFocusCallback;
+    constructor(getWindow: GetWindow, isOutside: boolean, props: DummyInputProps, element?: WeakHTMLElement, fixedTarget?: WeakHTMLElement);
+    dispose(): void;
+    setTopLeft(top: number, left: number): void;
+    private _isBackward;
+    private _focusIn;
+    private _focusOut;
+}
+export declare const DummyInputManagerPriorities: {
+    readonly Root: 1;
+    readonly Modalizer: 2;
+    readonly Mover: 3;
+    readonly Groupper: 4;
+};
+export declare class DummyInputManager {
+    private _instance?;
+    private _onFocusIn?;
+    private _onFocusOut?;
+    protected _element: WeakHTMLElement;
+    constructor(tabster: TabsterCore, element: WeakHTMLElement, priority: number, sys: SysProps | undefined, outsideByDefault?: boolean, callForDefaultAction?: boolean);
+    protected _setHandlers(onFocusIn?: DummyInputFocusCallback, onFocusOut?: DummyInputFocusCallback): void;
+    moveOut(backwards: boolean): void;
+    moveOutWithDefaultAction(backwards: boolean, relatedEvent: KeyboardEvent): void;
+    getHandler(isIn: boolean): DummyInputFocusCallback | undefined;
+    setTabbable(tabbable: boolean): void;
+    dispose(): void;
+    static moveWithPhantomDummy(tabster: TabsterCore, element: HTMLElement, // The target element to move to or out of.
+    moveOutOfElement: boolean, // Whether to move out of the element or into it.
+    isBackward: boolean, // Are we tabbing of shift-tabbing?
+    relatedEvent: KeyboardEvent): void;
+    static addPhantomDummyWithTarget(tabster: TabsterCore, sourceElement: HTMLElement, isBackward: boolean, targetElement: HTMLElement): void;
+}
+export declare class DummyInputObserver implements DummyInputObserverInterface {
+    private _win?;
+    private _updateQueue;
+    private _updateTimer?;
+    private _lastUpdateQueueTime;
+    private _changedParents;
+    private _updateDummyInputsTimer?;
+    private _dummyElements;
+    private _dummyCallbacks;
+    domChanged?(parent: HTMLElement): void;
+    constructor(win: GetWindow);
+    add(dummy: HTMLElement, callback: () => void): void;
+    remove(dummy: HTMLElement): void;
+    dispose(): void;
+    private _domChanged;
+    updatePositions(compute: (scrollTopLeftCache: Map<HTMLElement, {
+        scrollTop: number;
+        scrollLeft: number;
+    } | null>) => () => void): void;
+    private _scheduledUpdatePositions;
+}
+export declare function getLastChild(container: HTMLElement): HTMLElement | undefined;
+export declare function getAdjacentElement(from: HTMLElement, prev?: boolean): HTMLElement | undefined;
+export declare function augmentAttribute(tabster: TabsterCore, element: HTMLElement, name: string, value?: string | null): boolean;
+export declare function getTabsterAttributeOnElement(element: HTMLElement): TabsterAttributeProps | null;
+export declare function isDisplayNone(element: HTMLElement): boolean;
+export declare function isRadio(element: HTMLElement): boolean;
+export declare function getRadioButtonGroup(element: HTMLElement): RadioButtonGroup | undefined;
+/**
+ * If the passed element is Tabster dummy input, returns the container element this dummy input belongs to.
+ * @param element Element to check for being dummy input.
+ * @returns Dummy input container element (if the passed element is a dummy input) or null.
+ */
+export declare function getDummyInputContainer(element: HTMLElement | null | undefined): HTMLElement | null;
+export {};

node_modules/tabster/dist/dts/index.d.ts

@@ -0,0 +1,11 @@
+/*!
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export { createTabster, disposeTabster, forceCleanup, getCrossOrigin, getDeloser, getDummyInputContainer, getGroupper, getInternal, getModalizer, getMover, getObservedElement, getOutline, getRestorer, getShadowDOMAPI, getTabster, isNoOp, makeNoOp, } from "./Tabster";
+export * from "./AttributeHelpers";
+export * as Types from "./Types";
+export * from "./Events";
+export * as EventsTypes from "./EventsTypes";
+export * from "./Consts";
+export * from "./Deprecated";

node_modules/tabster/node_modules/@rollup/rollup-linux-x64-gnu/README.md

@@ -0,0 +1,3 @@
+# `@rollup/rollup-linux-x64-gnu`
+
+This is the **x86_64-unknown-linux-gnu** binary for `rollup`

node_modules/tabster/node_modules/@rollup/rollup-linux-x64-gnu/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@rollup/rollup-linux-x64-gnu",
+  "version": "4.53.3",
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "files": [
+    "rollup.linux-x64-gnu.node"
+  ],
+  "description": "Native bindings for Rollup",
+  "author": "Lukas Taegert-Atkinson",
+  "homepage": "https://rollupjs.org/",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rollup/rollup.git"
+  },
+  "libc": [
+    "glibc"
+  ],
+  "main": "./rollup.linux-x64-gnu.node"
+}

node_modules/tabster/package.json

@@ -0,0 +1,114 @@
+{
+    "name": "tabster",
+    "version": "8.7.0",
+    "description": "Focus Management Tools for Web",
+    "author": "Marat Abdullin <marata@microsoft.com>",
+    "license": "MIT",
+    "sideEffects": false,
+    "main": "./dist/index.js",
+    "module": "./dist/tabster.esm.js",
+    "typings": "./dist/index.d.ts",
+    "files": [
+        "dist"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/microsoft/tabster"
+    },
+    "scripts": {
+        "build": "npm run clean && npm run build-bundle && npm run build-storybook",
+        "build-bundle": "rollup -c",
+        "build-docs": "cd docs && npm install && npm run build",
+        "build-storybook": "storybook build",
+        "bundle-size": "npm run build-bundle && bundle-size measure",
+        "clean": "rimraf dist",
+        "format": "prettier --write .",
+        "format:check": "prettier --check .",
+        "lint": "eslint src/ --fix",
+        "lint:check": "eslint src/",
+        "test": "node tests/utils/runner.cjs",
+        "test:uncontrolled": "STORYBOOK_UNCONTROLLED=true npm test",
+        "test:root-dummy-inputs": "STORYBOOK_UNCONTROLLED=true STORYBOOK_ROOT_DUMMY_INPUTS=true npm test",
+        "test:shadowdom": "SHADOWDOM=true npm test",
+        "test:shadowdom:uncontrolled": "SHADOWDOM=true STORYBOOK_UNCONTROLLED=true npm test",
+        "test:shadowdom:root-dummy-inputs": "SHADOWDOM=true STORYBOOK_UNCONTROLLED=true STORYBOOK_ROOT_DUMMY_INPUTS=true npm test",
+        "test:all": "npm run test && npm run test:uncontrolled && npm run test:root-dummy-inputs && npm run test:shadowdom && npm run test:shadowdom:uncontrolled && npm run test:shadowdom:root-dummy-inputs",
+        "prepublishOnly": "npm run build",
+        "release": "release-it",
+        "serve": "npx http-serve storybook-static",
+        "serve-docs": "cd docs && npm run serve",
+        "start": "npm run storybook",
+        "start-docs": "cd docs && npm run start",
+        "start:uncontrolled": "STORYBOOK_UNCONTROLLED=true npm run storybook",
+        "start:root-dummy-inputs": "STORYBOOK_UNCONTROLLED=true STORYBOOK_ROOT_DUMMY_INPUTS=true npm run storybook",
+        "storybook": "storybook dev -p 8080",
+        "type-check": "npm run type-check:lib && npm run type-check:tests && npm run type-check:stories",
+        "type-check:lib": "tsc -b  src/tsconfig.lib.json",
+        "type-check:tests": "tsc -b tests/tsconfig.spec.json",
+        "type-check:stories": "tsc -b stories/tsconfig.stories.json",
+        "prepare-pages-deploy": "rimraf ./.pages-deploy && npm run build-docs && npm run build-storybook && copyfiles -u 2 -a \"./docs/build/**/*\" ./.pages-deploy && copyfiles -u 1 -a \"./storybook-static/**/*\" ./.pages-deploy/storybook"
+    },
+    "dependencies": {
+        "keyborg": "2.6.0",
+        "tslib": "^2.8.1"
+    },
+    "devDependencies": {
+        "@babel/core": "^7.28.5",
+        "@babel/plugin-proposal-class-properties": "^7.18.6",
+        "@babel/plugin-proposal-decorators": "^7.28.0",
+        "@babel/plugin-transform-react-jsx": "^7.27.1",
+        "@babel/plugin-transform-typescript": "^7.28.5",
+        "@babel/preset-env": "^7.28.5",
+        "@babel/preset-react": "^7.28.5",
+        "@babel/preset-typescript": "^7.28.5",
+        "@rollup/plugin-babel": "^6.1.0",
+        "@rollup/plugin-commonjs": "^29.0.0",
+        "@rollup/plugin-json": "^6.1.0",
+        "@rollup/plugin-node-resolve": "^16.0.3",
+        "@rollup/plugin-replace": "^6.0.3",
+        "@storybook/html-vite": "^10.1.4",
+        "@tsconfig/docusaurus": "^2.0.7",
+        "@types/expect-puppeteer": "^5.0.6",
+        "@types/jest": "^30.0.0",
+        "@types/jest-environment-puppeteer": "^5.0.6",
+        "@types/node": "^24.10.1",
+        "@types/react": "^19.2.7",
+        "@types/react-dom": "^19.2.3",
+        "@typescript-eslint/eslint-plugin": "^8.48.1",
+        "@typescript-eslint/parser": "^8.48.1",
+        "auto-changelog": "^2.5.0",
+        "babel-jest": "^30.2.0",
+        "babel-loader": "^10.0.0",
+        "babel-plugin-annotate-pure-calls": "^0.5.0",
+        "copyfiles": "^2.4.1",
+        "eslint": "^9.39.1",
+        "eslint-config-prettier": "^10.1.8",
+        "eslint-plugin-header": "^3.1.1",
+        "eslint-plugin-import": "^2.32.0",
+        "jest": "^30.2.0",
+        "jest-puppeteer": "^11.0.0",
+        "monosize": "^0.7.0",
+        "monosize-bundler-webpack": "0.2.0",
+        "monosize-storage-azure": "0.0.17",
+        "prettier": "^3.7.4",
+        "puppeteer": "^24.32.0",
+        "react": "^19.2.1",
+        "react-dom": "^19.2.1",
+        "release-it": "^19.0.6",
+        "rimraf": "^6.1.2",
+        "rollup": "^4.53.3",
+        "rollup-plugin-dts": "^6.3.0",
+        "rollup-plugin-typescript2": "^0.36.0",
+        "storybook": "^10.1.4",
+        "strip-ansi": "^7.1.2",
+        "tree-kill": "^1.2.2",
+        "tsconfig-paths-webpack-plugin": "^4.2.0",
+        "typescript": "^5.9.3",
+        "typescript-eslint": "^8.48.1",
+        "vite": "^7.2.6",
+        "vite-tsconfig-paths": "^5.1.4"
+    },
+    "optionalDependencies": {
+        "@rollup/rollup-linux-x64-gnu": "4.53.3"
+    }
+}