@spicetify/kit 0.3.1 → 0.4.1

package/vendor/stdlib/src/client.ts

@@ -30,18 +30,106 @@ export interface DaemonCapabilities {
 	apply(): Promise<unknown>;
 	blockUpdates(): Promise<unknown>;
 	unblockUpdates(): Promise<unknown>;
+	updateAndApplySupported?(): Promise<boolean | null>;
+	updateAndApply?: UpdateAndApplyCapability;
+	managedSpotify?: ManagedSpotifyCapability;
+}
+
+export type ManagedSpotifyJob =
+	| { kind: "idle" }
+	| { kind: "running"; jobId: string; phase: "checking" | "downloading" | "preparing" | "activating" }
+	| { kind: "complete"; jobId: string }
+	| { kind: "failed"; jobId: string; message: string };
+
+export type ManagedSpotifyInstallation =
+	| { kind: "external" }
+	| { kind: "unavailable"; message: string }
+	| { kind: "managed"; version: string; channel: "stable" | "testing"; nativeBlocked: boolean | null };
+
+export type ManagedSpotifyAvailability =
+	| { kind: "current"; version: string }
+	| { kind: "ready"; version: string }
+	| { kind: "unavailable"; version: string; message: string };
+
+export interface ManagedSpotifySnapshot {
+	installation: ManagedSpotifyInstallation;
+	job: ManagedSpotifyJob;
+}
+
+export interface ManagedSpotifyCapability {
+	status(): Promise<ManagedSpotifySnapshot | null>;
+	check(): Promise<ManagedSpotifyAvailability>;
+	update(): Promise<UpdateAdmission>;
+}
+
+export type UpdateFailureCode =
+	| "unsupported-platform"
+	| "unsupported-target"
+	| "update-unavailable"
+	| "renderer-timeout"
+	| "spotify-update-failed"
+	| "apply-failed";
+
+export type UpdateAndApplyStatus =
+	| { kind: "idle" }
+	| { kind: "accepted"; jobId: string; fromVersion: string }
+	| { kind: "waiting-for-update"; jobId: string; fromVersion: string }
+	| { kind: "downloading"; jobId: string; targetVersion: string }
+	| { kind: "installing-spotify"; jobId: string; targetVersion: string }
+	| { kind: "applying-spicetify"; jobId: string; targetVersion: string }
+	| { kind: "securing"; jobId: string; targetVersion?: string; message?: string; manualRecovery?: boolean }
+	| { kind: "complete"; jobId: string; fromVersion: string; toVersion: string }
+	| { kind: "failed-safe"; jobId: string; code: UpdateFailureCode; message: string };
+
+export interface UpdateAdmission {
+	jobId: string;
+	disposition: "accepted" | "joined";
+}
+
+export interface UpdateAndApplyCapability {
+	(): Promise<UpdateAdmission>;
+	observe(listener: (status: UpdateAndApplyStatus) => void): () => void;
 }
 
 export interface SnackbarCapabilities {
 	enqueueSnackbar(message: string, options?: { variant?: string }): unknown;
 }
 
+type CosmosBody = Record<string, unknown>;
+type CosmosHeaders = Spicetify.CosmosAsync.Headers;
+type CosmosMethod = Spicetify.CosmosAsync.Method;
+type CosmosResponse = Omit<Spicetify.CosmosAsync.Response, "body"> & { body: unknown };
+
+export interface CosmosCapabilities {
+	head(url: string, headers?: CosmosHeaders): Promise<CosmosHeaders>;
+	get(url: string, body?: CosmosBody, headers?: CosmosHeaders): Promise<unknown>;
+	post(url: string, body?: CosmosBody, headers?: CosmosHeaders): Promise<unknown>;
+	put(url: string, body?: CosmosBody, headers?: CosmosHeaders): Promise<unknown>;
+	del(url: string, body?: CosmosBody, headers?: CosmosHeaders): Promise<unknown>;
+	patch(url: string, body?: CosmosBody, headers?: CosmosHeaders): Promise<unknown>;
+	sub(
+		url: string,
+		callback: (body: unknown) => void,
+		onError?: (error: unknown) => void,
+		body?: CosmosBody,
+		headers?: CosmosHeaders,
+	): Promise<unknown>;
+	postSub(
+		url: string,
+		body: CosmosBody | null,
+		callback: (body: unknown) => void,
+		onError?: (error: unknown) => void,
+	): Promise<unknown>;
+	request(method: CosmosMethod, url: string, body?: CosmosBody, headers?: CosmosHeaders): Promise<CosmosResponse>;
+	resolve(method: CosmosMethod, url: string, body?: CosmosBody, headers?: CosmosHeaders): Promise<CosmosResponse>;
+}
+
 export interface ClientCapabilities {
 	readonly player: typeof Spicetify.Player;
 	readonly platform: typeof Spicetify.Platform;
 	readonly storage: typeof Spicetify.LocalStorage;
 	readonly uri: typeof Spicetify.URI;
-	readonly cosmos: typeof Spicetify.CosmosAsync;
+	readonly cosmos: CosmosCapabilities;
 	readonly corsProxy: typeof Spicetify.CORSProxy;
 	readonly graphQL: typeof Spicetify.GraphQL;
 	readonly locale: typeof Spicetify.Locale;

package/vendor/stdlib/src/events.mix.ts

@@ -21,6 +21,15 @@ function createGlobalThisShadow() {
 
 type CosmosRequest = { uri: string; method: string; body: string };
 
+declare global {
+	var sendCosmosRequest: (request: {
+		request: string;
+		persistent?: boolean;
+		onSuccess?: (response: string) => void;
+		onFailure?: (error: unknown) => void;
+	}) => unknown;
+}
+
 const CosmosRequestSubject = new Subject<CosmosRequest>();
 export const UpdateTitlebarSubject = new BehaviorSubject<number>(-1);
 

package/vendor/stdlib/src/events.ts

@@ -41,7 +41,7 @@ const playerListener = ({ data: state }: any) => {
 	cachedState = state;
 };
 
-const historyListener = (location) => EventBus.History.updated.next(location);
+const historyListener = (location: unknown) => EventBus.History.updated.next(location);
 
 const updateTitlebarListener = (height: number) => EventBus.ControlMessage.titlebar_updated.next(height);
 

package/vendor/stdlib/src/registers/menu-order.ts

@@ -0,0 +1,17 @@
+/*
+ * Copyright (C) 2026 Afonso Jorge Ramos
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+export const placeMenuItemsHost = (menu: Element, host: HTMLElement): void => {
+	const settingsRow = Array.from(menu.children).find(
+		(child) => child.matches('a[href="/preferences"]') || child.querySelector('a[href="/preferences"]'),
+	);
+
+	if (settingsRow) {
+		if (settingsRow.nextElementSibling !== host) settingsRow.after(host);
+		return;
+	}
+
+	if (host.parentElement !== menu) menu.append(host);
+};

package/vendor/stdlib/src/registers/menu.ts

@@ -9,6 +9,7 @@ import { matchLast } from "../util.ts";
 
 import { warn } from "../logger.ts";
 import { transformer } from "../../mixin.ts";
+import { placeMenuItemsHost } from "./menu-order.ts";
 import { Registry } from "./registry.ts";
 
 type __MenuContext = React.Context<MenuContext>;
@@ -125,14 +126,17 @@ if (
 		);
 
 		const ItemBoundary = createItemBoundary(R, "menu");
-		const live: Array<{ menu: Element; root: { unmount: () => void } }> = [];
+		const live: Array<{ menu: Element; host: HTMLElement; root: { unmount: () => void } }> = [];
 		const processed = new WeakSet<Element>();
 
-		const sweep = () => {
+		const sweep = (records: MutationRecord[] = []) => {
+			const changedMenus = new Set(records.map((record) => record.target));
 			for (let i = live.length - 1; i >= 0; i--) {
 				if (!live[i].menu.isConnected) {
 					live[i].root.unmount();
 					live.splice(i, 1);
+				} else if (changedMenus.has(live[i].menu)) {
+					placeMenuItemsHost(live[i].menu, live[i].host);
 				}
 			}
 			if (items.size === 0) return;
@@ -142,7 +146,7 @@ if (
 				const host = document.createElement("li");
 				host.setAttribute("role", "presentation");
 				host.className = "spicetify-menu-items";
-				menu.appendChild(host);
+				placeMenuItemsHost(menu, host);
 				const root = createRoot(host);
 				globalThis.__MenuContext ??= R.createContext(null);
 				root.render(
@@ -152,7 +156,7 @@ if (
 						...items.all().map((item, i) => R.createElement(ItemBoundary, { key: i }, item)),
 					),
 				);
-				live.push({ menu, root });
+				live.push({ menu, host, root });
 			}
 		};
 		new MutationObserver(sweep).observe(document.body, { childList: true, subtree: true });

package/vendor/stdlib/src/registers/mount.ts

@@ -143,10 +143,10 @@ const ensureAnchorStyle = () => {
 // constantly, and per-anchor subtree observers multiply that cost. Each
 // tick is one isConnected check per pending or placed anchor.
 type WatchedAnchor = { host: HTMLElement; place: () => boolean; started: boolean; start: () => void };
-const watched: WatchedAnchor[] = [];
+const watched = new Set<WatchedAnchor>();
 let bodyObserver: MutationObserver | undefined;
 const watchAnchor = (anchor: WatchedAnchor) => {
-	watched.push(anchor);
+	watched.add(anchor);
 	bodyObserver ??= (() => {
 		const observer = new MutationObserver(() => {
 			for (const a of watched) {
@@ -160,6 +160,13 @@ const watchAnchor = (anchor: WatchedAnchor) => {
 		observer.observe(document.body, { childList: true, subtree: true });
 		return observer;
 	})();
+	return () => {
+		watched.delete(anchor);
+		if (watched.size === 0) {
+			bodyObserver?.disconnect();
+			bodyObserver = undefined;
+		}
+	};
 };
 
 export function mountRegistryAnchor(spec: AnchorSpec): void {
@@ -192,6 +199,8 @@ export function mountRegistryAnchor(spec: AnchorSpec): void {
 		const start = () => {
 			const root = createRoot(host);
 			const ItemBoundary = createItemBoundary(R, spec.className);
+			const itemKeys = new Map<unknown, number>();
+			let nextItemKey = 0;
 			const Wrapper = () => {
 				const [, refresh] = R.useReducer((n: number) => n + 1, 0);
 				R.useEffect(() => {
@@ -201,12 +210,20 @@ export function mountRegistryAnchor(spec: AnchorSpec): void {
 				if (spec.renderItems) {
 					return R.createElement(ItemBoundary, null, spec.renderItems(spec.registry.all()));
 				}
+				for (const item of itemKeys.keys()) {
+					if (!spec.registry.has(item)) itemKeys.delete(item);
+				}
 				return R.createElement(
 					R.Fragment,
 					null,
-					...byOrder(spec.registry.all()).map((item: unknown, i: number) =>
-						R.createElement(ItemBoundary, { key: i }, item),
-					),
+					...byOrder(spec.registry.all()).map((item: unknown) => {
+						let key = itemKeys.get(item);
+						if (key === undefined) {
+							key = nextItemKey++;
+							itemKeys.set(item, key);
+						}
+						return R.createElement(ItemBoundary, { key }, item);
+					}),
 				);
 			};
 			root.render(R.createElement(Wrapper));
@@ -240,6 +257,8 @@ export interface AdjacentSpec {
 
 export function mountAdjacent(spec: AdjacentSpec): { remove: () => void } {
 	let removed = false;
+	let unwatch: (() => void) | undefined;
+	let retry: ReturnType<typeof setTimeout> | undefined;
 	let root: { render?: (node: unknown) => void; unmount?: () => void } | undefined;
 	const host = document.createElement("span");
 	host.className = spec.className;
@@ -247,6 +266,7 @@ export function mountAdjacent(spec: AdjacentSpec): { remove: () => void } {
 	host.dataset.spicetifyAnchor = "";
 
 	const place = (): boolean => {
+		if (removed) return false;
 		const target = spec.findTarget();
 		if (!target?.parentElement) return false;
 		const before = spec.side === "before" ? target : target.nextSibling;
@@ -255,9 +275,15 @@ export function mountAdjacent(spec: AdjacentSpec): { remove: () => void } {
 	};
 
 	const remove = () => {
+		if (removed) return;
 		removed = true;
-		root?.unmount?.();
-		host.remove();
+		clearTimeout(retry);
+		unwatch?.();
+		try {
+			root?.unmount?.();
+		} finally {
+			host.remove();
+		}
 	};
 
 	// Transform experiments render through injected __renderX() calls, and there
@@ -291,14 +317,14 @@ export function mountAdjacent(spec: AdjacentSpec): { remove: () => void } {
 			if (place()) {
 				start();
 				// Reuse the shared observer for re-placement only (already started).
-				watchAnchor({ host, place, started: true, start: () => {} });
+				unwatch = watchAnchor({ host, place, started: true, start: () => {} });
 				return;
 			}
 			if (Date.now() > deadline) {
 				spec.onGiveUp();
 				return;
 			}
-			setTimeout(attempt, 150);
+			retry = setTimeout(attempt, 150);
 		};
 		attempt();
 	});

package/vendor/stdlib/src/registers/root.ts

@@ -56,7 +56,7 @@ globalThis.__renderRootChildren = () =>
 		return childrenRegistry.all();
 	});
 globalThis.__renderRootProviders = (providers: React.ReactElement[]) => {
-	const MultiProvider = ({ children }) => {
+	const MultiProvider = ({ children }: React.PropsWithChildren) => {
 		const [, refresh] = React.useReducer((n) => n + 1, 0);
 		if (!providersRegistry.refresh.value) {
 			providersRegistry.refresh.resolve(refresh);

package/vendor/stdlib/src/storage.ts

@@ -55,7 +55,7 @@ export function createSyncedStorage(playlistUri: string) {
 	async function getUris(key: string) {
 		assertSmallerSize(encodeURIComponent(key), CHUNK_SIZE, 1, "Can't fit key in a single chunk");
 
-		const { items } = await PlaylistAPI.getContents(playlistUri, {
+		const { items }: { items: Array<{ uri: string }> } = await PlaylistAPI.getContents(playlistUri, {
 			filter: key,
 			limit: 1e9,
 		});

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

@@ -11,6 +11,7 @@ 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";
+import { findPlaylistMenu } from "./playlist-menu.ts";
 
 type SnackbarProviderT = any;
 
@@ -43,16 +44,9 @@ 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",
-);
+Menus.Playlist = findPlaylistMenu(modules, requireExports);
+if (Menus.Playlist === undefined) warn("[stdlib] webpack needle miss: playlist menu component");
 
 export const Cards: any = Object.assign(
 	{

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

@@ -105,7 +105,7 @@ export const from: (uri: ParsableAsURI) => URIClass<any> = findAndExcludeBy("all
 export const fromString: (str: string) => URIClass<any> = findAndExcludeBy("Argument `uri` must be a string.") as any;
 
 is.PlaylistV1OrV2 = (
-	is.Playlist && is.PlaylistV2
+	typeof is.Playlist === "function" && typeof is.PlaylistV2 === "function"
 		? findAndExcludeBy(`${(is.Playlist as Function).name}(e)||${(is.PlaylistV2 as Function).name}(e)`)
 		: undefined
 ) as any;

package/vendor/stdlib/src/webpack/capture-readiness.ts

@@ -3,18 +3,20 @@
  * SPDX-License-Identifier: GPL-3.0-or-later
  */
 
+type TimeoutHandle = ReturnType<typeof setTimeout> | number;
+
 export interface CaptureReadinessOptions {
 	timeoutMs: number;
 	onTimeout?: () => void;
-	scheduleTimeout?: typeof setTimeout;
-	clearScheduledTimeout?: typeof clearTimeout;
+	scheduleTimeout?: (callback: () => void, delay: number) => TimeoutHandle;
+	clearScheduledTimeout?: (timer: TimeoutHandle) => void;
 }
 
 export function createCaptureReadiness(options: CaptureReadinessOptions) {
 	const settled = Promise.withResolvers<void>();
 	let released = false;
 	let analyzed = false;
-	let timer: ReturnType<typeof setTimeout> | undefined;
+	let timer: TimeoutHandle | undefined;
 	const scheduleTimeout = options.scheduleTimeout ?? setTimeout;
 	const clearScheduledTimeout = options.clearScheduledTimeout ?? clearTimeout;
 	const release = () => {

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

@@ -64,6 +64,12 @@ export const analyzeWebpackRequire = (webpackRequire: WebpackRequire) => {
 	};
 };
 
+function resolveChunk(path: string): void {
+	const chunk = (CHUNKS[path] ??= Promise.withResolvers());
+	if (!chunk.resolve) throw new TypeError(`Chunk ${path} has no resolver`);
+	chunk.resolve(undefined);
+}
+
 CHUNKS["/vendor~xpui.js"] ??= Promise.withResolvers();
 CHUNKS["/xpui.js"] ??= Promise.withResolvers();
 Object.assign(CHUNKS, {
@@ -84,7 +90,7 @@ postWebpackRequireHooks.push((wpr: any) => {
 			load(
 				url,
 				(event: unknown) => {
-					(CHUNKS[new URL(url, location.href).pathname] ??= Promise.withResolvers()).resolve(undefined);
+					resolveChunk(new URL(url, location.href).pathname);
 					return done(event);
 				},
 				key,
@@ -98,7 +104,7 @@ postWebpackRequireHooks.push((wpr: any) => {
 		const url = new URL(entry.name, location.href);
 		if (url.pathname === "/vendor~xpui.js" || url.pathname === "/xpui.js") continue;
 		if (url.origin === location.origin && url.pathname.endsWith(".js")) {
-			(CHUNKS[url.pathname] ??= Promise.withResolvers()).resolve(undefined);
+			resolveChunk(url.pathname);
 		}
 	}
 	// Capture can fire while boot is still registering modules (xpui-modules
@@ -115,8 +121,8 @@ postWebpackRequireHooks.push((wpr: any) => {
 		last = count;
 		if (stable >= 3 || ++ticks > 100) {
 			clearInterval(settle);
-			CHUNKS["/vendor~xpui.js"].resolve(undefined);
-			CHUNKS["/xpui.js"].resolve(undefined);
+			resolveChunk("/vendor~xpui.js");
+			resolveChunk("/xpui.js");
 		}
 	}, 100);
 });

package/vendor/stdlib/src/webpack/playlist-menu.ts

@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2026 Spicetify
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+function source(value: unknown): string {
+	return typeof value === "function" ? Function.prototype.toString.call(value) : "";
+}
+
+function hasPlaylistMenuActions(text: string): boolean {
+	return (
+		text.includes("contextmenu.share.copy-playlist-link") &&
+		text.includes("canView") &&
+		text.includes("permissions")
+	);
+}
+
+export function isPlaylistMenuFactory(value: unknown): boolean {
+	return hasPlaylistMenuActions(source(value));
+}
+
+function isMenuComponent(value: unknown): boolean {
+	let render = value;
+	if (typeof render === "object" && render !== null && "$$typeof" in render) {
+		if (render.$$typeof === Symbol.for("react.memo") && "type" in render) render = render.type;
+		else if (render.$$typeof === Symbol.for("react.forward_ref") && "render" in render) render = render.render;
+	}
+	const text = source(render);
+	if (/^async\b/.test(text)) return false;
+	if (hasPlaylistMenuActions(text)) return /\b(?:jsx|jsxs|createElement)\s*\)?\s*\(/.test(text);
+	// Current clients export a thin JSX wrapper around the unexported memo.
+	// Match the whole wrapper, not JSX nested inside a page root.
+	return /^\(?([$\w]+)\)?=>\(0,[$\w]+\.jsx\)\([$\w]+,\{\.\.\.\1\}\)$/.test(text.replace(/\s/g, ""));
+}
+
+/** Match the menu factory, then its renderable export; never a playlist data mapper. */
+export function findPlaylistMenu(
+	modules: Iterable<readonly [PropertyKey, unknown]>,
+	requireModule: (id: PropertyKey) => unknown,
+): unknown {
+	const components = new Set<unknown>();
+	try {
+		for (const [id, factory] of modules) {
+			if (!isPlaylistMenuFactory(factory)) continue;
+			const exports = requireModule(id);
+			if (typeof exports !== "object" || exports === null) continue;
+			for (const value of Object.values(exports)) if (isMenuComponent(value)) components.add(value);
+		}
+	} catch {
+		// An unreadable client export leaves uniqueness unproven; degrade only this menu.
+		return undefined;
+	}
+	return components.size === 1 ? components.values().next().value : undefined;
+}

package/vendor/stdlib/src/wpunpk.mix.ts

@@ -42,7 +42,7 @@ export { Subject, BehaviorSubject };
 
 export const chunkLoadedSubjectPre = new Subject<unknown>();
 export const chunkLoadedSubjectPost = new Subject<unknown>();
-export const moduleLoadedSubject = new Subject<unknown>();
+export const moduleLoadedSubject = new Subject<[string, WebpackModule]>();
 
 const pendingHooks: Array<(wpr: any) => void> = [];
 export const postWebpackRequireHooks = {

package/vendor/classmaps/1020099/classmap-19f856aefd5.json

@@ -1,109 +0,0 @@
-{
-  "main": {
-    "topbar": {
-      "wrapper": "oy96nRTKcIs7wm5K",
-      "left": {
-        "button": {
-          "wrapper": "e-10810-legacy-button e-10810-button-tertiary--icon-only-medium",
-          "icon": {
-            "wrapper": "e-10810-icon e-10810-icon--auto-mirror"
-          }
-        },
-        "button_t": {
-          "wrapper": "e-10810-legacy-button e-10810-button-tertiary--icon-only-medium"
-        }
-      },
-      "right": {
-        "button": {
-          "wrapper": "e-10810-legacy-button e-10810-button-tertiary--condensed-all"
-        },
-        "button_t": {
-          "wrapper": "e-10810-legacy-button e-10810-button-tertiary--condensed-all"
-        },
-        "upgrade_button": {
-          "wrapper": "e-10810-legacy-button e-10810-legacy-button-primary"
-        }
-      }
-    },
-    "playbar": {
-      "widget": {},
-      "controls": {},
-      "buttons": {
-        "button": {
-          "wrapper": "e-10810-legacy-button e-10810-button-tertiary--icon-only-small",
-          "wrapper__active": "e-10810-legacy-button e-10810-legacy-button-primary",
-          "wrapper__indicator": "e-10810-button-primary__inner"
-        }
-      }
-    },
-    "navbar": {
-      "link": {
-        "wrapper": "main-globalNav-navLink",
-        "container": "main-globalNav-navLink",
-        "container__active": "main-globalNav-navLinkActive"
-      }
-    },
-    "global_navbar": {},
-    "sidebar": {},
-    "panel": {}
-  },
-  "tracklist": {
-    "column_header": "e-10810-legacy-list-row__header"
-  },
-  "search_chips": {
-    "wrapper_wrapper": "e-10810-chip-group",
-    "wrapper": "e-10810-chip-group__component",
-    "container": "e-10810-chip-group__component",
-    "chip": "e-10810-legacy-chip"
-  },
-  "modal": {
-    "widget_generator": {
-      "container": "main-embedWidgetGenerator-container",
-      "header": {
-        "container": "main-embedWidgetGenerator-header",
-        "close": "main-embedWidgetGenerator-closeBtn"
-      },
-      "content": {
-        "container": "main-embedWidgetGenerator-content"
-      }
-    },
-    "track_credits": {
-      "container": "main-trackCreditsModalV2-container",
-      "header": {
-        "container": "main-trackCreditsModalV2-header",
-        "close": "main-trackCreditsModalV2-closeBtn"
-      },
-      "content": {
-        "container": "main-trackCreditsModalV2-mainSection"
-      }
-    }
-  },
-  "settings": {
-    "header": {
-      "container": "fEEfljGMIEhhmWVi"
-    },
-    "section": {
-      "container": "nWR7PbHjFXQJiYNL"
-    },
-    "button": {
-      "wrapper": "e-10810-legacy-button e-10810-legacy-button--small e-10810-legacy-button-secondary"
-    },
-    "text_input": "e-10810-form-input e-10810-form-control encore-text-body-medium"
-  },
-  "scrollable_text": {
-    "container": "e-10810-legacy-box e-10810-legacy-box--naked",
-    "wrapper": "e-10810-legacy-box"
-  },
-  "sort_box": {
-    "list": {
-      "button": "x-sortBox-sortDropdown"
-    }
-  },
-  "search_box": {
-    "container": "main-globalNav-searchContainer",
-    "expand_button": "e-10810-legacy-button e-10810-button-tertiary--icon-only-medium main-globalNav-link-icon"
-  },
-  "context_menu": {
-    "menu_item": "main-contextMenu-menuItemButton"
-  }
-}