feat: Fluent UI Outlook Lite + connections mockup

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";