@spicetify/kit 0.1.0

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

@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+export type ParsableAsURI = any;
+
+export type IsThisURIType<A extends keyof URITypes> = (url: ParsableAsURI) => url is URIClass<A>;
+
+export type URIClass<_A extends keyof URITypes> = any;
+
+export type URITypes = {
+	AD: "ad";
+	ALBUM: "album";
+	GENRE: "genre";
+	QUEUE: "queue";
+	APPLICATION: "application";
+	ARTIST: "artist";
+	ARTIST_TOPLIST: "artist-toplist";
+	ARTIST_CONCERTS: "artist-concerts";
+	AUDIO_FILE: "audiofile";
+	COLLECTION: "collection";
+	COLLECTION_ALBUM: "collection-album";
+	COLLECTION_ARTIST: "collection-artist";
+	COLLECTION_MISSING_ALBUM: "collection-missing-album";
+	COLLECTION_TRACK_LIST: "collectiontracklist";
+	CONCEPT: "concept";
+	CONCERT: "concert";
+	CONTEXT_GROUP: "context-group";
+	CULTURAL_MOMENT: "cultural-moment";
+	DAILY_MIX: "dailymix";
+	EMPTY: "empty";
+	EPISODE: "episode";
+	FACEBOOK: "facebook";
+	FOLDER: "folder";
+	FOLLOWERS: "followers";
+	FOLLOWING: "following";
+	IMAGE: "image";
+	INBOX: "inbox";
+	INTERRUPTION: "interruption";
+	LIBRARY: "library";
+	LIVE: "live";
+	ROOM: "room";
+	EXPRESSION: "expression";
+	LOCAL: "local";
+	LOCAL_TRACK: "local";
+	LOCAL_ALBUM: "local-album";
+	LOCAL_ARTIST: "local-artist";
+	MERCH: "merch";
+	MERCHHUB: "merchhub";
+	MOSAIC: "mosaic";
+	PLAYLIST: "playlist";
+	PLAYLIST_V2: "playlist-v2";
+	PRERELEASE: "prerelease";
+	PROFILE: "profile";
+	PUBLISHED_ROOTLIST: "published-rootlist";
+	RADIO: "radio";
+	ROOTLIST: "rootlist";
+	SEARCH: "search";
+	SHOW: "show";
+	SOCIAL_SESSION: "socialsession";
+	SPECIAL: "special";
+	STARRED: "starred";
+	STATION: "station";
+	TEMP_PLAYLIST: "temp-playlist";
+	TOPLIST: "toplist";
+	TRACK: "track";
+	TRACKSET: "trackset";
+	USER_TOPLIST: "user-toplist";
+	USER_TOP_TRACKS: "user-top-tracks";
+	UNKNOWN: "unknown";
+	VIDEO: "video";
+	MEDIA: "media";
+	QUESTION: "question";
+	POLL: "poll";
+	RESPONSE: "response";
+	COURSE: "course";
+	LESSON: "lesson";
+	CANVAS: "canvas";
+};
+
+export * from "./URI.gen.ts";

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

@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import { toPascalCase } from "../util.ts";
+import { warn } from "../logger.ts";
+import { modules, src } from "./index.ts";
+import { webpackRequire } from "../wpunpk.mix.ts";
+import { IsThisURIType, ParsableAsURI, URIClass, URITypes } from "./URI.ts";
+
+type Is = {
+	Ad: IsThisURIType<any>;
+	Album: IsThisURIType<any>;
+	Application: IsThisURIType<any>;
+	Artist: IsThisURIType<any>;
+	CollectionAlbum: IsThisURIType<any>;
+	CollectionArtist: IsThisURIType<any>;
+	Collection: IsThisURIType<any>;
+	Concert: IsThisURIType<any>;
+	Episode: IsThisURIType<any>;
+	Folder: IsThisURIType<any>;
+	LocalTrack: IsThisURIType<any>;
+	Playlist: IsThisURIType<any>;
+	PlaylistV2: IsThisURIType<any>;
+	PlaylistV1OrV2: IsThisURIType<any>;
+	Profile: IsThisURIType<any>;
+	Radio: IsThisURIType<any>;
+	Show: IsThisURIType<any>;
+	SocialSession: IsThisURIType<any>;
+	Station: IsThisURIType<any>;
+	Track: IsThisURIType<any>;
+};
+
+type Create = {
+	Album: any;
+	Application: any;
+	Artist: any;
+	CollectionAlbum: any;
+	CollectionArtist: any;
+	Collection: any;
+	Concert: any;
+	Episode: any;
+	Folder: any;
+	LocalAlbum: any;
+	LocalArtist: any;
+	PlaylistV2: any;
+	Prerelease: any;
+	Profile: any;
+	Queue: any;
+	Search: any;
+	Show: any;
+	SocialSession: any;
+	Station: any;
+	Track: any;
+	UserToplist: any;
+};
+
+await CHUNKS.xpui.promise;
+
+// Needle misses are version drift, not fatal errors: a miss costs the
+// affected surface member (undefined), never the whole module — a throw
+// here rejects the lazy URI.gen import and used to crash the client.
+const URIModuleHit = modules.find(
+	([id, v]) => src(v).includes("Invalid Spotify URI!") && Object.keys(webpackRequire(id) ?? {}).length > 10,
+);
+if (!URIModuleHit) warn("[stdlib] webpack needle miss: URI module (Invalid Spotify URI!)");
+const URIModule = URIModuleHit ? webpackRequire(URIModuleHit[0]) : {};
+const [_Types, ...vs] = Object.values(URIModule) as [URITypes, ...Function[]];
+export const Types = _Types ?? ({} as URITypes);
+const TypesKeys = Object.keys(Types);
+
+const isTestFn = (fn: Function) => TypesKeys.some((t) => src(fn).includes(`${t}}`));
+const isCreateFn = (fn: Function) => TypesKeys.some((t) => src(fn).includes(`${t},`));
+
+const fnsByType = Object.groupBy(vs, (fn) => (isTestFn(fn) ? "test" : isCreateFn(fn) ? "create" : undefined!));
+export const is: Is = Object.fromEntries(
+	(fnsByType.test ?? []).flatMap((fn) => {
+		const name = src(fn).match(/([\w_\d]{2,})\}/)?.[1];
+		return name ? [[toPascalCase(name), fn]] : [];
+	}),
+) as any;
+export const create: Create = Object.fromEntries(
+	(fnsByType.create ?? []).flatMap((fn) => {
+		const name = src(fn).match(/([\w_\d]{2,})\,/)?.[1];
+		return name ? [[toPascalCase(name), fn]] : [];
+	}),
+) as any;
+const uniqueFns = fnsByType[undefined as unknown as keyof typeof fnsByType] ?? [];
+
+const findAndExcludeBy = (...strings: string[]) => {
+	const i = uniqueFns.findIndex((f) => strings.every((str) => src(f).includes(str)));
+	if (i < 0) {
+		warn("[stdlib] webpack needle miss: URI helper", strings.join(" + "));
+		return undefined;
+	}
+	return uniqueFns.splice(i, 1)[0];
+};
+
+export const isSameIdentity: (a: ParsableAsURI, b: ParsableAsURI) => boolean = findAndExcludeBy("PLAYLIST") as any;
+export const urlEncode: (str: string) => string = findAndExcludeBy(".URI") as any;
+export const idToHex: (str: string) => string = findAndExcludeBy("22===") as any;
+export const hexToId: (str: string) => string = findAndExcludeBy("32===") as any;
+export const from: (uri: ParsableAsURI) => URIClass<any> = findAndExcludeBy("allowedTypes") as any;
+export const fromString: (str: string) => URIClass<any> = findAndExcludeBy("Argument `uri` must be a string.") as any;
+
+is.PlaylistV1OrV2 = (
+	is.Playlist && is.PlaylistV2
+		? findAndExcludeBy(`${(is.Playlist as Function).name}(e)||${(is.PlaylistV2 as Function).name}(e)`)
+		: undefined
+) as any;

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

@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2026 Afonso Jorge Ramos
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+export interface CaptureReadinessOptions {
+	timeoutMs: number;
+	onTimeout?: () => void;
+	scheduleTimeout?: typeof setTimeout;
+	clearScheduledTimeout?: typeof clearTimeout;
+}
+
+export function createCaptureReadiness(options: CaptureReadinessOptions) {
+	const settled = Promise.withResolvers<void>();
+	let released = false;
+	let analyzed = false;
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	const scheduleTimeout = options.scheduleTimeout ?? setTimeout;
+	const clearScheduledTimeout = options.clearScheduledTimeout ?? clearTimeout;
+	const release = () => {
+		if (released) return;
+		released = true;
+		if (timer !== undefined) clearScheduledTimeout(timer);
+		settled.resolve(undefined);
+	};
+
+	return {
+		wait(): Promise<void> {
+			if (!released && timer === undefined) {
+				timer = scheduleTimeout(() => {
+					options.onTimeout?.();
+					release();
+				}, options.timeoutMs);
+			}
+			return settled.promise;
+		},
+		run(work: () => void, onFailure: (error: unknown) => void): void {
+			if (analyzed) return;
+			analyzed = true;
+			try {
+				work();
+			} catch (error) {
+				onFailure(error);
+			} finally {
+				release();
+			}
+		},
+	};
+}

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

@@ -0,0 +1,186 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import { warn } from "../logger.ts";
+import { postWebpackRequireHooks, WebpackModule, WebpackRequire, webpackRequire } from "../wpunpk.mix.ts";
+import { createCaptureReadiness } from "./capture-readiness.ts";
+
+export let modules: Array<[PropertyKey, WebpackModule]>;
+export let exports: Array<Record<string, any>>;
+export let exported: Array<any>;
+
+export let exportedFunctions: Array<any>;
+
+export let exportedReactObjects: Partial<Record<any, any[]>>;
+export let exportedContexts: Array<React.Context<any>>;
+export let exportedForwardRefs: Array<any>;
+export let exportedMemos: React.NamedExoticComponent[];
+
+// Some client exports are functions whose own toString is not callable; they
+// can never match a needle, so they stringify to "".
+export const src = (f: unknown): string => {
+	try {
+		return String(f);
+	} catch {
+		try {
+			return Function.prototype.toString.call(f);
+		} catch {
+			return "";
+		}
+	}
+};
+
+export const analyzeWebpackRequire = (webpackRequire: WebpackRequire) => {
+	const modules = Object.entries(webpackRequire.m) as Array<[keyof any, WebpackModule]>;
+	const exports = modules.map(([id]) => webpackRequire(id)) as Array<Record<string, any>>;
+	const exported = exports
+		.filter((module) => typeof module === "object")
+		.flatMap((module) => {
+			try {
+				return Object.values(module);
+			} catch (_) {}
+		})
+		.filter(Boolean) as Array<any>;
+
+	const isFunction = (obj: any): obj is Function => typeof obj === "function";
+	const exportedFunctions = exported.filter(isFunction) as any[];
+
+	const exportedReactObjects = Object.groupBy(exported, (x) => x.$$typeof);
+	const exportedContexts = exportedReactObjects[Symbol.for("react.context") as any]! as Array<React.Context<any>>;
+	const exportedForwardRefs = exportedReactObjects[Symbol.for("react.forward_ref") as any]! as any[];
+	const exportedMemos = exportedReactObjects[Symbol.for("react.memo") as any]! as React.NamedExoticComponent[];
+
+	return {
+		modules,
+		exports,
+		exported,
+		exportedFunctions,
+		exportedReactObjects,
+		exportedContexts,
+		exportedForwardRefs,
+		exportedMemos,
+	};
+};
+
+CHUNKS["/vendor~xpui.js"] ??= Promise.withResolvers();
+CHUNKS["/xpui.js"] ??= Promise.withResolvers();
+Object.assign(CHUNKS, {
+	xpui: {
+		promise: Promise.all([CHUNKS["/vendor~xpui.js"].promise, CHUNKS["/xpui.js"].promise]) as any,
+	},
+});
+
+// v3 chunk tracking: the 2024 pre-boot mixin that resolved chunk promises is
+// gone. The loader captures __webpack_require__ once the client is up, and
+// the xpui entry chunks live in the V8 snapshot — they have necessarily
+// executed by capture time. Lazy route chunks go through the runtime's own
+// script loader (wpr.l) from then on.
+postWebpackRequireHooks.push((wpr: any) => {
+	if (typeof wpr?.l === "function") {
+		const load = wpr.l.bind(wpr);
+		wpr.l = (url: string, done: (event: unknown) => unknown, key?: string, chunkId?: unknown) =>
+			load(
+				url,
+				(event: unknown) => {
+					(CHUNKS[new URL(url, location.href).pathname] ??= Promise.withResolvers()).resolve(undefined);
+					return done(event);
+				},
+				key,
+				chunkId,
+			);
+	}
+	// Chunk scripts that finished loading before capture. The xpui entry
+	// chunks are deliberately excluded: they are gated below on registry
+	// quiescence, because "script fetched" is not "all modules registered".
+	for (const entry of performance.getEntriesByType("resource")) {
+		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);
+		}
+	}
+	// Capture can fire while boot is still registering modules (xpui-modules
+	// and friends land after the runtime is up, and the analysis needles live
+	// there). The analysis below snapshots wpr.m once, so hold the xpui
+	// promises until the registry has been quiet for a few ticks — with a
+	// hard cap so a pathological boot still resolves.
+	let last = -1;
+	let stable = 0;
+	let ticks = 0;
+	const settle = setInterval(() => {
+		const count = Object.keys(wpr?.m ?? {}).length;
+		stable = count === last ? stable + 1 : 0;
+		last = count;
+		if (stable >= 3 || ++ticks > 100) {
+			clearInterval(settle);
+			CHUNKS["/vendor~xpui.js"].resolve(undefined);
+			CHUNKS["/xpui.js"].resolve(undefined);
+		}
+	}, 100);
+});
+
+// Capture subscribers run synchronously right after the analysis lands, so
+// the expose shims can populate their live bindings from a real capture
+// instead of snapshotting the lazy proxy at module init (which freezes
+// undefined for the whole session when anything evaluates a shim
+// pre-capture — the Fragment/react-shim class of bug).
+let captured = false;
+const captureSubscribers: Array<() => void> = [];
+const webpackCaptureReadiness = createCaptureReadiness({
+	// Registry quiescence caps at about 10.1s. Leave room for its last tick,
+	// then release degraded so a changed runtime cannot deadlock all modules.
+	timeoutMs: 12000,
+	onTimeout: () => warn("[stdlib] capture health: webpack capture timed out; module surfaces will be degraded"),
+});
+
+// Module preload uses this boundary to keep every later module out of the
+// gap between capturing webpack's require function and finishing the export
+// analysis. It settles on failure too: a degraded stdlib must not hang the
+// loader forever.
+export function waitForWebpackCapture(): Promise<void> {
+	return webpackCaptureReadiness.wait();
+}
+
+export function onWebpackCaptured(cb: () => void): void {
+	if (captured) {
+		cb();
+		return;
+	}
+	captureSubscribers.push(cb);
+}
+
+CHUNKS.xpui.promise.then(() => {
+	webpackCaptureReadiness.run(
+		() => {
+			// A single throwing client-module factory must not abort the whole
+			// capture: with no capture, every live binding in the react shims stays
+			// undefined for the session and the failure surfaces as nothing but an
+			// unhandled rejection.
+			const analysis = analyzeWebpackRequire(webpackRequire);
+			modules = analysis.modules;
+			exports = analysis.exports;
+			exported = analysis.exported;
+			exportedFunctions = analysis.exportedFunctions;
+			exportedReactObjects = analysis.exportedReactObjects;
+			exportedContexts = analysis.exportedContexts;
+			exportedForwardRefs = analysis.exportedForwardRefs;
+			exportedMemos = analysis.exportedMemos;
+			captured = true;
+			if (!analysis.exported.length) {
+				warn(
+					"[stdlib] capture health: the webpack capture yielded no exports — every needle-backed surface is degraded",
+				);
+			}
+			for (const cb of captureSubscribers.splice(0)) {
+				try {
+					cb();
+				} catch (e) {
+					console.error("[stdlib] capture subscriber failed:", e);
+				}
+			}
+		},
+		(e) => warn("[stdlib] capture health: webpack capture analysis failed; module surfaces will be degraded:", e),
+	);
+});

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

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

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

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

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

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import { exported, exportedFunctions } from "./index.ts";
+import { findBy } from "../util.ts";
+
+await CHUNKS.xpui.promise;
+
+// The client's own color class; no static types exist for it.
+export type Color = any;
+
+export const Color: Function & {
+	Format: any;
+	[member: string]: any;
+} = Object.assign(findBy("this.rgb")(exportedFunctions)!, {
+	// Typed predicate: some client exports are get-trap proxies that answer
+	// truthy for any key, so "has RGBA" alone can latch onto the wrong one.
+	Format: exported.find((m) => typeof m?.RGBA === "number" && typeof m?.HEX === "number")!,
+});
+
+export const Locale: any = exported.find((m) => typeof m.getTranslations === "function");
+
+export const createUrlLocale: Function = findBy("has", "baseName", "language")(exportedFunctions);
+
+export const InternalPropetyMap: any = exported.find((o) => typeof o.Builder === "function");

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

@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * Copyright (C) 2026 Afonso Jorge Ramos
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+// wpunpk.mix: webpack require access for the v3 modular runtime.
+// The modular loader captures __webpack_require__ itself after the client is
+// up (pre-boot chunk registration is fatal to the snapshot runtime). This
+// module forwards to it lazily and keeps the hooks-era contract intact.
+
+class Subject<T = unknown> {
+	private observers = new Set<(value: T) => void>();
+	subscribe(fn: (value: T) => void) {
+		this.observers.add(fn);
+		return { unsubscribe: () => this.observers.delete(fn) };
+	}
+	next(value: T) {
+		for (const fn of this.observers) fn(value);
+	}
+}
+
+class BehaviorSubject<T> extends Subject<T> {
+	constructor(private current: T) {
+		super();
+	}
+	override subscribe(fn: (value: T) => void) {
+		const sub = super.subscribe(fn);
+		fn(this.current);
+		return sub;
+	}
+	override next(value: T) {
+		this.current = value;
+		super.next(value);
+	}
+	getValue() {
+		return this.current;
+	}
+}
+
+export { Subject, BehaviorSubject };
+
+export const chunkLoadedSubjectPre = new Subject<unknown>();
+export const chunkLoadedSubjectPost = new Subject<unknown>();
+export const moduleLoadedSubject = new Subject<unknown>();
+
+const pendingHooks: Array<(wpr: any) => void> = [];
+export const postWebpackRequireHooks = {
+	push(hook: (wpr: any) => void) {
+		if (typeof globalThis.__webpack_require__ === "function") {
+			try {
+				hook(globalThis.__webpack_require__);
+			} catch (e) {
+				console.error(e);
+			}
+			return 0;
+		}
+		pendingHooks.push(hook);
+		ensureDrainTimer();
+		return pendingHooks.length;
+	},
+};
+
+export type WebpackModule = (module: any, exports: any, require: any) => void;
+
+export type WebpackRequire = {
+	(id: PropertyKey): any;
+	m: Record<string, unknown>;
+};
+
+export const webpackRequire: WebpackRequire = new Proxy(function () {}, {
+	get: (_, k) => globalThis.__webpack_require__?.[k as never] ?? (k === "m" ? {} : undefined),
+	apply: (_, __, args) => (globalThis.__webpack_require__ as any)(...args),
+}) as never;
+
+const drain = () => {
+	if (typeof globalThis.__webpack_require__ !== "function") return false;
+	for (const hook of pendingHooks.splice(0)) {
+		try {
+			hook(globalThis.__webpack_require__);
+		} catch (e) {
+			console.error(e);
+		}
+	}
+	return true;
+};
+// Hooks can be pushed at mixin time (pre-boot) or load time (post-boot),
+// and capture can land arbitrarily late — each pending push (re)arms a
+// bounded poll instead of relying on one module-eval-time window.
+let drainTimer: ReturnType<typeof setInterval> | undefined;
+const ensureDrainTimer = () => {
+	if (drainTimer !== undefined) return;
+	let tries = 0;
+	drainTimer = setInterval(() => {
+		if (drain() || ++tries > 400) {
+			clearInterval(drainTimer);
+			drainTimer = undefined;
+		}
+	}, 50);
+};
+
+declare global {
+	var __webpack_require__: WebpackRequire | undefined;
+}

package/vendor/stdlib/src/wpunpk.ts

@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2024 Delusoire
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+import { moduleLoadedSubject, type WebpackModule, webpackRequire } from "./wpunpk.mix.ts";
+
+type ModuleMatcher = (id: string, module: WebpackModule) => boolean;
+type ModulePair = [keyof any, WebpackModule];
+
+export function matchWebpackModuleSync(moduleMatcher: ModuleMatcher): ModulePair | null {
+	if (webpackRequire) {
+		for (const [id, module] of Object.entries(webpackRequire!.m) as Array<[string, WebpackModule]>) {
+			if (moduleMatcher(id, module)) {
+				return [id, module] as ModulePair;
+			}
+		}
+	}
+
+	return null;
+}
+
+export function matchWebpackModule(moduleMatcher: ModuleMatcher, callback: (...args: ModulePair) => void) {
+	const sync = matchWebpackModuleSync(moduleMatcher);
+	if (sync) {
+		callback(...sync);
+		return;
+	}
+
+	const subscription = moduleLoadedSubject.subscribe(([id, module]) => {
+		if (moduleMatcher(id, module)) {
+			subscription.unsubscribe();
+			callback(id, module);
+		}
+	});
+}

package/vendor/stdlib/vendor/rxjs.d.ts

@@ -0,0 +1,5 @@
+/*
+ * Types for the prebundled vendor/rxjs.js (the rxjs dev dependency
+ * provides them; the bundle carries no declarations of its own).
+ */
+export { BehaviorSubject, Subject, Subscription } from "rxjs";