youtubei-es6 1.0.0

package/README.md

@@ -0,0 +1,4 @@
+# youtubei-es6
+YouTube extractor from WD-40 bot converted to ES6
+
+https://github.com/iTsMaaT/WD-40/tree/develop/utils/helpers/youtubei

package/getInnertube.js

@@ -0,0 +1,32 @@
+import { Innertube, UniversalCache, Platform } from "youtubei.js";
+
+let ineerTubeInstance = null;
+
+Platform.shim.eval = async (data, env) => {
+    const properties = [];
+
+    if (env.n) properties.push(`n: exportedVars.nFunction("${env.n}")`);
+
+    if (env.sig) properties.push(`sig: exportedVars.sigFunction("${env.sig}")`);
+
+    const code = `${data.output}\nreturn { ${properties.join(", ")} }`;
+
+    return new Function(code)();
+};
+
+/**
+ * Get the Innertube instance
+ * @returns {Promise<Innertube>} The Innertube instance
+ */
+async function getInnertube(cookies) {
+    if (!ineerTubeInstance) {
+        ineerTubeInstance = await Innertube.create({
+            cache: new UniversalCache(false),
+            // player_id: "0004de42",
+            cookie: cookies,
+        });
+    }
+    return ineerTubeInstance;
+}
+
+export { getInnertube };

package/package.json

@@ -0,0 +1,16 @@
+{
+    "name": "youtubei-es6",
+    "version": "1.0.0",
+    "description": "YouTube extractor from WD-40 bot converted to ES6",
+    "main": "youtubeiExtractor.js",
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "author": "",
+    "license": "ISC",
+    "dependencies": {
+        "discord-player": "^7.1.0",
+        "stream": "^0.0.3",
+        "youtubei.js": "^16.0.1"
+    }
+}

package/poTokenGenerator.js

@@ -0,0 +1,315 @@
+import { BG, GOOG_API_KEY, USER_AGENT, buildURL } from "bgutils-js";
+import { JSDOM } from "jsdom";
+import { createCanvas, ImageData as CanvasImageData } from "@napi-rs/canvas";
+
+const REQUEST_KEY = "O43z0dpjhgX20SCx4KAo";
+
+let domWindow;
+let initializationPromise = null;
+let botguardClient;
+let webPoMinter;
+let activeScriptId = null;
+let canvasPatched = false;
+
+function patchCanvasSupport(window) {
+    if (canvasPatched) return;
+
+    const HTMLCanvasElement = window?.HTMLCanvasElement;
+    if (!HTMLCanvasElement) return;
+
+    Object.defineProperty(HTMLCanvasElement.prototype, "_napiCanvasState", {
+        configurable: true,
+        enumerable: false,
+        writable: true,
+        value: null,
+    });
+
+    HTMLCanvasElement.prototype.getContext = function getContext(
+        type,
+        options,
+    ) {
+        if (type !== "2d") return null;
+
+        const width =
+            Number.isFinite(this.width) && this.width > 0 ? this.width : 300;
+        const height =
+            Number.isFinite(this.height) && this.height > 0 ? this.height : 150;
+
+        const state = this._napiCanvasState || {};
+
+        if (!state.canvas) {
+            state.canvas = createCanvas(width, height);
+        } else if (
+            state.canvas.width !== width ||
+            state.canvas.height !== height
+        ) {
+            state.canvas.width = width;
+            state.canvas.height = height;
+        }
+
+        state.context = state.canvas.getContext("2d", options);
+        this._napiCanvasState = state;
+        return state.context;
+    };
+
+    HTMLCanvasElement.prototype.toDataURL = function toDataURL(...args) {
+        if (!this._napiCanvasState?.canvas) {
+            const width =
+                Number.isFinite(this.width) && this.width > 0
+                    ? this.width
+                    : 300;
+            const height =
+                Number.isFinite(this.height) && this.height > 0
+                    ? this.height
+                    : 150;
+            this._napiCanvasState = {
+                canvas: createCanvas(width, height),
+                context: null,
+            };
+        }
+
+        return this._napiCanvasState.canvas.toDataURL(...args);
+    };
+
+    if (!window.ImageData) window.ImageData = CanvasImageData;
+
+    if (!Reflect.has(globalThis, "ImageData")) {
+        Object.defineProperty(globalThis, "ImageData", {
+            configurable: true,
+            enumerable: false,
+            writable: true,
+            value: CanvasImageData,
+        });
+    }
+
+    canvasPatched = true;
+}
+
+function ensureDomEnvironment(userAgent) {
+    if (domWindow) return domWindow;
+
+    const dom = new JSDOM(
+        "<!DOCTYPE html><html><head></head><body></body></html>",
+        {
+            url: "https://www.youtube.com/",
+            referrer: "https://www.youtube.com/",
+            userAgent,
+        },
+    );
+
+    domWindow = dom.window;
+
+    const globalAssignments = {
+        window: domWindow,
+        document: domWindow.document,
+        location: domWindow.location,
+        origin: domWindow.origin,
+        navigator: domWindow.navigator,
+        HTMLElement: domWindow.HTMLElement,
+        atob: domWindow.atob,
+        btoa: domWindow.btoa,
+        crypto: domWindow.crypto,
+        performance: domWindow.performance,
+    };
+
+    for (const [key, value] of Object.entries(globalAssignments)) {
+        if (!Reflect.has(globalThis, key)) {
+            Object.defineProperty(globalThis, key, {
+                configurable: true,
+                enumerable: false,
+                writable: true,
+                value,
+            });
+        }
+    }
+
+    if (!Reflect.has(globalThis, "self")) {
+        Object.defineProperty(globalThis, "self", {
+            configurable: true,
+            enumerable: false,
+            writable: true,
+            value: globalThis,
+        });
+    }
+
+    patchCanvasSupport(domWindow);
+
+    return domWindow;
+}
+
+function resetBotguardState() {
+    if (botguardClient?.shutdown) {
+        try {
+            botguardClient.shutdown();
+        } catch {
+            /* no-op */
+        }
+    }
+
+    if (activeScriptId && domWindow?.document)
+        domWindow.document.getElementById(activeScriptId)?.remove();
+
+    botguardClient = undefined;
+    webPoMinter = undefined;
+    activeScriptId = null;
+    initializationPromise = null;
+}
+
+async function initializeBotguard(innertube, { forceRefresh } = {}) {
+    if (forceRefresh) resetBotguardState();
+
+    if (webPoMinter) return webPoMinter;
+
+    if (initializationPromise) return await initializationPromise;
+
+    const userAgent = innertube.session.context.client.userAgent || USER_AGENT;
+    ensureDomEnvironment(userAgent);
+
+    initializationPromise = (async () => {
+        const challengeResponse = await innertube.getAttestationChallenge(
+            "ENGAGEMENT_TYPE_UNBOUND",
+        );
+        const challenge = challengeResponse?.bg_challenge;
+
+        if (!challenge)
+            throw new Error("Failed to retrieve Botguard challenge.");
+
+        const interpreterUrl =
+            challenge.interpreter_url
+                ?.private_do_not_access_or_else_trusted_resource_url_wrapped_value;
+
+        if (!interpreterUrl)
+            throw new Error(
+                "Botguard challenge did not provide an interpreter URL.",
+            );
+
+        if (!domWindow.document.getElementById(interpreterUrl)) {
+            const interpreterResponse = await fetch(`https:${interpreterUrl}`, {
+                headers: {
+                    "user-agent": userAgent,
+                },
+            });
+
+            const interpreterJavascript = await interpreterResponse.text();
+
+            if (!interpreterJavascript)
+                throw new Error(
+                    "Failed to download Botguard interpreter script.",
+                );
+
+            const script = domWindow.document.createElement("script");
+            script.type = "text/javascript";
+            script.id = interpreterUrl;
+            script.textContent = interpreterJavascript;
+            domWindow.document.head.appendChild(script);
+            activeScriptId = script.id;
+
+            const executeInterpreter = new domWindow.Function(
+                interpreterJavascript,
+            );
+            executeInterpreter.call(domWindow);
+        }
+
+        botguardClient = await BG.BotGuardClient.create({
+            program: challenge.program,
+            globalName: challenge.global_name,
+            globalObj: globalThis,
+        });
+
+        const webPoSignalOutput = [];
+        const botguardSnapshot = await botguardClient.snapshot({
+            webPoSignalOutput,
+        });
+
+        const integrityResponse = await fetch(buildURL("GenerateIT", true), {
+            method: "POST",
+            headers: {
+                "content-type": "application/json+protobuf",
+                "x-goog-api-key": GOOG_API_KEY,
+                "x-user-agent": "grpc-web-javascript/0.1",
+                "user-agent": userAgent,
+            },
+            body: JSON.stringify([REQUEST_KEY, botguardSnapshot]),
+        });
+
+        const integrityPayload = await integrityResponse.json();
+        const integrityToken = integrityPayload?.[0];
+
+        if (typeof integrityToken !== "string")
+            throw new Error("Botguard integrity token generation failed.");
+
+        webPoMinter = await BG.WebPoMinter.create(
+            { integrityToken },
+            webPoSignalOutput,
+        );
+
+        return webPoMinter;
+    })()
+        .catch((error) => {
+            resetBotguardState();
+            throw error;
+        })
+        .finally(() => {
+            initializationPromise = null;
+        });
+
+    return await initializationPromise;
+}
+
+function requireBinding(binding) {
+    if (!binding)
+        throw new Error("Content binding is required to mint a WebPO token.");
+    return binding;
+}
+
+async function getWebPoMinter(innertube, options = {}) {
+    const minter = await initializeBotguard(innertube, options);
+
+    return {
+        generatePlaceholder(binding) {
+            return BG.PoToken.generateColdStartToken(requireBinding(binding));
+        },
+        async mint(binding) {
+            return await minter.mintAsWebsafeString(requireBinding(binding));
+        },
+    };
+}
+
+function invalidateWebPoMinter() {
+    resetBotguardState();
+}
+
+/**
+ * Generates Data Sync tokens required for content PO token minting.
+ *
+ * @param {Innertube} innertube - The Innertube instance.
+ * @returns {Promise<{dataSyncId: string, fullToken: string}>} The Data Sync ID and full token.
+ */
+async function generateDataSyncTokens(innertube) {
+    try {
+        const accountInfo = await innertube.account.getInfo();
+        console.log(accountInfo);
+        const dataSyncId =
+            accountInfo.contents.contents[0].endpoint.payload.supportedTokens[2]
+                .datasyncIdToken.datasyncIdToken;
+
+        if (!dataSyncId)
+            throw new Error("Data Sync ID not found in account info");
+
+        console.log("Data Sync ID:", dataSyncId);
+        const minter = await getWebPoMinter(innertube);
+
+        const fullToken = await minter.mint(dataSyncId);
+        console.log("Full Token:", fullToken);
+
+        return {
+            dataSyncId,
+            fullToken,
+        };
+    } catch (error) {
+        console.error("Error generating Data Sync tokens:", error);
+        throw error;
+    }
+}
+
+export { getWebPoMinter, invalidateWebPoMinter, generateDataSyncTokens };

package/youtubeSabrCore.js

@@ -0,0 +1,178 @@
+import { Constants, YTNodes } from "youtubei.js";
+import { EnabledTrackTypes, buildSabrFormat } from "googlevideo/utils";
+import { SabrStream } from "googlevideo/sabr-stream";
+import { Readable, PassThrough } from "stream";
+import { getWebPoMinter, invalidateWebPoMinter } from "./poTokenGenerator.js";
+import { getInnertube } from "./getInnertube.js";
+
+const DEFAULT_OPTIONS = {
+    audioQuality: "AUDIO_QUALITY_MEDIUM",
+    enabledTrackTypes: EnabledTrackTypes.AUDIO_ONLY,
+};
+
+/**
+ * Converts a stream to a Node.js Readable stream
+ *
+ * @param {ReadableStream} stream - The stream to convert
+ * @returns {Readable} The Node.js Readable stream
+ */
+function toNodeReadable(stream) {
+    const nodeStream = new PassThrough();
+    const reader = stream.getReader();
+
+    (async () => {
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                if (value) {
+                    if (!nodeStream.write(Buffer.from(value)))
+                        await new Promise((resolve) =>
+                            nodeStream.once("drain", resolve),
+                        );
+                }
+            }
+        } finally {
+            nodeStream.end();
+        }
+    })();
+
+    return nodeStream;
+}
+
+/**
+ * Creates a SABR stream for a given video ID
+ *
+ * @param {string} videoId - The video ID
+ * @returns {Promise<Readable>} The SABR stream
+ */
+async function createSabrStream(videoId, cookies, logSabrEvents = false) {
+    const innertube = await getInnertube(cookies);
+    let accountInfo = null;
+
+    // === Mint initial PO token ===
+    try {
+        accountInfo = await innertube.account.getInfo();
+    } catch (e) {
+        accountInfo = null;
+    }
+    const dataSyncId =
+        accountInfo?.contents?.contents[0]?.endpoint?.payload
+            ?.supportedTokens?.[2]?.datasyncIdToken?.datasyncIdToken ??
+        innertube.session.context.client.visitorData;
+    const minter = await getWebPoMinter(innertube);
+    const contentPoToken = await minter.mint(videoId);
+    const poToken = await minter.mint(dataSyncId);
+
+    // === Player request ===
+    const watchEndpoint = new YTNodes.NavigationEndpoint({
+        watchEndpoint: { videoId },
+    });
+    const playerResponse = await watchEndpoint.call(innertube.actions, {
+        playbackContext: {
+            adPlaybackContext: { pyv: true },
+            contentPlaybackContext: {
+                vis: 0,
+                splay: false,
+                lactMilliseconds: "-1",
+                signatureTimestamp:
+                    innertube.session.player?.signature_timestamp,
+            },
+        },
+        contentCheckOk: true,
+        racyCheckOk: true,
+        serviceIntegrityDimensions: { poToken: poToken },
+        parse: true,
+    });
+
+    const serverAbrStreamingUrl = await innertube.session.player?.decipher(
+        playerResponse.streaming_data?.server_abr_streaming_url,
+    );
+    const videoPlaybackUstreamerConfig =
+        playerResponse.player_config?.media_common_config
+            .media_ustreamer_request_config?.video_playback_ustreamer_config;
+
+    if (!videoPlaybackUstreamerConfig)
+        throw new Error("ustreamerConfig not found");
+    if (!serverAbrStreamingUrl)
+        throw new Error("serverAbrStreamingUrl not found");
+
+    const sabrFormats =
+        playerResponse.streaming_data?.adaptive_formats.map(buildSabrFormat) ||
+        [];
+
+    const serverAbrStream = new SabrStream({
+        formats: sabrFormats,
+        serverAbrStreamingUrl,
+        videoPlaybackUstreamerConfig,
+        poToken: contentPoToken,
+        clientInfo: {
+            clientName: parseInt(
+                Constants.CLIENT_NAME_IDS[
+                    innertube.session.context.client.clientName
+                ],
+            ),
+            clientVersion: innertube.session.context.client.clientVersion,
+        },
+    });
+
+    // === Stream protection handling ===
+    let protectionFailureCount = 0;
+    let lastStatus = null;
+    serverAbrStream.on("streamProtectionStatusUpdate", async (statusUpdate) => {
+        if (statusUpdate.status !== lastStatus) {
+            if (logSabrEvents)
+                console.log("Stream Protection Status Update:", statusUpdate);
+            lastStatus = statusUpdate.status;
+        }
+        if (statusUpdate.status === 2) {
+            protectionFailureCount = Math.min(protectionFailureCount + 1, 10);
+            if (
+                protectionFailureCount === 1 ||
+                protectionFailureCount % 5 === 0
+            )
+                if (logSabrEvents)
+                    console.log(
+                        `Rotating PO token... (attempt ${protectionFailureCount})`,
+                    );
+
+            try {
+                const rotationMinter = await getWebPoMinter(innertube, {
+                    forceRefresh: protectionFailureCount >= 3,
+                });
+                const placeholderToken =
+                    rotationMinter.generatePlaceholder(videoId);
+                serverAbrStream.setPoToken(placeholderToken);
+                const mintedPoToken = await rotationMinter.mint(videoId);
+                serverAbrStream.setPoToken(mintedPoToken);
+            } catch (err) {
+                if (
+                    protectionFailureCount === 1 ||
+                    protectionFailureCount % 5 === 0
+                )
+                    if (logSabrEvents)
+                        console.error("Failed to rotate PO token:", err);
+            }
+        } else if (statusUpdate.status === 3) {
+            if (logSabrEvents)
+                console.error(
+                    "Stream protection rejected token (SPS 3). Resetting Botguard.",
+                );
+            invalidateWebPoMinter();
+        } else {
+            protectionFailureCount = 0;
+        }
+    });
+
+    serverAbrStream.on("error", (err) => {
+        if (logSabrEvents) console.error("SABR stream error:", err);
+    });
+
+    // === Start SABR stream ===
+    const { audioStream } = await serverAbrStream.start(DEFAULT_OPTIONS);
+    const nodeStream = toNodeReadable(audioStream);
+
+    return nodeStream;
+}
+
+export { createSabrStream };

package/youtubeiExtractor.js

@@ -0,0 +1,298 @@
+// YoutubeSabrExtractor.js
+import { BaseExtractor, Track, Playlist, Util } from "discord-player";
+import { createSabrStream } from "./youtubeSabrCore.js";
+import { getInnertube } from "./getInnertube.js";
+
+/**
+ * Discord-player extractor using only helpers from youtubeSabrCore.js.
+ */
+class YoutubeSabrExtractor extends BaseExtractor {
+    static identifier = "com.itsmaat.discord-player.youtube-sabr";
+
+    async activate() {
+        this.protocols = ["youtube", "yt"];
+        this.cookies = this.options.cookies;
+        this.logSabrEvents = this.options.logSabrEvents;
+        this.innertube = await getInnertube(this.cookies);
+
+        const fn = this.options.createStream;
+        if (typeof fn === "function") {
+            this._stream = (q) => {
+                return fn(this, q);
+            };
+        }
+    }
+
+    async deactivate() {
+        this._stream = null;
+        this.innertube = null;
+    }
+
+    async validate(query, queryType) {
+        if (typeof query !== "string") return false;
+        return (
+            !isUrl(query) ||
+            /^https?:\/\/(www\.)?(youtube\.com|youtu\.be)\//i.test(query)
+        );
+    }
+
+    async handle(query, context) {
+        try {
+            if (!isUrl(query)) {
+                const search = await this.innertube.search(query);
+                const videos = search.videos.filter((v) => v.type === "Video");
+
+                const tracks = [];
+                for (const video of videos.slice(0, 10)) {
+                    const info = await this.innertube.getBasicInfo(video.id);
+                    const durationMs = (info.basic_info?.duration ?? 0) * 1000;
+
+                    tracks.push(
+                        new Track(context.player, {
+                            title:
+                                info.basic_info?.title ?? `YouTube:${video.id}`,
+                            author: info.basic_info?.author ?? null,
+                            url: `https://www.youtube.com/watch?v=${video.id}`,
+                            thumbnail: video.thumbnails[0]?.url,
+                            duration: Util.buildTimeCode(
+                                Util.parseMS(durationMs),
+                            ),
+                            source: "youtube-sabr",
+                            requestedBy: context.requestedBy ?? null,
+                            raw: {
+                                basicInfo: info,
+                                live: info.basic_info?.is_live || false,
+                            },
+                        }),
+                    );
+                }
+                return this.createResponse(null, tracks);
+            }
+            let isPlaylist = false;
+            let playlistId = null;
+            const urlObj = new URL(query);
+            const hasList = urlObj.searchParams.has("list");
+            const isShortLink = /(^|\.)youtu\.be$/i.test(urlObj.hostname);
+            isPlaylist = hasList && !isShortLink;
+            playlistId = isPlaylist ? urlObj.searchParams.get("list") : null;
+
+            // If playlist detected
+            if (isPlaylist && playlistId) {
+                let playlist = await this.innertube.getPlaylist(playlistId);
+                if (!playlist?.videos?.length)
+                    return this.createResponse(null, []);
+
+                const dpPlaylist = new Playlist(context.player, {
+                    id: playlistId,
+                    title: playlist.info.title ?? "Unknown",
+                    url: query,
+                    thumbnail: playlist.info.thumbnails[0].url,
+                    description:
+                        playlist.info.description ??
+                        playlist.info.title ??
+                        "UNKNOWN DESCRIPTION",
+                    source: "youtube",
+                    type: "playlist",
+                    author: {
+                        name:
+                            playlist?.channels[0]?.author?.name ??
+                            playlist.info.author.name ??
+                            "UNKNOWN AUTHOR",
+                        url:
+                            playlist?.channels[0]?.author?.url ??
+                            playlist.info.author.url ??
+                            "UNKNOWN AUTHOR",
+                    },
+                    tracks: [],
+                    requestedBy: context.requestedBy ?? null,
+                });
+
+                dpPlaylist.tracks = [];
+
+                const plTracks = playlist.videos
+                    .filter((v) => v.type === "PlaylistVideo")
+                    .map((v) => {
+                        const duration = Util.buildTimeCode(
+                            Util.parseMS(v.duration.seconds * 1000),
+                        );
+                        const raw = {
+                            duration_ms: v.duration.seconds * 1000,
+                            live: v.is_live,
+                            duration,
+                        };
+
+                        return new Track(this.context.player, {
+                            title: v.title.text ?? "UNKNOWN TITLE",
+                            duration: duration,
+                            thumbnail: v.thumbnails[0]?.url,
+                            author: v.author.name,
+                            requestedBy: context.requestedBy,
+                            url: `https://youtube.com/watch?v=${v.id}`,
+                            raw,
+                            playlist: dpPlaylist,
+                            source: "youtube",
+                            queryType: "youtubeVideo",
+                            async requestMetadata() {
+                                return this.raw;
+                            },
+                            metadata: raw,
+                            live: v.is_live,
+                        });
+                    });
+
+                while (playlist.has_continuation) {
+                    playlist = await playlist.getContinuation();
+
+                    plTracks.push(
+                        ...playlist.videos
+                            .filter((v) => v.type === "PlaylistVideo")
+                            .map((v) => {
+                                const duration = Util.buildTimeCode(
+                                    Util.parseMS(v.duration.seconds * 1000),
+                                );
+                                const raw = {
+                                    duration_ms: v.duration.seconds * 1000,
+                                    live: v.is_live,
+                                    duration,
+                                };
+
+                                return new Track(this.context.player, {
+                                    title: v.title.text ?? "UNKNOWN TITLE",
+                                    duration,
+                                    thumbnail: v.thumbnails[0]?.url,
+                                    author: v.author.name,
+                                    requestedBy: context.requestedBy,
+                                    url: `https://youtube.com/watch?v=${v.id}`,
+                                    raw,
+                                    playlist: dpPlaylist,
+                                    source: "youtube",
+                                    queryType: "youtubeVideo",
+                                    async requestMetadata() {
+                                        return this.raw;
+                                    },
+                                    metadata: raw,
+                                    live: v.is_live,
+                                });
+                            }),
+                    );
+                }
+
+                dpPlaylist.tracks = plTracks;
+
+                return this.createResponse(dpPlaylist, plTracks);
+            }
+
+            // Otherwise treat as single video
+            const videoId = extractVideoId(query);
+            if (!videoId) return this.createResponse(null, []);
+
+            const info = await this.innertube.getBasicInfo(videoId);
+            const durationMs = (info.basic_info?.duration ?? 0) * 1000;
+
+            const trackObj = new Track(context.player, {
+                title: info.basic_info?.title ?? `YouTube:${videoId}`,
+                author: info.basic_info?.author ?? null,
+                url: `https://www.youtube.com/watch?v=${videoId}`,
+                thumbnail: info.basic_info?.thumbnail[0].url,
+                duration: Util.buildTimeCode(Util.parseMS(durationMs)),
+                source: "youtube-sabr",
+                requestedBy: context.requestedBy ?? null,
+                raw: {
+                    basicInfo: info,
+                    live: info.basic_info?.is_live || false,
+                },
+            });
+
+            return this.createResponse(null, [trackObj]);
+        } catch (err) {
+            console.error("[YoutubeSabrExtractor handle error]", err);
+            return this.createResponse(null, []);
+        }
+    }
+
+    async stream(track) {
+        try {
+            if (!this.innertube)
+                throw new Error(
+                    "Innertube not initialized; call activate() first",
+                );
+            const videoId = extractVideoId(track.url || track.raw?.id || "");
+            if (!videoId)
+                throw new Error("Unable to extract video id from track.url");
+            // Use the helper to create the SABR stream (returns Node.js readable)
+            const nodeStream = await createSabrStream(
+                videoId,
+                this.cookies,
+                this.logSabrEvents,
+            );
+            return nodeStream;
+        } catch (e) {
+            console.error(e);
+            throw e;
+        }
+    }
+}
+
+function isUrl(input) {
+    try {
+        const url = new URL(input);
+        return ["https:", "http:"].includes(url.protocol);
+    } catch (e) {
+        return false;
+    }
+}
+
+function extractVideoId(vid) {
+    const YOUTUBE_REGEX =
+        /^https:\/\/(www\.)?youtu(\.be\/.{11}(.+)?|be\.com\/watch\?v=.{11}(&.+)?)/;
+    if (!YOUTUBE_REGEX.test(vid)) throw new Error("Invalid youtube url");
+
+    let id = new URL(vid).searchParams.get("v");
+    // VIDEO DETECTED AS YT SHORTS OR youtu.be link
+    if (!id) id = vid.split("/").at(-1)?.split("?").at(0);
+
+    return id;
+}
+
+function extractPlaylistId(url) {
+    try {
+        const u = new URL(url);
+        return u.searchParams.get("list");
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Try to resolve a youtu.be short link to the final canonical URL.
+ * Uses HEAD first, falls back to GET if needed. Returns the final URL string
+ * or the original input on failure.
+ *
+ * Note: relies on global fetch being available (Node 18+). If fetch isn't
+ * available in your environment, you can polyfill with node-fetch or use Innertube's fetch.
+ */
+async function resolveFinalUrl(input) {
+    try {
+        // prefer HEAD to minimize data, but some endpoints block HEAD so we fallback to GET
+        if (typeof fetch !== "function") return input;
+
+        // HEAD attempt
+        try {
+            const head = await fetch(input, {
+                method: "HEAD",
+                redirect: "follow",
+            });
+            if (head?.url) return head.url;
+        } catch (headErr) {
+            // ignore and try GET
+        }
+
+        const get = await fetch(input, { method: "GET", redirect: "follow" });
+        return get?.url || input;
+    } catch (err) {
+        // anything fails -> return original
+        return input;
+    }
+}
+
+export { YoutubeSabrExtractor };