@spicetify/kit 0.1.0

package/vendor/stdlib/src/webpack/ReactComponents.gen.ts

@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import type * as ReactComponents_desktop_ts from "./ReactComponents.desktop.ts";
+export let Settings: typeof ReactComponents_desktop_ts.Settings;
+import("./ReactComponents.desktop.ts").then(m => {
+	Settings = m.Settings;
+}).catch((e) => console.warn("[stdlib] lazy webpack surface ./ReactComponents.desktop.ts failed:", e));
+
+import type * as ReactComponents_panel_ts from "./ReactComponents.panel.ts";
+export let PanelContainer: typeof ReactComponents_panel_ts.PanelContainer;
+export let PanelContent: typeof ReactComponents_panel_ts.PanelContent;
+export let PanelHeader: typeof ReactComponents_panel_ts.PanelHeader;
+import("./ReactComponents.panel.ts").then(m => {
+	PanelContainer = m.PanelContainer;
+	PanelContent = m.PanelContent;
+	PanelHeader = m.PanelHeader;
+}).catch((e) => console.warn("[stdlib] lazy webpack surface ./ReactComponents.panel.ts failed:", e));
+
+import type * as ReactComponents_xpui_ts from "./ReactComponents.xpui.ts";
+export let Menus: typeof ReactComponents_xpui_ts.Menus;
+export let Cards: typeof ReactComponents_xpui_ts.Cards;
+export let RemoteConfigProviderComponent: typeof ReactComponents_xpui_ts.RemoteConfigProviderComponent;
+export let Nav: typeof ReactComponents_xpui_ts.Nav;
+export let NavTo: typeof ReactComponents_xpui_ts.NavTo;
+export let InstrumentedRedirect: typeof ReactComponents_xpui_ts.InstrumentedRedirect;
+export let SnackbarProvider: typeof ReactComponents_xpui_ts.SnackbarProvider;
+export let ContextMenu: typeof ReactComponents_xpui_ts.ContextMenu;
+export let RightClickMenu: typeof ReactComponents_xpui_ts.RightClickMenu;
+export let Tooltip: typeof ReactComponents_xpui_ts.Tooltip;
+export let Menu: typeof ReactComponents_xpui_ts.Menu;
+export let MenuItem: typeof ReactComponents_xpui_ts.MenuItem;
+export let MenuItemSubMenu: typeof ReactComponents_xpui_ts.MenuItemSubMenu;
+export let RemoteConfigProvider: typeof ReactComponents_xpui_ts.RemoteConfigProvider;
+export let Snackbar: typeof ReactComponents_xpui_ts.Snackbar;
+export let FilterBox: typeof ReactComponents_xpui_ts.FilterBox;
+export let ScrollableContainer: typeof ReactComponents_xpui_ts.ScrollableContainer;
+export let ScrollableText: typeof ReactComponents_xpui_ts.ScrollableText;
+export let Router: typeof ReactComponents_xpui_ts.Router;
+export let Routes: typeof ReactComponents_xpui_ts.Routes;
+export let Route: typeof ReactComponents_xpui_ts.Route;
+export let StoreProvider: typeof ReactComponents_xpui_ts.StoreProvider;
+export let GenericModal: typeof ReactComponents_xpui_ts.GenericModal;
+export let Tracklist: typeof ReactComponents_xpui_ts.Tracklist;
+export let TracklistColumnsContextProvider: typeof ReactComponents_xpui_ts.TracklistColumnsContextProvider;
+import("./ReactComponents.xpui.ts").then(m => {
+	Menus = m.Menus;
+	Cards = m.Cards;
+	RemoteConfigProviderComponent = m.RemoteConfigProviderComponent;
+	Nav = m.Nav;
+	NavTo = m.NavTo;
+	InstrumentedRedirect = m.InstrumentedRedirect;
+	SnackbarProvider = m.SnackbarProvider;
+	ContextMenu = m.ContextMenu;
+	RightClickMenu = m.RightClickMenu;
+	Tooltip = m.Tooltip;
+	Menu = m.Menu;
+	MenuItem = m.MenuItem;
+	MenuItemSubMenu = m.MenuItemSubMenu;
+	RemoteConfigProvider = m.RemoteConfigProvider;
+	Snackbar = m.Snackbar;
+	FilterBox = m.FilterBox;
+	ScrollableContainer = m.ScrollableContainer;
+	ScrollableText = m.ScrollableText;
+	Router = m.Router;
+	Routes = m.Routes;
+	Route = m.Route;
+	StoreProvider = m.StoreProvider;
+	GenericModal = m.GenericModal;
+	Tracklist = m.Tracklist;
+	TracklistColumnsContextProvider = m.TracklistColumnsContextProvider;
+}).catch((e) => console.warn("[stdlib] lazy webpack surface ./ReactComponents.xpui.ts failed:", e));

package/vendor/stdlib/src/webpack/ReactComponents.panel.ts

@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import { analyzeWebpackRequire, src } from "./index.ts";
+import { webpackRequire } from "../wpunpk.mix.ts";
+
+await (CHUNKS["/dwp-panel-section.js"] ??= Promise.withResolvers()).promise;
+
+const { exportedFunctions, exportedForwardRefs } = analyzeWebpackRequire(webpackRequire);
+
+export const PanelContainer: React.FC<any> = exportedFunctions.find((f) =>
+	src(f).includes('"Desktop_PanelContainer_Id"'),
+);
+
+export const PanelContent: React.FC<any> = exportedForwardRefs.find((f) => src(f.render).includes("fixedHeader"));
+
+export const PanelHeader: React.FC<any> = exportedFunctions.find((m) => src(m).includes("PanelHeader_CloseButton"))!;

package/vendor/stdlib/src/webpack/ReactComponents.ts

@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import { webpackRequire } from "../wpunpk.mix.ts";
+import { matchWebpackModule } from "../wpunpk.ts";
+
+export * from "./ReactComponents.gen.ts";
+
+export let Slider: React.FC<any>;
+export let Toggle: React.FC<any>;
+export let TracklistRow: React.FC<any>;
+
+// postWebpackRequireHooks.push($ => {
+matchWebpackModule(
+	(id, module) => {
+		const moduleStr = module.toString();
+		return moduleStr.includes('"data-testid":"progress-bar"');
+	},
+	(id, _$) => {
+		const module = webpackRequire(id);
+		Slider = Object.values<any>(module)[0];
+	},
+);
+
+matchWebpackModule(
+	(id, module) => {
+		const moduleStr = module.toString();
+		return moduleStr.includes('"JWYoNAyrIIdW30u4PSGE"');
+	},
+	(id, _$) => {
+		const module = webpackRequire(id);
+		Toggle = Object.values<any>(module)[0];
+	},
+);
+
+matchWebpackModule(
+	(id, module) => {
+		const moduleStr = module.toString();
+		return moduleStr.includes('"data-testid":"track-icon"');
+	},
+	async (id, _$) => {
+		//! HACKY ALERT (this module depennds on chunks that aren't loaded yet)
+		await new Promise((resolve) => setTimeout(resolve));
+		const module = webpackRequire(id);
+		TracklistRow = Object.values<any>(module)[0];
+	},
+);
+// })

package/vendor/stdlib/src/webpack/ReactComponents.xpui.ts

@@ -0,0 +1,164 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import { findBy, toPascalCase } from "../util.ts";
+
+import { warn } from "../logger.ts";
+
+import { Platform } from "../expose/Platform.ts";
+import { exportedFunctions, exportedMemos, modules, src } from "./index.ts";
+import { webpackRequire } from "../wpunpk.mix.ts";
+import { React } from "../expose/React.ts";
+
+type SnackbarProviderT = any;
+
+await CHUNKS.xpui.promise;
+
+export const Menus: any = Object.fromEntries(
+	exportedMemos.flatMap((m) => {
+		const str = src((m as any).type);
+		const match = str.match(/value:"([\w-]+)"/);
+		const name = match?.[1] ?? "";
+		const type = {
+			album: "Album",
+			show: "PodcastShow",
+			artist: "Artist",
+			track: "Track",
+		}[name];
+		return type ? [[type, m]] : [];
+	}),
+);
+
+// Needle misses are version drift, not fatal errors: a miss costs one
+// surface member (undefined), never the whole stdlib barrel. The warning
+// names the needle so a needle refresh can target it.
+const findModuleId = (needle: string, pred: (source: string) => boolean) => {
+	const hit = modules.find(([, v]) => pred(v.toString()));
+	if (!hit) warn("[stdlib] webpack needle miss:", needle);
+	return hit?.[0];
+};
+const requireExports = (id: ReturnType<typeof findModuleId>): Record<string, any> =>
+	id === undefined ? {} : (webpackRequire(id) as Record<string, any>);
+
+const ContextMenuModuleID = findModuleId("toggleContextMenu", (s) => s.includes("toggleContextMenu"));
+// Dead since 1.2.9x: no module carries value:"playlist" + canView +
+// permissions anymore; Menus.Playlist stays undefined until re-needled.
+const playlistMenuModuleID = findModuleId(
+	'value:"playlist" + canView + permissions',
+	(s) => s.includes('value:"playlist"') && s.includes("canView") && s.includes("permissions"),
+);
+
+Menus.Playlist = Object.values(requireExports(playlistMenuModuleID)).find(
+	(m) => typeof m === "function" || typeof m === "object",
+);
+
+export const Cards: any = Object.assign(
+	{
+		Generic: exportedFunctions.find(
+			(f) =>
+				src(f).includes("OnMouseDown") &&
+				src(f).match(/^[^;]*headerText/) &&
+				src(f).match(/^[^;]*featureIdentifier/) &&
+				src(f).match(/^[^;]*renderCardImage/),
+		),
+		HeroGeneric: findBy("cardPlayButtonFactory", "featureIdentifier", "getSignifierContent")(exportedFunctions),
+		CardImage: findBy('"card-image"')(exportedFunctions),
+	},
+	Object.fromEntries(
+		[
+			exportedFunctions.map((m) => {
+				try {
+					const str = m.toString();
+					const match = str.match(/featureIdentifier:"(.+?)"/);
+					if (!match) return [];
+					const name = match[1];
+					return [[toPascalCase(name), m]];
+				} catch (e) {
+					return [];
+				}
+			}),
+			exportedMemos.map((m) => {
+				try {
+					const str = (m as any).type.toString();
+					const match = str.match(/featureIdentifier:"(.+?)"/);
+					if (!match) return [];
+					const name = match[1];
+					return [[toPascalCase(name), m]];
+				} catch (e) {
+					return [];
+				}
+			}),
+		].flat(2),
+	),
+);
+
+export const RemoteConfigProviderComponent: React.FC<any> = findBy(
+	"resolveSuspense",
+	"configuration",
+)(exportedFunctions);
+
+const exportedMemoFRefs = exportedMemos.filter((m) => (m as any).type.$$typeof === Symbol.for("react.forward_ref"));
+export const Nav: React.NamedExoticComponent<any> = exportedMemoFRefs.find((m) =>
+	src((m as any).type.render).includes("navigationalRoot"),
+)!;
+export const NavTo: React.NamedExoticComponent<any> = exportedMemoFRefs.find((m) =>
+	src((m as any).type.render).includes("pageId"),
+)!;
+
+export const InstrumentedRedirect: React.FC<any> = exportedFunctions.find(
+	(f) => src(f).includes("getInteractionId") && /\bto:/.test(src(f)),
+);
+
+export const SnackbarProvider: SnackbarProviderT = findBy("enqueueSnackbar called with invalid argument")(
+	exportedFunctions,
+) as unknown as SnackbarProviderT;
+
+export const ContextMenu: any = Object.values(requireExports(ContextMenuModuleID))[0];
+export const RightClickMenu: React.FC<any> = findBy("action", "open", "trigger", "right-click")(exportedFunctions);
+
+// export const ConfirmDialog: React.FC<any> = findBy(
+// 	"isOpen",
+// 	"shouldCloseOnEsc",
+// 	"onClose",
+// )(exportedFunctions);
+export const Tooltip: React.FC<any> = findBy("hover-or-focus", "tooltip")(exportedFunctions);
+
+export const Menu: React.FC<any> = findBy("getInitialFocusElement", "children")(exportedFunctions);
+export const MenuItem: React.FC<any> = findBy("handleMouseEnter", "onClick")(exportedFunctions);
+export const MenuItemSubMenu: React.FC<any> = findBy("subMenuIcon")(exportedFunctions);
+
+export const RemoteConfigProvider = ({
+	configuration = Platform.getRemoteConfiguration(),
+	children = undefined as React.ReactNode,
+}) => React.createElement(RemoteConfigProviderComponent, { configuration }, children);
+export const Snackbar = {
+	wrapper: findBy("encore-light-theme", "elevated")(exportedFunctions),
+	simpleLayout: findBy("leading", "center", "trailing")(exportedFunctions),
+	ctaText: findBy("ctaText")(exportedFunctions),
+	styledImage: findBy("placeholderSrc")(exportedFunctions),
+};
+
+export const FilterBox: React.NamedExoticComponent = exportedMemos.find((f) =>
+	src((f as any).type).includes("filterBoxApiRef"),
+)!;
+export const ScrollableContainer: React.FC<any> = findBy("scrollLeft", "showButtons")(exportedFunctions);
+export const ScrollableText: React.FC<any> = findBy("scrollLeft", "pauseAtEndEdgeDurationMs")(exportedFunctions);
+export const Router: React.FC<any> = findBy("navigationType", "static")(exportedFunctions);
+export const Routes: React.FC<any> = findBy(
+	/\([a-zA-Z_\$][\w\$]*\)\{let\{children:[a-zA-Z_\$][\w\$]*,location:[a-zA-Z_\$][\w\$]*\}=[a-zA-Z_\$][\w\$]*/,
+)(exportedFunctions);
+export const Route: React.FC<any> = findBy(
+	/^function [a-zA-Z_\$][\w\$]*\([a-zA-Z_\$][\w\$]*\)\{\(0,[a-zA-Z_\$][\w\$]*\.[a-zA-Z_\$][\w\$]*\)\(\!1\)\}$/,
+)(exportedFunctions);
+export const StoreProvider: React.FC<any> = findBy("notifyNestedSubs", "serverState")(exportedFunctions);
+
+export const GenericModal: React.FC<any> = findBy("isOpen", "contentLabel")(exportedFunctions);
+
+export const Tracklist: React.FC<any> = exportedMemos.find((f) => src((f as any).type).includes("nrValidItems"))!;
+export const TracklistColumnsContextProvider: React.FC<any> = findBy(
+	"columns",
+	"visibleColumns",
+	"toggleVisible",
+)(exportedFunctions);

package/vendor/stdlib/src/webpack/ReactFlipToolkit.gen.ts

@@ -0,0 +1,12 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import type * as ReactFlipToolkit_xpui_ts from "./ReactFlipToolkit.xpui.ts";
+export let Flipper: typeof ReactFlipToolkit_xpui_ts.Flipper;
+export let Flipped: typeof ReactFlipToolkit_xpui_ts.Flipped;
+import("./ReactFlipToolkit.xpui.ts").then(m => {
+	Flipper = m.Flipper;
+	Flipped = m.Flipped;
+}).catch((e) => console.warn("[stdlib] lazy webpack surface ./ReactFlipToolkit.xpui.ts failed:", e));

package/vendor/stdlib/src/webpack/ReactFlipToolkit.ts

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+export * from "./ReactFlipToolkit.gen.ts";

package/vendor/stdlib/src/webpack/ReactFlipToolkit.xpui.ts

@@ -0,0 +1,14 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import { exportedFunctions } from "./index.ts";
+
+type FlippedT = any;
+type FlipperT = any;
+
+await CHUNKS.xpui.promise;
+
+export const Flipper: FlipperT = exportedFunctions.find((m) => m.prototype?.getSnapshotBeforeUpdate)!;
+export const Flipped: FlippedT = exportedFunctions.find((m) => (m as any).displayName === "Flipped")!;

package/vendor/stdlib/src/webpack/ReactHooks.fullscreen.ts

@@ -0,0 +1,15 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import { webpackRequire } from "../wpunpk.mix.ts";
+import { analyzeWebpackRequire, src } from "./index.ts";
+
+await (CHUNKS["/dwp-full-screen-mode-container.js"] ??= Promise.withResolvers()).promise;
+
+const { exportedFunctions } = analyzeWebpackRequire(webpackRequire);
+
+export const useExtractedColor: Function = exportedFunctions.find(
+	(m) => src(m).includes("extracted-color") || (src(m).includes("colorRaw") && src(m).includes("useEffect")),
+)!;

package/vendor/stdlib/src/webpack/ReactHooks.gen.ts

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import type * as ReactHooks_fullscreen_ts from "./ReactHooks.fullscreen.ts";
+export let useExtractedColor: typeof ReactHooks_fullscreen_ts.useExtractedColor;
+import("./ReactHooks.fullscreen.ts").then(m => {
+	useExtractedColor = m.useExtractedColor;
+}).catch((e) => console.warn("[stdlib] lazy webpack surface ./ReactHooks.fullscreen.ts failed:", e));
+
+import type * as ReactHooks_xpui_ts from "./ReactHooks.xpui.ts";
+export let DragHandler: typeof ReactHooks_xpui_ts.DragHandler;
+export let usePanelAPI: typeof ReactHooks_xpui_ts.usePanelAPI;
+export let useContextMenuState: typeof ReactHooks_xpui_ts.useContextMenuState;
+export let imageAnalysis: typeof ReactHooks_xpui_ts.imageAnalysis;
+export let fallbackPreset: typeof ReactHooks_xpui_ts.fallbackPreset;
+export let getPlayContext: typeof ReactHooks_xpui_ts.getPlayContext;
+export let useTrackListColumns: typeof ReactHooks_xpui_ts.useTrackListColumns;
+export let usePanelStateMachine: typeof ReactHooks_xpui_ts.usePanelStateMachine;
+export let extractColorPreset: typeof ReactHooks_xpui_ts.extractColorPreset;
+import("./ReactHooks.xpui.ts").then(m => {
+	DragHandler = m.DragHandler;
+	usePanelAPI = m.usePanelAPI;
+	useContextMenuState = m.useContextMenuState;
+	imageAnalysis = m.imageAnalysis;
+	fallbackPreset = m.fallbackPreset;
+	getPlayContext = m.getPlayContext;
+	useTrackListColumns = m.useTrackListColumns;
+	usePanelStateMachine = m.usePanelStateMachine;
+	extractColorPreset = m.extractColorPreset;
+}).catch((e) => console.warn("[stdlib] lazy webpack surface ./ReactHooks.xpui.ts failed:", e));

package/vendor/stdlib/src/webpack/ReactHooks.ts

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+export * from "./ReactHooks.gen.ts";

package/vendor/stdlib/src/webpack/ReactHooks.xpui.ts

@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import { Platform } from "../expose/Platform.ts";
+import { exported, exportedFunctions } from "./index.ts";
+import { findBy } from "../util.ts";
+
+await CHUNKS.xpui.promise;
+
+export const DragHandler: Function = findBy("dataTransfer", "data-dragging")(exportedFunctions);
+
+export const usePanelAPI: Function = findBy("panelSend", "context")(exportedFunctions);
+
+export const useContextMenuState: Function = findBy("useContextMenuState")(exportedFunctions);
+
+export const imageAnalysis: Function = findBy(/\![a-zA-Z_\$][\w\$]*\.isFallback|\{extractColor/)(exportedFunctions);
+
+export const fallbackPreset: any = exported.find((m) => m.colorDark && Object.hasOwn(m, "colorDark"));
+
+export const getPlayContext: Function = findBy("referrerIdentifier", "usePlayContextItem")(exportedFunctions);
+
+export const useTrackListColumns: Function = findBy("useTrackListColumns")(exportedFunctions);
+
+export const usePanelStateMachine: () => [state: any, actor: any, machine: any] =
+	findBy("usePanelStateMachine")(exportedFunctions);
+
+export const extractColorPreset = async (image: any) => {
+	const analysis = await imageAnalysis(Platform.getGraphQLLoader(), image);
+	// for (const result of analysis) {
+	// 	if (!("isFallback" in result)) {
+	// 		result.isFallback = fallbackPreset === result;
+	// 	}
+	// }
+
+	return analysis;
+};

package/vendor/stdlib/src/webpack/ReactQuery.gen.ts

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import type * as ReactQuery_xpui_ts from "./ReactQuery.xpui.ts";
+export let QueryClient: typeof ReactQuery_xpui_ts.QueryClient;
+export let PersistQueryClientProvider: typeof ReactQuery_xpui_ts.PersistQueryClientProvider;
+export let QueryClientProvider: typeof ReactQuery_xpui_ts.QueryClientProvider;
+export let notifyManager: typeof ReactQuery_xpui_ts.notifyManager;
+export let useMutation: typeof ReactQuery_xpui_ts.useMutation;
+export let useQuery: typeof ReactQuery_xpui_ts.useQuery;
+export let useQueryClient: typeof ReactQuery_xpui_ts.useQueryClient;
+export let useSuspenseQuery: typeof ReactQuery_xpui_ts.useSuspenseQuery;
+export let useInfiniteQuery: typeof ReactQuery_xpui_ts.useInfiniteQuery;
+import("./ReactQuery.xpui.ts").then(m => {
+	QueryClient = m.QueryClient;
+	PersistQueryClientProvider = m.PersistQueryClientProvider;
+	QueryClientProvider = m.QueryClientProvider;
+	notifyManager = m.notifyManager;
+	useMutation = m.useMutation;
+	useQuery = m.useQuery;
+	useQueryClient = m.useQueryClient;
+	useSuspenseQuery = m.useSuspenseQuery;
+	useInfiniteQuery = m.useInfiniteQuery;
+}).catch((e) => console.warn("[stdlib] lazy webpack surface ./ReactQuery.xpui.ts failed:", e));

package/vendor/stdlib/src/webpack/ReactQuery.ts

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+export * from "./ReactQuery.gen.ts";

package/vendor/stdlib/src/webpack/ReactQuery.xpui.ts

@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import { exported, exportedFunctions, modules } from "./index.ts";
+
+import type {
+	notifyManager as notifyManagerT,
+	QueryClient as QueryClientT,
+	QueryClientProvider as QueryClientProviderT,
+	useInfiniteQuery as useInfiniteQueryT,
+	useMutation as useMutationT,
+	useQuery as useQueryT,
+	useQueryClient as useQueryClientT,
+	useSuspenseQuery as useSuspenseQueryT,
+} from "npm:@tanstack/react-query";
+import { findBy } from "../util.ts";
+import { webpackRequire } from "../wpunpk.mix.ts";
+
+await CHUNKS.xpui.promise;
+
+export const QueryClient: typeof QueryClientT = findBy("defaultMutationOptions")(exportedFunctions);
+export const PersistQueryClientProvider = findBy("persistOptions")(exportedFunctions);
+export const QueryClientProvider: typeof QueryClientProviderT = findBy("use QueryClientProvider")(exportedFunctions);
+export const notifyManager: typeof notifyManagerT = exported.find(
+	(m) => typeof m.setBatchNotifyFunction === "function",
+);
+export const useMutation: typeof useMutationT = findBy("mutateAsync")(exportedFunctions);
+export const useQuery: typeof useQueryT = findBy(
+	/^function [a-zA-Z_\$][\w\$]*\(([a-zA-Z_\$][\w\$]*),([a-zA-Z_\$][\w\$]*)\)\{return\(0,[a-zA-Z_\$][\w\$]*\.[a-zA-Z_\$][\w\$]*\)\(\1,[a-zA-Z_\$][\w\$]*\.[a-zA-Z_\$][\w\$]*,\2\)\}$/,
+)(exportedFunctions);
+export const useQueryClient: typeof useQueryClientT = findBy("client", "Provider", "mount")(exportedFunctions);
+export const useSuspenseQuery: typeof useSuspenseQueryT = findBy(
+	"throwOnError",
+	"suspense",
+	"enabled",
+	"placeholderData",
+)(exportedFunctions);
+
+const [infiniteQueryModuleID] = modules.find(
+	([_, v]) => v.toString().includes("fetchPreviousPage") && v.toString().includes("getOptimisticResult"),
+)!;
+export const useInfiniteQuery: typeof useInfiniteQueryT = Object.values(webpackRequire(infiniteQueryModuleID)).find(
+	(m) => typeof m === "function",
+);

package/vendor/stdlib/src/webpack/ReactRouter.gen.ts

@@ -0,0 +1,12 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import type * as ReactRouter_xpui_ts from "./ReactRouter.xpui.ts";
+export let useMatch: typeof ReactRouter_xpui_ts.useMatch;
+export let useLocation: typeof ReactRouter_xpui_ts.useLocation;
+import("./ReactRouter.xpui.ts").then(m => {
+	useMatch = m.useMatch;
+	useLocation = m.useLocation;
+}).catch((e) => console.warn("[stdlib] lazy webpack surface ./ReactRouter.xpui.ts failed:", e));

package/vendor/stdlib/src/webpack/ReactRouter.ts

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+export * from "./ReactRouter.gen.ts";

package/vendor/stdlib/src/webpack/ReactRouter.xpui.ts

@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import { findBy } from "../util.ts";
+import { exportedFunctions, modules, src } from "./index.ts";
+
+import type { useLocation as useLocationT, useMatch as useMatchT } from "npm:react-router";
+import { webpackRequire } from "../wpunpk.mix.ts";
+
+await CHUNKS.xpui.promise;
+
+const [ReactRouterModuleID] = modules.find(([_, v]) => v.toString().includes("React Router"))!;
+const ReactRouterModule = Object.values(webpackRequire(ReactRouterModuleID));
+
+// https://github.com/remix-run/react-router/blob/main/packages/react-router/lib/hooks.tsx#L131
+export const useMatch: typeof useMatchT = ReactRouterModule.find(
+	(f) => src(f).includes("let{pathname:") && !src(f).includes(".createElement("),
+);
+
+export const useLocation: typeof useLocationT = findBy("location", "useContext")(exportedFunctions);

package/vendor/stdlib/src/webpack/Snackbar.gen.ts

@@ -0,0 +1,12 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import type * as Snackbar_xpui_ts from "./Snackbar.xpui.ts";
+export let useSnackbar: typeof Snackbar_xpui_ts.useSnackbar;
+export let enqueueCustomSnackbar: typeof Snackbar_xpui_ts.enqueueCustomSnackbar;
+import("./Snackbar.xpui.ts").then(m => {
+	useSnackbar = m.useSnackbar;
+	enqueueCustomSnackbar = m.enqueueCustomSnackbar;
+}).catch((e) => console.warn("[stdlib] lazy webpack surface ./Snackbar.xpui.ts failed:", e));

package/vendor/stdlib/src/webpack/Snackbar.ts

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+export * from "./Snackbar.gen.ts";

package/vendor/stdlib/src/webpack/Snackbar.xpui.ts

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import { exportedFunctions } from "./index.ts";
+import { findBy } from "../util.ts";
+
+// notistack ships inside the client bundle; these aliases stand in
+// for its types, which cannot be resolved from the npm: URL.
+type EnqueueSnackbarT = (...args: any[]) => any;
+type OptionsObjectT = Record<string, any>;
+type useSnackbarT = () => any;
+
+await CHUNKS.xpui.promise;
+
+export const useSnackbar: useSnackbarT = findBy(
+	/^function\(\)\{return\(0,[a-zA-Z_\$][\w\$]*\.useContext\)\([a-zA-Z_\$][\w\$]*\)\}$/,
+)(exportedFunctions);
+
+type FN_enqueueCustomSnackbar_OPTS =
+	| (Omit<OptionsObjectT, "key"> & { keyPrefix: string })
+	| (OptionsObjectT & { identifier: string });
+export const enqueueCustomSnackbar: (
+	element: React.ReactElement,
+	opts: FN_enqueueCustomSnackbar_OPTS,
+) => ReturnType<EnqueueSnackbarT> = findBy("enqueueCustomSnackbar", "headless")(exportedFunctions);

package/vendor/stdlib/src/webpack/URI.gen.ts

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import type * as URI_xpui_ts from "./URI.xpui.ts";
+export let Types: typeof URI_xpui_ts.Types;
+export let is: typeof URI_xpui_ts.is;
+export let create: typeof URI_xpui_ts.create;
+export let isSameIdentity: typeof URI_xpui_ts.isSameIdentity;
+export let urlEncode: typeof URI_xpui_ts.urlEncode;
+export let idToHex: typeof URI_xpui_ts.idToHex;
+export let hexToId: typeof URI_xpui_ts.hexToId;
+export let from: typeof URI_xpui_ts.from;
+export let fromString: typeof URI_xpui_ts.fromString;
+import("./URI.xpui.ts").then(m => {
+	Types = m.Types;
+	is = m.is;
+	create = m.create;
+	isSameIdentity = m.isSameIdentity;
+	urlEncode = m.urlEncode;
+	idToHex = m.idToHex;
+	hexToId = m.hexToId;
+	from = m.from;
+	fromString = m.fromString;
+}).catch((e) => console.warn("[stdlib] lazy webpack surface ./URI.xpui.ts failed:", e));