@decky/ui 4.0.0

package/dist/plugin.d.ts

@@ -0,0 +1,68 @@
+import type { ComponentType, ReactNode } from 'react';
+import { RouteProps } from 'react-router';
+export interface Plugin {
+    title: JSX.Element;
+    icon: JSX.Element;
+    content?: JSX.Element;
+    onDismount?(): void;
+    alwaysRender?: boolean;
+}
+interface ServerResponseSuccess<TRes> {
+    success: true;
+    result: TRes;
+}
+interface ServerResponseError {
+    success: false;
+    result: string;
+}
+export type ServerResponse<TRes> = ServerResponseSuccess<TRes> | ServerResponseError;
+export type RoutePatch = (route: RouteProps) => RouteProps;
+export interface RouterHook {
+    addRoute(path: string, component: ComponentType, props?: Omit<RouteProps, 'path' | 'children'>): void;
+    addPatch(path: string, patch: RoutePatch): RoutePatch;
+    addGlobalComponent(name: string, component: ComponentType): void;
+    removeRoute(path: string): void;
+    removePatch(path: string, patch: RoutePatch): void;
+    removeGlobalComponent(name: string): void;
+}
+export interface ToastData {
+    title: ReactNode;
+    body: ReactNode;
+    onClick?: () => void;
+    logo?: ReactNode;
+    icon?: ReactNode;
+    className?: string;
+    contentClassName?: string;
+    duration?: number;
+    critical?: boolean;
+    eType?: number;
+    sound?: number;
+    playSound?: boolean;
+    showToast?: boolean;
+}
+export interface Toaster {
+    toast(toast: ToastData): void;
+}
+export interface FilePickerRes {
+    path: string;
+    realpath: string;
+}
+export declare const enum FileSelectionType {
+    FILE = 0,
+    FOLDER = 1
+}
+export interface ServerAPI {
+    routerHook: RouterHook;
+    toaster: Toaster;
+    openFilePicker(startPath: string, includeFiles?: boolean, regex?: RegExp): Promise<FilePickerRes>;
+    openFilePickerV2(select: FileSelectionType, startPath: string, includeFiles?: boolean, includeFolders?: boolean, filter?: RegExp | ((file: File) => boolean), extensions?: string[], showHiddenFiles?: boolean, allowAllFiles?: boolean, max?: number): Promise<FilePickerRes>;
+    callPluginMethod<TArgs = {}, TRes = {}>(methodName: string, args: TArgs): Promise<ServerResponse<TRes>>;
+    callServerMethod<TArgs = {}, TRes = {}>(methodName: string, args: TArgs): Promise<ServerResponse<TRes>>;
+    fetchNoCors<TRes = {}>(url: RequestInfo, request?: RequestInit): Promise<ServerResponse<TRes>>;
+    executeInTab(tab: string, runAsync: boolean, code: string): Promise<unknown>;
+    injectCssIntoTab<TRes = string>(tab: string, style: string): Promise<ServerResponse<TRes>>;
+    removeCssFromTab(tab: string, cssId: string): Promise<unknown>;
+}
+type DefinePluginFn = (serverAPI: ServerAPI) => Plugin;
+export declare const definePlugin: (fn: DefinePluginFn) => DefinePluginFn;
+export {};

package/dist/plugin.js

@@ -0,0 +1,5 @@
+export const definePlugin = (fn) => {
+    return (...args) => {
+        return fn(...args);
+    };
+};

package/dist/utils/index.d.ts

@@ -0,0 +1,12 @@
+export * from './patcher';
+export * from './react';
+export * from './static-classes';
+declare global {
+    var FocusNavController: any;
+    var GamepadNavTree: any;
+}
+export declare function joinClassNames(...classes: string[]): string;
+export declare function sleep(ms: number): Promise<unknown>;
+export declare function findSP(): Window;
+export declare function getFocusNavController(): any;
+export declare function getGamepadNavigationTrees(): any;

package/dist/utils/index.js

@@ -0,0 +1,23 @@
+export * from './patcher';
+export * from './react';
+export * from './static-classes';
+export function joinClassNames(...classes) {
+    return classes.join(' ');
+}
+export function sleep(ms) {
+    return new Promise((res) => setTimeout(res, ms));
+}
+export function findSP() {
+    if (document.title == 'SP')
+        return window;
+    const navTrees = getGamepadNavigationTrees();
+    return navTrees?.find((x) => x.m_ID == 'root_1_').Root.Element.ownerDocument.defaultView;
+}
+export function getFocusNavController() {
+    return window.GamepadNavTree?.m_context?.m_controller || window.FocusNavController;
+}
+export function getGamepadNavigationTrees() {
+    const focusNav = getFocusNavController();
+    const context = focusNav.m_ActiveContext || focusNav.m_LastActiveContext;
+    return context?.m_rgGamepadNavigationTrees;
+}

package/dist/utils/patcher.d.ts

@@ -0,0 +1,18 @@
+export declare let callOriginal: symbol;
+export interface PatchOptions {
+    singleShot?: boolean;
+}
+type GenericPatchHandler = (args: any[], ret?: any) => any;
+export interface Patch {
+    original: Function;
+    property: string;
+    object: any;
+    patchedFunction: any;
+    hasUnpatched: boolean;
+    handler: GenericPatchHandler;
+    unpatch: () => void;
+}
+export declare function beforePatch(object: any, property: string, handler: (args: any[]) => any, options?: PatchOptions): Patch;
+export declare function afterPatch(object: any, property: string, handler: (args: any[], ret: any) => any, options?: PatchOptions): Patch;
+export declare function replacePatch(object: any, property: string, handler: (args: any[]) => any, options?: PatchOptions): Patch;
+export {};

package/dist/utils/patcher.js

@@ -0,0 +1,103 @@
+export let callOriginal = Symbol('DECKY_CALL_ORIGINAL');
+export function beforePatch(object, property, handler, options = {}) {
+    const orig = object[property];
+    object[property] = function (...args) {
+        handler.call(this, args);
+        const ret = patch.original.call(this, ...args);
+        if (options.singleShot) {
+            patch.unpatch();
+        }
+        return ret;
+    };
+    const patch = processPatch(object, property, handler, object[property], orig);
+    return patch;
+}
+export function afterPatch(object, property, handler, options = {}) {
+    const orig = object[property];
+    object[property] = function (...args) {
+        let ret = patch.original.call(this, ...args);
+        ret = handler.call(this, args, ret);
+        if (options.singleShot) {
+            patch.unpatch();
+        }
+        return ret;
+    };
+    const patch = processPatch(object, property, handler, object[property], orig);
+    return patch;
+}
+export function replacePatch(object, property, handler, options = {}) {
+    const orig = object[property];
+    object[property] = function (...args) {
+        const ret = handler.call(this, args);
+        if (ret == callOriginal)
+            return patch.original.call(this, ...args);
+        if (options.singleShot) {
+            patch.unpatch();
+        }
+        return ret;
+    };
+    const patch = processPatch(object, property, handler, object[property], orig);
+    return patch;
+}
+function processPatch(object, property, handler, patchedFunction, original) {
+    Object.assign(object[property], original);
+    object[property].toString = () => original.toString();
+    Object.defineProperty(object[property], '__deckyOrig', {
+        get: () => patch.original,
+        set: (val) => (patch.original = val),
+    });
+    const patch = {
+        object,
+        property,
+        handler,
+        patchedFunction,
+        original,
+        hasUnpatched: false,
+        unpatch: () => unpatch(patch),
+    };
+    object[property].__deckyPatch = patch;
+    return patch;
+}
+function unpatch(patch) {
+    const { object, property, handler, patchedFunction, original } = patch;
+    if (patch.hasUnpatched)
+        throw new Error('Function is already unpatched.');
+    let realProp = property;
+    let realObject = object;
+    console.debug('[Patcher] unpatching', {
+        realObject,
+        realProp,
+        object,
+        property,
+        handler,
+        patchedFunction,
+        original,
+        isEqual: realObject[realProp] === patchedFunction,
+    });
+    while (realObject[realProp] && realObject[realProp] !== patchedFunction) {
+        realObject = realObject[realProp].__deckyPatch;
+        realProp = 'original';
+        console.debug('[Patcher] moved to next', {
+            realObject,
+            realProp,
+            object,
+            property,
+            handler,
+            patchedFunction,
+            original,
+            isEqual: realObject[realProp] === patchedFunction,
+        });
+    }
+    realObject[realProp] = realObject[realProp].__deckyPatch.original;
+    patch.hasUnpatched = true;
+    console.debug('[Patcher] unpatched', {
+        realObject,
+        realProp,
+        object,
+        property,
+        handler,
+        patchedFunction,
+        original,
+        isEqual: realObject[realProp] === patchedFunction,
+    });
+}

package/dist/utils/react.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+declare global {
+    interface Window {
+        SP_REACT: typeof React;
+    }
+}
+export declare function fakeRenderComponent(fun: Function, customHooks?: any): any;
+export declare function wrapReactType(node: any, prop?: any): any;
+export declare function wrapReactClass(node: any, prop?: any): any;
+export declare function getReactRoot(o: HTMLElement | Element | Node): any;
+export declare function getReactInstance(o: HTMLElement | Element | Node): any;
+export interface findInTreeOpts {
+    walkable?: string[];
+    ignore?: string[];
+}
+export declare type findInTreeFilter = (element: any) => boolean;
+export declare const findInTree: (parent: any, filter: findInTreeFilter, opts: findInTreeOpts) => any;
+export declare const findInReactTree: (node: any, filter: findInTreeFilter) => any;

package/dist/utils/react.js

@@ -0,0 +1,74 @@
+export function fakeRenderComponent(fun, customHooks = {}) {
+    const hooks = window.SP_REACT.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentDispatcher
+        .current;
+    let oldHooks = {
+        useContext: hooks.useContext,
+        useCallback: hooks.useCallback,
+        useLayoutEffect: hooks.useLayoutEffect,
+        useEffect: hooks.useEffect,
+        useMemo: hooks.useMemo,
+        useRef: hooks.useRef,
+        useState: hooks.useState,
+    };
+    hooks.useCallback = (cb) => cb;
+    hooks.useContext = (cb) => cb._currentValue;
+    hooks.useLayoutEffect = (_) => { };
+    hooks.useMemo = (cb, _) => cb;
+    hooks.useEffect = (_) => { };
+    hooks.useRef = (val) => ({ current: val || {} });
+    hooks.useState = (v) => {
+        let val = v;
+        return [val, (n) => (val = n)];
+    };
+    Object.assign(hooks, customHooks);
+    const res = fun(hooks);
+    Object.assign(hooks, oldHooks);
+    return res;
+}
+export function wrapReactType(node, prop = 'type') {
+    if (node[prop]?.__DECKY_WRAPPED) {
+        return node[prop];
+    }
+    else {
+        return (node[prop] = { ...node[prop], __DECKY_WRAPPED: true });
+    }
+}
+export function wrapReactClass(node, prop = 'type') {
+    var _a;
+    if (node[prop]?.__DECKY_WRAPPED) {
+        return node[prop];
+    }
+    else {
+        const cls = node[prop];
+        const wrappedCls = (_a = class extends cls {
+            },
+            _a.__DECKY_WRAPPED = true,
+            _a);
+        return (node[prop] = wrappedCls);
+    }
+}
+export function getReactRoot(o) {
+    return (o[Object.keys(o).find((k) => k.startsWith('__reactContainer$'))] ||
+        o['_reactRootContainer']?._internalRoot?.current);
+}
+export function getReactInstance(o) {
+    return (o[Object.keys(o).find((k) => k.startsWith('__reactFiber'))] ||
+        o[Object.keys(o).find((k) => k.startsWith('__reactInternalInstance'))]);
+}
+export const findInTree = (parent, filter, opts) => {
+    const { walkable = null, ignore = [] } = opts ?? {};
+    if (!parent || typeof parent !== 'object') {
+        return null;
+    }
+    if (filter(parent))
+        return parent;
+    if (Array.isArray(parent)) {
+        return parent.map((x) => findInTree(x, filter, opts)).find((x) => x);
+    }
+    return (walkable || Object.keys(parent))
+        .map((x) => !ignore.includes(x) && findInTree(parent[x], filter, opts))
+        .find((x) => x);
+};
+export const findInReactTree = (node, filter) => findInTree(node, filter, {
+    walkable: ['props', 'children', 'child', 'sibling'],
+});

package/dist/utils/static-classes.d.ts

@@ -0,0 +1,52 @@
+type QuickAccessMenuClasses = Record<'ActiveTab' | 'AllTabContents' | 'BackgroundAnimation' | 'BatteryDetailsLabels' | 'BatteryIcon' | 'BatteryPercentageLabel' | 'BatteryProjectedLabel' | 'BatteryProjectedValue' | 'BatterySectionContainer' | 'Blocked' | 'ComingSoon' | 'Container' | 'ContentTransition' | 'Down' | 'EmptyNotifications' | 'Enter' | 'EnterActive' | 'Exit' | 'ExitActive' | 'FooterBoxShadow' | 'FriendsListTabPanel' | 'FriendsTitle' | 'FullHeight' | 'HeaderAndFooterVisible' | 'HeaderContainer' | 'ItemFocusAnim-darkGrey' | 'ItemFocusAnim-darkerGrey' | 'ItemFocusAnim-darkerGrey-nocolor' | 'ItemFocusAnim-green' | 'ItemFocusAnim-grey' | 'ItemFocusAnim-translucent-white-10' | 'ItemFocusAnim-translucent-white-20' | 'ItemFocusAnimBorder-darkGrey' | 'KeyboardButton' | 'Label' | 'LowBattery' | 'LowBatteryGauge' | 'Menu' | 'Open' | 'PanelExitAnchor' | 'PanelOuterNav' | 'PanelSection' | 'PanelSectionRow' | 'PanelSectionTitle' | 'PopupBody' | 'QuickAccessMenu' | 'QuickAccessNotifications' | 'ReallyLow' | 'Remaining' | 'Selected' | 'Tab' | 'TabContentColumn' | 'TabGroupPanel' | 'TabPanelHidden' | 'Tabs' | 'TabsWithFooter' | 'Text' | 'Title' | 'TransitionMenuDelay' | 'Up' | 'VR' | 'ViewPlaceholder' | 'VoiceTab' | 'duration-app-launch' | 'focusAnimation' | 'hoverAnimation' | 'vrgamepadui-floating-bar-popup-panel-height' | 'vrgamepadui-floating-bar-popup-panel-width' | 'vrgamepadui-floating-keyboard-height' | 'vrgamepadui-floating-keyboard-width' | 'vrgamepadui-floating-side-panel-height' | 'vrgamepadui-floating-side-panel-width', string>;
+type ScrollPanelClasses = Record<'ScrollBoth' | 'ScrollPanel' | 'ScrollX' | 'ScrollY', string>;
+type GamepadDialogClasses = Record<'ActiveAndUnfocused' | 'AlignCenter' | 'AlignLeft' | 'AlignRight' | 'BackgroundAnimation' | 'BasicTextInput' | 'BeforeChildren' | 'BottomButtons' | 'Button' | 'ChildrenWidthFixed' | 'ChildrenWidthGrow' | 'Clickable' | 'CompactPadding' | 'ControlsListChild' | 'ControlsListOuterPanel' | 'Disabled' | 'DropDownControlButtonContents' | 'DropDownRow' | 'ExtraPaddingOnChildrenBelow' | 'ExtraSpacing' | 'Field' | 'FieldChildrenInner' | 'FieldChildrenWithIcon' | 'FieldClickTarget' | 'FieldDescription' | 'FieldIcon' | 'FieldLabel' | 'FieldLabelRow' | 'FieldLabelValue' | 'Front' | 'FullWidth' | 'GamepadDialogContent' | 'GamepadDialogContent_InnerWidth' | 'HighlightOnFocus' | 'IconContainer' | 'InlineWrapShiftsChildrenBelow' | 'ItemFocusAnim-darkGrey' | 'ItemFocusAnim-darkerGrey' | 'ItemFocusAnim-darkerGrey-nocolor' | 'ItemFocusAnim-green' | 'ItemFocusAnim-grey' | 'ItemFocusAnim-translucent-white-10' | 'ItemFocusAnim-translucent-white-20' | 'ItemFocusAnimBorder-darkGrey' | 'ItemMaxSizeDesktop' | 'Label' | 'LabelFieldValue' | 'ModalClickToDismiss' | 'ModalPosition' | 'NoHeaderPadding' | 'NoMinWidth' | 'On' | 'QuickAccess-Menu' | 'ScrollWithin' | 'Spacer' | 'StandaloneFieldSeparator' | 'StandardPadding' | 'StandardSpacing' | 'Toggle' | 'ToggleRail' | 'ToggleSwitch' | 'VR' | 'VerticalAlignCenter' | 'WithBottomSeparator' | 'WithBottomSeparatorStandard' | 'WithBottomSeparatorThick' | 'WithChildrenBelow' | 'WithDescription' | 'WithFirstRow' | 'WithStandardPadding' | 'duration-app-launch' | 'focusAnimation' | 'hoverAnimation' | 'slideInAnimation', string>;
+type QuickAccessControlsClasses = Record<'BackgroundAnimation' | 'BatteryDetailsLabels' | 'BatteryIcon' | 'BatteryPercentageLabel' | 'BatteryProjectedLabel' | 'BatteryProjectedValue' | 'BatterySectionContainer' | 'ComingSoon' | 'EmptyNotifications' | 'ItemFocusAnim-darkGrey' | 'ItemFocusAnim-darkerGrey' | 'ItemFocusAnim-darkerGrey-nocolor' | 'ItemFocusAnim-green' | 'ItemFocusAnim-grey' | 'ItemFocusAnim-translucent-white-10' | 'ItemFocusAnim-translucent-white-20' | 'ItemFocusAnimBorder-darkGrey' | 'Label' | 'LowBattery' | 'LowBatteryGauge' | 'PanelSection' | 'PanelSectionRow' | 'PanelSectionTitle' | 'QuickAccessNotifications' | 'ReallyLow' | 'Remaining' | 'Text' | 'VR' | 'duration-app-launch' | 'focusAnimation' | 'hoverAnimation', string>;
+type UpdaterFieldClasses = Record<'ApplyingText' | 'BackgroundAnimation' | 'BatteryLowWarning' | 'Body' | 'CurrentStatus' | 'Denominator' | 'EventDetailTitle' | 'EventDetailsBody' | 'EventDetailsSubTitle' | 'InsufficientBatteryText' | 'ItemFocusAnim-darkGrey' | 'ItemFocusAnim-darkerGrey' | 'ItemFocusAnim-darkerGrey-nocolor' | 'ItemFocusAnim-green' | 'ItemFocusAnim-grey' | 'ItemFocusAnim-translucent-white-10' | 'ItemFocusAnim-translucent-white-20' | 'ItemFocusAnimBorder-darkGrey' | 'Label' | 'Numerator' | 'OOBEUpdateStatusContainer' | 'PatchNotes' | 'PostedTime' | 'ProgressInfoContainer' | 'ProgressStatus' | 'Separator' | 'Text' | 'TextContainer' | 'TimeRemaining' | 'Title' | 'TotalUpdateSize' | 'UnsupportedHardwareWarning' | 'UpdateBytesRemaining' | 'UpdatePanel' | 'UpdateScreen' | 'UpdateStatusContainer' | 'UpdaterFieldStatusApplying' | 'UpdaterFieldStatusSuccess' | 'duration-app-launch' | 'fadeInAnimation' | 'focusAnimation' | 'hoverAnimation', string>;
+type PlaySectionClasses = Record<'AchievementCountLabel' | 'AchievementProgressRow' | 'AchievementSVG' | 'ActionSection' | 'AppButtonsContainer' | 'Arrow' | 'AvatarAndPersona' | 'BackgroundAnimation' | 'BreakNarrow' | 'BreakShort' | 'BreakTall' | 'BreakUltraWide' | 'BreakWide' | 'ButtonChild' | 'ButtonText' | 'ChooseButton' | 'ClaimButton' | 'ClaimButtonContainer' | 'ClickablePlayBarItem' | 'CloudIconSVG' | 'CloudStatusIcon' | 'CloudStatusLabel' | 'CloudStatusRow' | 'CloudStatusSyncFail' | 'CloudSyncProblem' | 'CloudSynching' | 'ComingSoon' | 'Container' | 'ControllerConfigButton' | 'ControllerSupportInfo' | 'ControllerSupportRow' | 'DetailsProgressBar' | 'DetailsProgressContainer' | 'DetailsSection' | 'DetailsSectionExtra' | 'DetailsSectionStatus' | 'Disabled' | 'DotDotDot' | 'DownloadPaused' | 'DownloadProgressBar' | 'Downloading' | 'FavoriteButton' | 'Favorited' | 'FeatureHidden' | 'GameInfoButton' | 'GameStat' | 'GameStatIcon' | 'GameStatIconForced' | 'GameStatRight' | 'GameStatsSection' | 'GamepadUIBreakNarrow' | 'GamepadUIBreakShort' | 'GamepadUIBreakWide' | 'Glassy' | 'HideWhenNarrow' | 'Icon' | 'Icons' | 'InPage' | 'InnerContainer' | 'InvalidPlatform' | 'ItemFocusAnim-darkGrey' | 'ItemFocusAnim-darkerGrey' | 'ItemFocusAnim-darkerGrey-nocolor' | 'ItemFocusAnim-green' | 'ItemFocusAnim-grey' | 'ItemFocusAnim-translucent-white-10' | 'ItemFocusAnim-translucent-white-20' | 'ItemFocusAnimBorder-darkGrey' | 'LastPlayed' | 'LastPlayedInfo' | 'LaunchOptionCallout' | 'LaunchOptionCalloutMessage' | 'LaunchOptionCalloutMessageContainer' | 'LongButton' | 'MenuActive' | 'MenuButton' | 'MenuButtonContainer' | 'MiniAchievements' | 'OfflineMode' | 'OnlyDownloadBar' | 'PermanentlyUnavailable' | 'PlayBar' | 'PlayBarCloudStatusContainer' | 'PlayBarDetailLabel' | 'PlayBarGameIcon' | 'PlayBarGameName' | 'PlayBarIconAndGame' | 'PlayBarLabel' | 'Playtime' | 'PlaytimeIcon' | 'PlaytimeIconForced' | 'PortraitBar' | 'PrivateAppActiveIndicator' | 'RecentlyUpdated' | 'RecentlyUpdatedIcon' | 'RecentlyUpdatedLink' | 'RecentlyUpdatedText' | 'RightBreakNarrow' | 'RightBreakUltraNarrow' | 'RightBreakUltraWide' | 'RightBreakWide' | 'RightControls' | 'Row' | 'SharedLibrary' | 'ShowStreaming' | 'StatusAndStats' | 'StatusNameContainer' | 'StickyHeader' | 'StickyHeaderShadow' | 'SuperimposedGridItems' | 'SyncAnim' | 'Visible' | 'duration-app-launch' | 'favorited' | 'focusAnimation' | 'hoverAnimation', string>;
+type GamepadSliderClasses = Record<'AlignToEnds' | 'AlignToLeft' | 'AlignToRight' | 'BackgroundAnimation' | 'CompoundSlider' | 'CompoundSliderSubSlider' | 'CompoundSliderSubSliderLabel' | 'CompoundSliderSubSliderLabelContainer' | 'CompoundSliderSubSliderLabelInternal' | 'CompoundSliderSubSliderLabelPositioner' | 'DefaultValueColorLeft' | 'DefaultValueColorRight' | 'DefaultValueIsColorRange' | 'DefaultValueTick' | 'DefaultValueTickContainer' | 'DescriptionValue' | 'Disabled' | 'EditableValue' | 'ErrorShake' | 'FakeEditableValue' | 'Icon' | 'ItemFocusAnim-darkGrey' | 'ItemFocusAnim-darkerGrey' | 'ItemFocusAnim-darkerGrey-nocolor' | 'ItemFocusAnim-green' | 'ItemFocusAnim-grey' | 'ItemFocusAnim-translucent-white-10' | 'ItemFocusAnim-translucent-white-20' | 'ItemFocusAnimBorder-darkGrey' | 'LabelText' | 'Left' | 'ParenSliderHandle' | 'ParenSliderHandleContainer' | 'RedBorder' | 'Right' | 'SliderControl' | 'SliderControlAndNotches' | 'SliderControlPanelGroup' | 'SliderHandle' | 'SliderHandleContainer' | 'SliderHandleFocusPop' | 'SliderHasNotches' | 'SliderNotch' | 'SliderNotchContainer' | 'SliderNotchLabel' | 'SliderNotchTick' | 'SliderTrack' | 'SliderTrackDark' | 'TickActive' | 'VerticalLineSliderHandle' | 'VerticalLineSliderHandleContainer' | 'WithDefaultValue' | 'duration-app-launch' | 'error-shake' | 'error-shake-duration', string>;
+type AppDetailsHeaderClasses = Record<'AddBoxSizer' | 'Background' | 'Bottom' | 'BottomCenter' | 'BottomLeft' | 'BottomRight' | 'BoxSizer' | 'BoxSizerButtonContainer' | 'BoxSizerContainer' | 'BoxSizerDelete' | 'BoxSizerDragBox' | 'BoxSizerEdge' | 'BoxSizerGridBox' | 'BoxSizerInfo' | 'BoxSizerSettings' | 'BoxSizerValidRegion' | 'CenterCenter' | 'DialogButton' | 'EdgeDown' | 'FallbackArt' | 'Features' | 'FullscreenEnterActive' | 'FullscreenEnterDone' | 'FullscreenEnterStart' | 'FullscreenExitActive' | 'FullscreenExitDone' | 'FullscreenExitStart' | 'HeaderBackgroundImage' | 'ImgBlur' | 'ImgBlurBackdrop' | 'ImgContainer' | 'ImgSrc' | 'Left' | 'Loaded' | 'Middle' | 'NoArt' | 'PinBox' | 'Right' | 'SVGTitle' | 'SaveBoxSizer' | 'TextNameSpace' | 'TitleImageContainer' | 'TitleLogo' | 'TitleSection' | 'Top' | 'TopCapsule' | 'TopGradient' | 'TopLeft' | 'TopRight' | 'UpperCenter' | 'UpperLeft' | 'duration-app-launch', string>;
+type AppDetailsClasses = Record<'AppDetailsOverviewPanel' | 'BackgroundAnimation' | 'BreakNarrow' | 'BreakShort' | 'BreakTall' | 'BreakUltraWide' | 'BreakWide' | 'Container' | 'GamepadUIBreakNarrow' | 'GamepadUIBreakShort' | 'GamepadUIBreakWide' | 'Glassy' | 'Header' | 'HeaderLoaded' | 'InnerContainer' | 'ItemFocusAnim-darkGrey' | 'ItemFocusAnim-darkerGrey' | 'ItemFocusAnim-darkerGrey-nocolor' | 'ItemFocusAnim-green' | 'ItemFocusAnim-grey' | 'ItemFocusAnim-translucent-white-10' | 'ItemFocusAnim-translucent-white-20' | 'ItemFocusAnimBorder-darkGrey' | 'PlayBar' | 'PreventScrolling' | 'RightBreakNarrow' | 'RightBreakUltraNarrow' | 'RightBreakUltraWide' | 'RightBreakWide' | 'ScrollContainer' | 'ShowPlayBar' | 'Throbber' | 'duration-app-launch' | 'fadein' | 'focusAnimation' | 'hoverAnimation', string>;
+type GamepadUIClasses = Record<'BackgroundAnimation' | 'BasicHome' | 'BasicUiRoot' | 'Content' | 'ContinuousRenderPixel' | 'ContinuousRenderPixelBlink' | 'GamepadDialogOverlay' | 'GamepadUIPopupWindowBody' | 'HeaderHeightVisible' | 'ItemFocusAnim-darkGrey' | 'ItemFocusAnim-darkerGrey' | 'ItemFocusAnim-darkerGrey-nocolor' | 'ItemFocusAnim-green' | 'ItemFocusAnim-grey' | 'ItemFocusAnim-translucent-white-10' | 'ItemFocusAnim-translucent-white-20' | 'ItemFocusAnimBorder-darkGrey' | 'MainNavMenuAnchor' | 'MainNavMenuMainSplit' | 'OpaqueBackground' | 'PopupBody' | 'QuickAccessMenuAnchor' | 'StandaloneKeyboard' | 'SteamUIPopupHTML' | 'SteamUIPopupWindow' | 'SteamUIPopupWindowBody' | 'TransparentBackground' | 'TrueBlackBackground' | 'VR' | 'duration-app-launch' | 'focusAnimation' | 'hoverAnimation' | 'vrgamepadui-floating-bar-popup-panel-height' | 'vrgamepadui-floating-bar-popup-panel-width' | 'vrgamepadui-floating-keyboard-height' | 'vrgamepadui-floating-keyboard-width' | 'vrgamepadui-floating-side-panel-height' | 'vrgamepadui-floating-side-panel-width', string>;
+type GamepadTabbedPageClasses = Record<'Active' | 'AnimateDownwardExpansion' | 'Arrows' | 'BackgroundAnimation' | 'BleedGlyphs' | 'CanBeHeaderBackground' | 'ContentTransition' | 'Enter' | 'EnterActive' | 'Exit' | 'ExitActive' | 'ExpandFadeDownwards' | 'FixCenterAlignScroll' | 'Floating' | 'GamepadTabbedPage' | 'Glyphs' | 'HasAddon' | 'IsUnderHeader' | 'ItemFocusAnim-darkGrey' | 'ItemFocusAnim-darkerGrey' | 'ItemFocusAnim-darkerGrey-nocolor' | 'ItemFocusAnim-green' | 'ItemFocusAnim-grey' | 'ItemFocusAnim-translucent-white-10' | 'ItemFocusAnim-translucent-white-20' | 'ItemFocusAnimBorder-darkGrey' | 'Left' | 'LeftAddon' | 'OverlayPinnedView' | 'Right' | 'RightAddon' | 'ScrolledDown' | 'Selected' | 'Show' | 'SortAndFilterButton' | 'SortAndFilterContainer' | 'Tab' | 'TabBadge' | 'TabContents' | 'TabContentsScroll' | 'TabCount' | 'TabCountBadge' | 'TabHeaderRowWrapper' | 'TabIcon' | 'TabRow' | 'TabRowSpacer' | 'TabRowTabs' | 'TabTitle' | 'TabsRowScroll' | 'contentPadding' | 'duration-app-launch' | 'headerHeight', string>;
+type GamepadContextMenuClasses = Record<'Arrow' | 'BackgroundAnimation' | 'BasicContextMenuContainer' | 'BasicContextMenuHeader' | 'BasicContextMenuHeaderShrinkableSpacing' | 'BasicContextMenuModal' | 'Capitalized' | 'ContextMenuSeparator' | 'Destructive' | 'Emphasis' | 'Focused' | 'ItemFocusAnim-darkGrey' | 'ItemFocusAnim-darkerGrey' | 'ItemFocusAnim-darkerGrey-nocolor' | 'ItemFocusAnim-green' | 'ItemFocusAnim-grey' | 'ItemFocusAnim-translucent-white-10' | 'ItemFocusAnim-translucent-white-20' | 'ItemFocusAnimBorder-darkGrey' | 'Label' | 'MenuSectionHeader' | 'Positive' | 'Selected' | 'SubMenu' | 'UpperCase' | 'active' | 'contextMenu' | 'contextMenuContents' | 'contextMenuFade' | 'contextMenuItem' | 'duration-app-launch' | 'focusAnimation' | 'hasSubMenu' | 'hoverAnimation' | 'slideInAnimation', string>;
+type AchievementListClasses = Record<'AchievementContent' | 'AchievementDescription' | 'AchievementGlobalPercentage' | 'AchievementList' | 'AchievementListItemBase' | 'AchievementTitle' | 'AlignEnd' | 'Avatar' | 'AvatarContainer' | 'ComparisonAchieverColumn' | 'ComparisonAchieverInfo' | 'Container' | 'Content' | 'Description' | 'Footer' | 'FriendAchievementFooter' | 'GlobalAchievementListItem' | 'GlobalAchievementsListHeader' | 'GlobalPercentage' | 'HeaderText' | 'Hidden' | 'HiddenAchievementContent' | 'ImageContainer' | 'InBody' | 'Info' | 'ListTitle' | 'Percent' | 'ProgressBar' | 'ProgressContainer' | 'ProgressCount' | 'ProgressFill' | 'ProgressLabel' | 'Right' | 'SearchField' | 'Secondary' | 'SpoilerWarning' | 'Title' | 'Unachieved' | 'UnlockContainer' | 'UnlockDate' | 'UserUnlockDateTime' | 'VerticalContent' | 'duration-app-launch' | 'nAchievementGap' | 'nAchievementHeight' | 'nAchievementsListTitleHeight' | 'nGlobalAchievementHeight', string>;
+type AchievementPageClasses = Record<'AchievementContent' | 'AchievementDescription' | 'AchievementGlobalPercentage' | 'AchievementList' | 'AchievementListItemBase' | 'AchievementTabs' | 'AchievementTitle' | 'AlignEnd' | 'Avatar' | 'AvatarContainer' | 'Background' | 'Blur' | 'CompareButtonContainer' | 'ComparisonAchieverColumn' | 'ComparisonAchieverInfo' | 'Container' | 'Content' | 'Description' | 'DragHandle' | 'ErrorButtons' | 'ErrorContainer' | 'ErrorTitle' | 'Footer' | 'FriendAchievementFooter' | 'FriendAchievementsListHeader' | 'GlobalAchievementListItem' | 'GlobalAchievementsListHeader' | 'GlobalButton' | 'GlobalPercentage' | 'HeaderContainer' | 'HeaderImage' | 'HeaderText' | 'Hidden' | 'HiddenAchievementContent' | 'ImageContainer' | 'InBody' | 'Info' | 'Label' | 'List' | 'ListTitle' | 'LoadingContainer' | 'MyAchievementsHeader' | 'Nav' | 'NotOwnedMessage' | 'Page' | 'Percent' | 'PerfectGame' | 'PinnedView' | 'PinnedViewTabs' | 'ProgressBar' | 'ProgressContainer' | 'ProgressCount' | 'ProgressFill' | 'ProgressLabel' | 'Right' | 'SearchField' | 'Secondary' | 'SortableAchievementsList' | 'SortableUserAchievement' | 'SortableUserAchievementInner' | 'SpoilerWarning' | 'Text' | 'Throbber' | 'Title' | 'ToggleContainer' | 'Unachieved' | 'UnlockContainer' | 'UnlockDate' | 'UserContext' | 'UserUnlockDateTime' | 'VerticalContent' | 'duration-app-launch' | 'headerPadding' | 'nAchievementGap' | 'nAchievementHeight' | 'nAchievementsListTitleHeight' | 'nGlobalAchievementHeight', string>;
+type MainMenuAppRunningClasses = Record<'Active' | 'ActiveContent' | 'ActiveDot' | 'AppColumn' | 'AppColumnContent' | 'AppRunningControls' | 'BackgroundAnimation' | 'Collapsible' | 'Container' | 'ControllerColumnFocused' | 'CurrentGameBackground' | 'CurrentGameLogo' | 'Disabled' | 'FocusedColumn' | 'HideMask' | 'ItemFocusAnim-darkGrey' | 'ItemFocusAnim-darkerGrey' | 'ItemFocusAnim-darkerGrey-nocolor' | 'ItemFocusAnim-green' | 'ItemFocusAnim-grey' | 'ItemFocusAnim-translucent-white-10' | 'ItemFocusAnim-translucent-white-20' | 'ItemFocusAnimBorder-darkGrey' | 'KeyBoardVisible' | 'NavColumnFocused' | 'NavigationBox' | 'NavigationColumn' | 'NavigationMenuItem' | 'NavigationMenuItemSeparator' | 'OverlayAchievements' | 'OverlayGuides' | 'OverlayInplaceBrowser' | 'OverlayNotes' | 'ScrollMask' | 'SelectableAppWindow' | 'SwitchAppsTitle' | 'Visible' | 'duration-app-launch' | 'focusAnimation' | 'hoverAnimation', string>;
+type BasicAppDetailsSectionStylerClasses = Record<'ActionButtonAndStatusPanel' | 'ActionRow' | 'AppActionButton' | 'AppButtons' | 'AppDetailSectionList' | 'AppDetailsContainer' | 'AppDetailsContent' | 'AppDetailsRoot' | 'CollectionsHeader' | 'DeckVerifiedFeedbackButton' | 'DeckVerifiedFeedbackConfirmation' | 'DeckVerifiedFeedbackConfirmationContainer' | 'DeckVerifiedFeedbackContainer' | 'DeckVerifiedFeedbackQuestion' | 'GameInfoCollections' | 'GameInfoContainer' | 'GameInfoQuickLinks' | 'Header' | 'InvertFocusedIcon' | 'PlaySection' | 'duration-app-launch' | 'headerPadding', string>;
+type SteamSpinnerClasses = Record<'BackgroundAnimation' | 'Black' | 'Container' | 'ContainerBackground' | 'ExtraSpace' | 'ItemFocusAnim-darkGrey' | 'ItemFocusAnim-darkerGrey' | 'ItemFocusAnim-darkerGrey-nocolor' | 'ItemFocusAnim-green' | 'ItemFocusAnim-grey' | 'ItemFocusAnim-translucent-white-10' | 'ItemFocusAnim-translucent-white-20' | 'ItemFocusAnimBorder-darkGrey' | 'LoadingStatus' | 'Medium' | 'Small' | 'Spacer' | 'SpinnerLoaderContainer' | 'focusAnimation' | 'hoverAnimation', string>;
+type FooterClasses = Record<'BackgroundAnimation' | 'BasicFooter' | 'FooterLegend' | 'ItemFocusAnim-darkGrey' | 'ItemFocusAnim-darkerGrey' | 'ItemFocusAnim-darkerGrey-nocolor' | 'ItemFocusAnim-green' | 'ItemFocusAnim-grey' | 'ItemFocusAnim-translucent-white-10' | 'ItemFocusAnim-translucent-white-20' | 'ItemFocusAnimBorder-darkGrey' | 'Opaque' | 'PillShapedIcon' | 'QuickAccessFooter' | 'Relative' | 'Spacer' | 'WithKeyboard' | 'duration-app-launch' | 'focusAnimation' | 'hoverAnimation', string>;
+type AppActionButtonClasses = Record<'BackgroundAnimation' | 'BreakNarrow' | 'BreakShort' | 'BreakTall' | 'BreakUltraWide' | 'BreakWide' | 'ButtonChild' | 'ButtonText' | 'ButtonThrobberPadding' | 'Disabled' | 'ForceShutdownButton' | 'GamepadUIBreakNarrow' | 'GamepadUIBreakShort' | 'GamepadUIBreakWide' | 'Green' | 'ItemFocusAnim-darkGrey' | 'ItemFocusAnim-darkerGrey' | 'ItemFocusAnim-darkerGrey-nocolor' | 'ItemFocusAnim-green' | 'ItemFocusAnim-grey' | 'ItemFocusAnim-translucent-white-10' | 'ItemFocusAnim-translucent-white-20' | 'ItemFocusAnimBorder-darkGrey' | 'LongButton' | 'NoAction' | 'PlayButton' | 'PlayButtonContainer' | 'RightBreakNarrow' | 'RightBreakUltraNarrow' | 'RightBreakUltraWide' | 'RightBreakWide' | 'ShowStreaming' | 'ShowingStreaming' | 'ShutdownAppButton' | 'StreamingCallout' | 'StreamingCalloutMessage' | 'StreamingCalloutMessageContainer' | 'StreamingContextMenuItem' | 'StreamingSelector' | 'Throbber' | 'ThrobberContainer' | 'WaitingForForceShutdown' | 'WaitingForShutdownSpinner' | 'duration-app-launch' | 'focusAnimation' | 'hoverAnimation' | 'rotate', string>;
+type LibraryAssetImageClasses = Record<'Container' | 'GreyBackground' | 'Hidden' | 'Image' | 'LandscapeImage' | 'LongTitles' | 'NoTransitions' | 'PortraitImage' | 'Short' | 'Title' | 'Visibility' | 'Visible' | 'duration-app-launch', string>;
+type GamepadLibraryClasses = Record<'AppGridFilterHeader' | 'AppGridFilterHeaderAsButton' | 'AppGridFilterText' | 'BackgroundAnimation' | 'BreakNarrow' | 'BreakShort' | 'BreakTall' | 'BreakUltraWide' | 'BreakWide' | 'CollectionContents' | 'CollectionHeader' | 'ComingSoon' | 'GamepadLibrary' | 'GamepadUIBreakNarrow' | 'GamepadUIBreakShort' | 'GamepadUIBreakWide' | 'ItemFocusAnim-darkGrey' | 'ItemFocusAnim-darkerGrey' | 'ItemFocusAnim-darkerGrey-nocolor' | 'ItemFocusAnim-green' | 'ItemFocusAnim-grey' | 'ItemFocusAnim-translucent-white-10' | 'ItemFocusAnim-translucent-white-20' | 'ItemFocusAnimBorder-darkGrey' | 'RightBreakNarrow' | 'RightBreakUltraNarrow' | 'RightBreakUltraWide' | 'RightBreakWide' | 'duration-app-launch' | 'focusAnimation' | 'hoverAnimation', string>;
+type FocusRingClasses = Record<'DebugFocusRing' | 'FocusRing' | 'FocusRingOnHiddenItem' | 'FocusRingRoot' | 'blinker' | 'fadeOutline' | 'flash' | 'growOutline', string>;
+type SearchBarClasses = Record<'BackgroundAnimation' | 'ForceExpanded' | 'IconMovesOnHover' | 'ItemFocusAnim-darkGrey' | 'ItemFocusAnim-darkerGrey' | 'ItemFocusAnim-darkerGrey-nocolor' | 'ItemFocusAnim-green' | 'ItemFocusAnim-grey' | 'ItemFocusAnim-translucent-white-10' | 'ItemFocusAnim-translucent-white-20' | 'ItemFocusAnimBorder-darkGrey' | 'SearchAndTitleContainer' | 'SearchBox' | 'SearchFieldBackground' | 'SearchIconLeft' | 'SearchIconRight' | 'ShowingSearch' | 'ShowingTitle' | 'VR' | 'Visible' | 'WhiteBackground' | 'duration-app-launch', string>;
+type MainBrowserClasses = Record<'Browser' | 'BrowserContainer' | 'BrowserNavRoot' | 'Disabled' | 'ExternalBrowserContainer' | 'InputSupportLevel' | 'MainBrowser' | 'MainBrowserContainer' | 'MicroTxnContainer' | 'NavigationButton' | 'RequireTouchscreenLabel' | 'StatusIcon' | 'Toggled' | 'URL' | 'URLBar' | 'URLInput' | 'Visible' | 'duration-app-launch' | 'showSupportLevel', string>;
+export declare const quickAccessMenuClasses: QuickAccessMenuClasses;
+export declare const scrollPanelClasses: ScrollPanelClasses;
+export declare const gamepadDialogClasses: GamepadDialogClasses;
+export declare const quickAccessControlsClasses: QuickAccessControlsClasses;
+export declare const updaterFieldClasses: UpdaterFieldClasses;
+export declare const playSectionClasses: PlaySectionClasses;
+export declare const gamepadSliderClasses: GamepadSliderClasses;
+export declare const appDetailsHeaderClasses: AppDetailsHeaderClasses;
+export declare const appDetailsClasses: AppDetailsClasses;
+export declare const gamepadUIClasses: GamepadUIClasses;
+export declare const gamepadTabbedPageClasses: GamepadTabbedPageClasses;
+export declare const gamepadContextMenuClasses: GamepadContextMenuClasses;
+export declare const achievementListClasses: AchievementListClasses;
+export declare const achievementPageClasses: AchievementPageClasses;
+export declare const mainMenuAppRunningClasses: MainMenuAppRunningClasses;
+export declare const basicAppDetailsSectionStylerClasses: BasicAppDetailsSectionStylerClasses;
+export declare const steamSpinnerClasses: SteamSpinnerClasses;
+export declare const footerClasses: FooterClasses;
+export declare const appActionButtonClasses: AppActionButtonClasses;
+export declare const libraryAssetImageClasses: LibraryAssetImageClasses;
+export declare const gamepadLibraryClasses: GamepadLibraryClasses;
+export declare const focusRingClasses: FocusRingClasses;
+export declare const searchBarClasses: SearchBarClasses;
+export declare const mainBrowserClasses: MainBrowserClasses;
+export declare const staticClasses: QuickAccessMenuClasses;
+export declare const scrollClasses: ScrollPanelClasses;
+export declare const achievementClasses: AchievementListClasses;
+export {};

package/dist/utils/static-classes.js

@@ -0,0 +1,28 @@
+import { findClassModule } from '../class-mapper';
+export const quickAccessMenuClasses = findClassModule((m) => m.Title && m.QuickAccessMenu && m.BatteryDetailsLabels);
+export const scrollPanelClasses = findClassModule((m) => m.ScrollPanel);
+export const gamepadDialogClasses = findClassModule((m) => m.GamepadDialogContent && !m.BindingButtons);
+export const quickAccessControlsClasses = findClassModule((m) => m.BatteryPercentageLabel && m.PanelSection && !m['vr-dashboard-bar-height'] && !m.QuickAccessMenu && !m.QuickAccess && !m.PerfProfileInfo);
+export const updaterFieldClasses = findClassModule((m) => m.OOBEUpdateStatusContainer);
+export const playSectionClasses = findClassModule((m) => m.PlayBarDetailLabel);
+export const gamepadSliderClasses = findClassModule((m) => m.SliderControlPanelGroup);
+export const appDetailsHeaderClasses = findClassModule((m) => m.TopCapsule);
+export const appDetailsClasses = findClassModule((m) => m.HeaderLoaded);
+export const gamepadUIClasses = findClassModule((m) => m.BasicUiRoot);
+export const gamepadTabbedPageClasses = findClassModule((m) => m.GamepadTabbedPage);
+export const gamepadContextMenuClasses = findClassModule((m) => m.BasicContextMenuModal);
+export const achievementListClasses = findClassModule((m) => m.AchievementListItemBase && !m.Page);
+export const achievementPageClasses = findClassModule((m) => m.AchievementListItemBase && m.Page);
+export const mainMenuAppRunningClasses = findClassModule((m) => m.AppRunningControls && m.OverlayAchievements);
+export const basicAppDetailsSectionStylerClasses = findClassModule((m) => m.AppDetailsRoot);
+export const steamSpinnerClasses = findClassModule(m => m.SpinnerLoaderContainer);
+export const footerClasses = findClassModule(m => m.QuickAccessFooter);
+export const appActionButtonClasses = findClassModule(m => m.PlayButtonContainer);
+export const libraryAssetImageClasses = findClassModule(m => m.LongTitles && m.GreyBackground);
+export const gamepadLibraryClasses = findClassModule(m => m.GamepadLibrary);
+export const focusRingClasses = findClassModule(m => m.FocusRingRoot);
+export const searchBarClasses = findClassModule(m => m.SearchAndTitleContainer);
+export const mainBrowserClasses = findClassModule(m => m.MainBrowserContainer);
+export const staticClasses = quickAccessMenuClasses;
+export const scrollClasses = scrollPanelClasses;
+export const achievementClasses = achievementListClasses;

package/dist/webpack.d.ts

@@ -0,0 +1,21 @@
+declare global {
+    interface Window {
+        webpackChunksteamui: any;
+    }
+}
+export type Module = any;
+export type Export = any;
+type FilterFn = (module: any) => boolean;
+type ExportFilterFn = (moduleExport: any, exportName?: any) => boolean;
+type FindFn = (module: any) => any;
+export declare let modules: any;
+export declare const findModule: (filter: FilterFn) => any;
+export declare const findModuleDetailsByExport: (filter: ExportFilterFn, minExports?: number) => [module: Module | undefined, moduleExport: any, exportName: any];
+export declare const findModuleByExport: (filter: ExportFilterFn, minExports?: number) => any;
+export declare const findModuleExport: (filter: ExportFilterFn, minExports?: number) => any;
+export declare const findModuleChild: (filter: FindFn) => any;
+export declare const findAllModules: (filter: FilterFn) => any[];
+export declare const CommonUIModule: any;
+export declare const IconsModule: any;
+export declare const ReactRouter: any;
+export {};

package/dist/webpack.js

@@ -0,0 +1,102 @@
+import Logger from './logger';
+const logger = new Logger('Webpack');
+export let modules = [];
+function initModuleCache() {
+    const startTime = performance.now();
+    logger.group('Webpack Module Init');
+    const id = Math.random();
+    let webpackRequire;
+    window.webpackChunksteamui.push([
+        [id],
+        {},
+        (r) => {
+            webpackRequire = r;
+        },
+    ]);
+    logger.log('Initializing all modules. Errors here likely do not matter, as they are usually just failing module side effects.');
+    for (let i of Object.keys(webpackRequire.m)) {
+        try {
+            const module = webpackRequire(i);
+            if (module) {
+                modules.push(module);
+            }
+        }
+        catch (e) {
+            logger.debug('Ignoring require error for module', i, e);
+        }
+    }
+    logger.groupEnd(`Modules initialized in ${performance.now() - startTime}ms...`);
+}
+initModuleCache();
+export const findModule = (filter) => {
+    for (const m of modules) {
+        if (m.default && filter(m.default))
+            return m.default;
+        if (filter(m))
+            return m;
+    }
+};
+export const findModuleDetailsByExport = (filter, minExports) => {
+    for (const m of modules) {
+        if (!m)
+            continue;
+        for (const mod of [m.default, m]) {
+            if (typeof mod !== 'object')
+                continue;
+            if (minExports && Object.keys(mod).length < minExports)
+                continue;
+            for (let exportName in mod) {
+                if (mod?.[exportName]) {
+                    const filterRes = filter(mod[exportName], exportName);
+                    if (filterRes) {
+                        return [mod, mod[exportName], exportName];
+                    }
+                    else {
+                        continue;
+                    }
+                }
+            }
+        }
+    }
+    return [undefined, undefined, undefined];
+};
+export const findModuleByExport = (filter, minExports) => {
+    return findModuleDetailsByExport(filter, minExports)?.[0];
+};
+export const findModuleExport = (filter, minExports) => {
+    return findModuleDetailsByExport(filter, minExports)?.[1];
+};
+export const findModuleChild = (filter) => {
+    for (const m of modules) {
+        for (const mod of [m.default, m]) {
+            const filterRes = filter(mod);
+            if (filterRes) {
+                return filterRes;
+            }
+            else {
+                continue;
+            }
+        }
+    }
+};
+export const findAllModules = (filter) => {
+    const out = [];
+    for (const m of modules) {
+        if (m.default && filter(m.default))
+            out.push(m.default);
+        if (filter(m))
+            out.push(m);
+    }
+    return out;
+};
+export const CommonUIModule = modules.find((m) => {
+    if (typeof m !== 'object')
+        return false;
+    for (let prop in m) {
+        if (m[prop]?.contextType?._currentValue && Object.keys(m).length > 60)
+            return true;
+    }
+    return false;
+});
+export const IconsModule = findModuleByExport((e) => e?.toString && /Spinner\)}\),.\.createElement\(\"path\",{d:\"M18 /.test(e.toString()));
+export const ReactRouter = findModuleByExport((e) => e.computeRootMatch);