@oreohq/ytdl-core 4.15.2 → 4.16.5

package/lib/info.js

@@ -1,5 +1,6 @@
 /* eslint-disable no-unused-vars */
 const sax = require("sax");
+
 const utils = require("./utils");
 // Forces Node JS version of setTimeout for Electron based applications
 const { setTimeout } = require("timers");
@@ -68,10 +69,8 @@ exports.getBasicInfo = async (id, options) => {
   info.videoDetails = extras.cleanVideoDetails(
     Object.assign(
       {},
-      info.player_response &&
-        info.player_response.microformat &&
-        info.player_response.microformat.playerMicroformatRenderer,
-      info.player_response && info.player_response.videoDetails,
+      info.player_response?.microformat?.playerMicroformatRenderer,
+      info.player_response?.videoDetails,
       additional,
     ),
     info,
@@ -96,7 +95,7 @@ const getEmbedPageBody = (id, options) => {
 const getHTML5player = body => {
   let html5playerRes =
     /<script\s+src="([^"]+)"(?:\s+type="text\/javascript")?\s+name="player_ias\/base"\s*>|"jsUrl":"([^"]+)"/.exec(body);
-  return html5playerRes ? html5playerRes[1] || html5playerRes[2] : null;
+  return html5playerRes?.[1] || html5playerRes?.[2];
 };
 
 /**
@@ -122,7 +121,7 @@ const retryFunc = async (func, args, options) => {
       result = await func(...args);
       break;
     } catch (err) {
-      if ((err && err.statusCode < 500) || currentTry >= options.maxRetries) throw err;
+      if (err?.statusCode < 500 || currentTry >= options.maxRetries) throw err;
       let wait = Math.min(++currentTry * options.backoff.inc, options.backoff.max);
       await new Promise(resolve => setTimeout(resolve, wait));
     }
@@ -153,12 +152,9 @@ const findJSON = (source, varName, body, left, right, prependJSON) => {
 };
 
 const findPlayerResponse = (source, info) => {
+  if (!info) return {};
   const player_response =
-    info &&
-    ((info.args && info.args.player_response) ||
-      info.player_response ||
-      info.playerResponse ||
-      info.embedded_player_response);
+    info.args?.player_response || info.player_response || info.playerResponse || info.embedded_player_response;
   return parseJSON(source, "player_response", player_response);
 };
 
@@ -201,17 +197,11 @@ const getWatchHTMLPage = async (id, options) => {
  * @returns {Array.<Object>}
  */
 const parseFormats = player_response => {
-  let formats = [];
-  if (player_response && player_response.streamingData) {
-    formats = formats
-      .concat(player_response.streamingData.formats || [])
-      .concat(player_response.streamingData.adaptiveFormats || []);
-  }
-  return formats;
+  return (player_response?.streamingData?.formats || [])?.concat(player_response?.streamingData?.adaptiveFormats || []);
 };
 
 const parseAdditionalManifests = (player_response, options) => {
-  let streamingData = player_response && player_response.streamingData,
+  let streamingData = player_response?.streamingData,
     manifests = [];
   if (streamingData) {
     if (streamingData.dashManifestUrl) {
@@ -241,7 +231,6 @@ exports.getInfo = async (id, options) => {
   const info = await exports.getBasicInfo(id, options);
   let funcs = [];
 
-  // Fill in HTML5 player URL
   info.html5player =
     info.html5player ||
     getHTML5player(await getWatchHTMLPageBody(id, options)) ||
@@ -251,52 +240,102 @@ exports.getInfo = async (id, options) => {
     throw Error("Unable to find html5player file");
   }
 
-  const html5player = new URL(info.html5player, BASE_URL).toString();
+  info.html5player = new URL(info.html5player, BASE_URL).toString();
+
+  let bestPlayerResponse = null;
 
   try {
-    if (info.videoDetails.age_restricted) throw Error("Cannot download age restricted videos with mobile clients");
     const promises = [];
-    if (options.playerClients.includes("WEB_CREATOR")) promises.push(fetchWebCreatorPlayer(id, html5player, options));
+    if (options.playerClients.includes("WEB_EMBEDDED")) promises.push(fetchWebEmbeddedPlayer(id, info, options));
+    if (options.playerClients.includes("TV")) promises.push(fetchTvPlayer(id, info, options));
     if (options.playerClients.includes("IOS")) promises.push(fetchIosJsonPlayer(id, options));
     if (options.playerClients.includes("ANDROID")) promises.push(fetchAndroidJsonPlayer(id, options));
-    const responses = await Promise.allSettled(promises);
-    info.formats = [].concat(...responses.map(r => parseFormats(r.value)));
-    if (info.formats.length === 0) throw new Error("Player JSON API failed");
 
-    funcs.push(sig.decipherFormats(info.formats, html5player, options));
+    if (promises.length > 0) {
+      const responses = await Promise.allSettled(promises);
+      const successfulResponses = responses
+        .filter(r => r.status === "fulfilled")
+        .map(r => r.value)
+        .filter(r => r);
+
+      console.log(`Found ${successfulResponses.length} successful responses from clients`);
 
-    for (let resp of responses) {
-      if (resp.value) {
-        funcs.push(...parseAdditionalManifests(resp.value, options));
+      if (successfulResponses.length > 0) {
+        bestPlayerResponse = successfulResponses[0];
+        funcs.push(sig.decipherFormats(parseFormats(bestPlayerResponse), info.html5player, options));
+        funcs.push(...parseAdditionalManifests(bestPlayerResponse, options));
       }
     }
 
-    if (options.playerClients.includes("WEB")) {
-      funcs.push(sig.decipherFormats(parseFormats(info.player_response), html5player, options));
-      funcs.push(...parseAdditionalManifests(info.player_response));
+    if (!bestPlayerResponse && options.playerClients.includes("WEB")) {
+      bestPlayerResponse = info.player_response;
+      funcs.push(sig.decipherFormats(parseFormats(info.player_response), info.html5player, options));
+      funcs.push(...parseAdditionalManifests(info.player_response, options));
     }
-  } catch (_) {
-    funcs.push(sig.decipherFormats(parseFormats(info.player_response), html5player, options));
-    funcs.push(...parseAdditionalManifests(info.player_response));
+  } catch (error) {
+    console.error("Error fetching formats:", error);
+
+    if (!bestPlayerResponse && options.playerClients.includes("WEB")) {
+      bestPlayerResponse = info.player_response;
+      funcs.push(sig.decipherFormats(parseFormats(info.player_response), info.html5player, options));
+      funcs.push(...parseAdditionalManifests(info.player_response, options));
+    }
+  }
+
+  if (funcs.length === 0) {
+    throw new Error("Failed to find any playable formats");
   }
 
   let results = await Promise.all(funcs);
   info.formats = Object.values(Object.assign({}, ...results));
-  info.formats = info.formats.map(formatUtils.addFormatMeta);
+
+  info.formats = info.formats.filter(format => format && format.url && format.mimeType);
+
+  if (info.formats.length === 0) {
+    throw new Error("No playable formats found");
+  }
+
+
+  info.formats = info.formats.map(format => {
+    const enhancedFormat = formatUtils.addFormatMeta(format);
+
+    if (!enhancedFormat.audioBitrate && enhancedFormat.hasAudio) {
+      enhancedFormat.audioBitrate = estimateAudioBitrate(enhancedFormat);
+    }
+
+    if (!enhancedFormat.isHLS && enhancedFormat.mimeType &&
+        (enhancedFormat.mimeType.includes('hls') ||
+         enhancedFormat.mimeType.includes('x-mpegURL') ||
+         enhancedFormat.mimeType.includes('application/vnd.apple.mpegurl'))) {
+      enhancedFormat.isHLS = true;
+    }
+
+    return enhancedFormat;
+  });
+
   info.formats.sort(formatUtils.sortFormats);
 
+  const bestFormat = info.formats.find(format => format.hasVideo && format.hasAudio) ||
+                     info.formats.find(format => format.hasVideo) ||
+                     info.formats.find(format => format.hasAudio) ||
+                     info.formats[0];
+
+  info.bestFormat = bestFormat;
+  info.videoUrl = bestFormat.url;
+  info.selectedFormat = bestFormat;
+
   info.full = true;
+
   return info;
 };
 
 const getPlaybackContext = async (html5player, options) => {
   const body = await utils.request(html5player, options);
-  let mo = body.match(/signatureTimestamp:(\d+)/);
-
+  const mo = body.match(/(signatureTimestamp|sts):(\d+)/);
   return {
     contentPlaybackContext: {
       html5Preference: "HTML5_PREF_WANTS",
-      signatureTimestamp: mo ? mo[1] : undefined,
+      signatureTimestamp: mo?.[2],
     },
   };
 };
@@ -304,26 +343,42 @@ const getPlaybackContext = async (html5player, options) => {
 const LOCALE = { hl: "en", timeZone: "UTC", utcOffsetMinutes: 0 },
   CHECK_FLAGS = { contentCheckOk: true, racyCheckOk: true };
 
-const WEB_CREATOR_CONTEXT = {
+const WEB_EMBEDDED_CONTEXT = {
   client: {
-    clientName: "WEB_CREATOR",
-    clientVersion: "1.20241023.00.01",
+    clientName: "WEB_EMBEDDED_PLAYER",
+    clientVersion: "1.20240723.01.00",
     ...LOCALE,
   },
 };
 
-const fetchWebCreatorPlayer = async (videoId, html5player, options) => {
+const TVHTML5_CONTEXT = {
+  client: {
+    clientName: "TVHTML5",
+    clientVersion: "7.20241201.18.00",
+    ...LOCALE,
+  },
+};
+
+const fetchWebEmbeddedPlayer = async (videoId, info, options) => {
   const payload = {
-    context: WEB_CREATOR_CONTEXT,
+    context: WEB_EMBEDDED_CONTEXT,
     videoId,
-    playbackContext: await getPlaybackContext(html5player, options),
+    playbackContext: await getPlaybackContext(info.html5player, options),
     ...CHECK_FLAGS,
   };
-
-  return await playerAPI(videoId, payload, undefined, options);
+  return await playerAPI(videoId, payload, options);
+};
+const fetchTvPlayer = async (videoId, info, options) => {
+  const payload = {
+    context: TVHTML5_CONTEXT,
+    videoId,
+    playbackContext: await getPlaybackContext(info.html5player, options),
+    ...CHECK_FLAGS,
+  };
+  return await playerAPI(videoId, payload, options);
 };
 
-const playerAPI = async (videoId, payload, userAgent, options) => {
+const playerAPI = async (videoId, payload, options) => {
   const { jar, dispatcher } = options.agent;
   const opts = {
     requestOptions: {
@@ -336,8 +391,7 @@ const playerAPI = async (videoId, payload, userAgent, options) => {
       },
       headers: {
         "Content-Type": "application/json",
-        cookie: jar.getCookieStringSync("https://www.youtube.com"),
-        "User-Agent": userAgent,
+        Cookie: jar.getCookieStringSync("https://www.youtube.com"),
         "X-Goog-Api-Format-Version": "2",
       },
       body: JSON.stringify(payload),

package/lib/sig.js

@@ -15,37 +15,47 @@ exports.cache = new Cache(1);
  */
 exports.getFunctions = (html5playerfile, options) =>
   exports.cache.getOrSet(html5playerfile, async () => {
+    // Rewrite tce player script URLs to non-tce variant
+    if (html5playerfile.includes("/player_ias_tce.vflset/")) {
+      console.debug("jsUrl URL points to tce-variant player script, rewriting to non-tce.");
+      html5playerfile = html5playerfile.replace("/player_ias_tce.vflset/", "/player_ias.vflset/");
+    }
+
     const body = await utils.request(html5playerfile, options);
     const functions = exports.extractFunctions(body);
     exports.cache.set(html5playerfile, functions);
     return functions;
   });
 
-// NewPipeExtractor regexps
-const DECIPHER_NAME_REGEXPS = [
-  "\\bm=([a-zA-Z0-9$]{2,})\\(decodeURIComponent\\(h\\.s\\)\\)",
-  "\\bc&&\\(c=([a-zA-Z0-9$]{2,})\\(decodeURIComponent\\(c\\)\\)",
-  '(?:\\b|[^a-zA-Z0-9$])([a-zA-Z0-9$]{2,})\\s*=\\s*function\\(\\s*a\\s*\\)\\s*\\{\\s*a\\s*=\\s*a\\.split\\(\\s*""\\s*\\)',
-  '([\\w$]+)\\s*=\\s*function\\((\\w+)\\)\\{\\s*\\2=\\s*\\2\\.split\\(""\\)\\s*;',
-];
+// Updated VARIABLE_PART based on the Java code
+const VARIABLE_PART = "[a-zA-Z_\\$][a-zA-Z_0-9\\$]*";
 
-// LavaPlayer regexps
-const VARIABLE_PART = "[a-zA-Z_\\$][a-zA-Z_0-9]*";
+const DECIPHER_NAME_REGEXPS = {
+  "\\b([a-zA-Z0-9_$]+)&&\\(\\1=([a-zA-Z0-9_$]{2,})\\(decodeURIComponent\\(\\1\\)\\)": 2,
+  '([a-zA-Z0-9_$]+)\\s*=\\s*function\\(\\s*([a-zA-Z0-9_$]+)\\s*\\)\\s*{\\s*\\2\\s*=\\s*\\2\\.split\\(\\s*""\\s*\\)\\s*;\\s*[^}]+;\\s*return\\s+\\2\\.join\\(\\s*""\\s*\\)': 1,
+  '/(?:\\b|[^a-zA-Z0-9_$])([a-zA-Z0-9_$]{2,})\\s*=\\s*function\\(\\s*a\\s*\\)\\s*{\\s*a\\s*=\\s*a\\.split\\(\\s*""\\s*\\)(?:;[a-zA-Z0-9_$]{2}\\.[a-zA-Z0-9_$]{2}\\(a,\\d+\\))?/': 1,
+  "\\bm=([a-zA-Z0-9$]{2,})\\(decodeURIComponent\\(h\\.s\\)\\)": 1,
+  "\\bc&&\\(c=([a-zA-Z0-9$]{2,})\\(decodeURIComponent\\(c\\)\\)": 1,
+  '(?:\\b|[^a-zA-Z0-9$])([a-zA-Z0-9$]{2,})\\s*=\\s*function\\(\\s*a\\s*\\)\\s*\\{\\s*a\\s*=\\s*a\\.split\\(\\s*""\\s*\\)': 1,
+  '([\\w$]+)\\s*=\\s*function\\((\\w+)\\)\\{\\s*\\2=\\s*\\2\\.split\\(""\\)\\s*;': 1,
+};
+
+// LavaPlayer regexps - update to use the new VARIABLE_PART
 const VARIABLE_PART_DEFINE = `\\"?${VARIABLE_PART}\\"?`;
 const BEFORE_ACCESS = '(?:\\[\\"|\\.)';
 const AFTER_ACCESS = '(?:\\"\\]|)';
 const VARIABLE_PART_ACCESS = BEFORE_ACCESS + VARIABLE_PART + AFTER_ACCESS;
-const REVERSE_PART = ":function\\(a\\)\\{(?:return )?a\\.reverse\\(\\)\\}";
-const SLICE_PART = ":function\\(a,b\\)\\{return a\\.slice\\(b\\)\\}";
-const SPLICE_PART = ":function\\(a,b\\)\\{a\\.splice\\(0,b\\)\\}";
+const REVERSE_PART = ":function\\(\\w\\)\\{(?:return )?\\w\\.reverse\\(\\)\\}";
+const SLICE_PART = ":function\\(\\w,\\w\\)\\{return \\w\\.slice\\(\\w\\)\\}";
+const SPLICE_PART = ":function\\(\\w,\\w\\)\\{\\w\\.splice\\(0,\\w\\)\\}";
 const SWAP_PART =
-  ":function\\(a,b\\)\\{" + "var c=a\\[0\\];a\\[0\\]=a\\[b%a\\.length\\];a\\[b(?:%a.length|)\\]=c(?:;return a)?\\}";
+  ":function\\(\\w,\\w\\)\\{var \\w=\\w\\[0\\];\\w\\[0\\]=\\w\\[\\w%\\w\\.length\\];\\w\\[\\w(?:%\\w.length|)\\]=\\w(?:;return \\w)?\\}";
 
 const DECIPHER_REGEXP =
-  `function(?: ${VARIABLE_PART})?\\(a\\)\\{` +
-  `a=a\\.split\\(""\\);\\s*` +
-  `((?:(?:a=)?${VARIABLE_PART}${VARIABLE_PART_ACCESS}\\(a,\\d+\\);)+)` +
-  `return a\\.join\\(""\\)` +
+  `function(?: ${VARIABLE_PART})?\\(([a-zA-Z])\\)\\{` +
+  '\\1=\\1\\.split\\(""\\);\\s*' +
+  `((?:(?:\\1=)?${VARIABLE_PART}${VARIABLE_PART_ACCESS}\\(\\1,\\d+\\);)+)` +
+  'return \\1\\.join\\(""\\)' +
   `\\}`;
 
 const HELPER_REGEXP = `var (${VARIABLE_PART})=\\{((?:(?:${VARIABLE_PART_DEFINE}${REVERSE_PART}|${
@@ -55,24 +65,14 @@ const HELPER_REGEXP = `var (${VARIABLE_PART})=\\{((?:(?:${VARIABLE_PART_DEFINE}$
 const SCVR = "[a-zA-Z0-9$_]";
 const MCR = `${SCVR}+`;
 const AAR = "\\[(\\d+)]";
-const N_TRANSFORM_NAME_REGEXPS = [
-  // NewPipeExtractor regexps
-  `${SCVR}="nn"\\[\\+${MCR}\\.${MCR}],${MCR}\\(${MCR}\\),${MCR}=${MCR}\\.${MCR}\\[${MCR}]\\|\\|null\\).+\\|\\|(${
-    MCR
-  })\\(""\\)`,
-  `${SCVR}="nn"\\[\\+${MCR}\\.${MCR}],${MCR}\\(${MCR}\\),${MCR}=${MCR}\\.${MCR}\\[${MCR}]\\|\\|null\\)&&\\(${MCR}=(${
-    MCR
-  })${AAR}`,
-  `${SCVR}="nn"\\[\\+${MCR}\\.${MCR}],${MCR}=${MCR}\\.get\\(${MCR}\\)\\).+\\|\\|(${MCR})\\(""\\)`,
-  `${SCVR}="nn"\\[\\+${MCR}\\.${MCR}],${MCR}=${MCR}\\.get\\(${MCR}\\)\\)&&\\(${MCR}=(${MCR})\\[(\\d+)]`,
-  `\\(${SCVR}=String\\.fromCharCode\\(110\\),${SCVR}=${SCVR}\\.get\\(${SCVR}\\)\\)&&\\(${SCVR}=(${MCR})(?:${AAR})?\\(${
-    SCVR
-  }\\)`,
-  `\\.get\\("n"\\)\\)&&\\(${SCVR}=(${MCR})(?:${AAR})?\\(${SCVR}\\)`,
-  // Skick regexps
-  '(\\w+).length\\|\\|\\w+\\(""\\)',
-  '\\w+.length\\|\\|(\\w+)\\(""\\)',
-];
+const N_TRANSFORM_NAME_REGEXPS = {
+  [`${SCVR}="nn"\\[\\+${MCR}\\.${MCR}],${MCR}\\(${MCR}\\),${MCR}=${MCR}\\.${MCR}\\[${MCR}]\\|\\|null\\).+\\|\\|(${MCR})\\(""\\)`]: 1,
+  [`${SCVR}="nn"\\[\\+${MCR}\\.${MCR}],${MCR}\\(${MCR}\\),${MCR}=${MCR}\\.${MCR}\\[${MCR}]\\|\\|null\\)&&\\(${MCR}=(${MCR})${AAR}`]: 1,
+  [`${SCVR}="nn"\\[\\+${MCR}\\.${MCR}],${MCR}=${MCR}\\.get\\(${MCR}\\)\\).+\\|\\|(${MCR})\\(""\\)`]: 1,
+  [`${SCVR}="nn"\\[\\+${MCR}\\.${MCR}],${MCR}=${MCR}\\.get\\(${MCR}\\)\\)&&\\(${MCR}=(${MCR})\\[(\\d+)]`]: 1,
+  [`\\(${SCVR}=String\\.fromCharCode\\(110\\),${SCVR}=${SCVR}\\.get\\(${SCVR}\\)\\)&&\\(${SCVR}=(${MCR})(?:${AAR})?\\(${SCVR}\\)`]: 1,
+  [`\\.get\\("n"\\)\\)&&\\(${SCVR}=(${MCR})(?:${AAR})?\\(${SCVR}\\)`]: 1,
+};
 
 // LavaPlayer regexps
 const N_TRANSFORM_REGEXP =
@@ -80,7 +80,7 @@ const N_TRANSFORM_REGEXP =
   "var\\s*(\\w+)=(?:\\1\\.split\\(.*?\\)|String\\.prototype\\.split\\.call\\(\\1,.*?\\))," +
   "\\s*(\\w+)=(\\[.*?]);\\s*\\3\\[\\d+]" +
   "(.*?try)(\\{.*?})catch\\(\\s*(\\w+)\\s*\\)\\s*\\{" +
-  '\\s*return"enhanced_except_([A-z0-9-]+)"\\s*\\+\\s*\\1\\s*}' +
+  '\\s*return"[\\w-]+([A-z0-9-]+)"\\s*\\+\\s*\\1\\s*}' +
   '\\s*return\\s*(\\2\\.join\\(""\\)|Array\\.prototype\\.join\\.call\\(\\2,.*?\\))};';
 
 const DECIPHER_ARGUMENT = "sig";
@@ -92,17 +92,15 @@ const matchRegex = (regex, str) => {
   return match;
 };
 
-const matchFirst = (regex, str) => matchRegex(regex, str)[0];
-
-const matchGroup1 = (regex, str) => matchRegex(regex, str)[1];
+const matchGroup = (regex, str, idx = 0) => matchRegex(regex, str)[idx];
 
 const getFuncName = (body, regexps) => {
   let fn;
-  for (const regex of regexps) {
+  for (const [regex, idx] of Object.entries(regexps)) {
     try {
-      fn = matchGroup1(regex, body);
+      fn = matchGroup(regex, body, idx);
       try {
-        fn = matchGroup1(`${fn.replace(/\$/g, "\\$")}=\\[([a-zA-Z0-9$\\[\\]]{2,})\\]`, body);
+        fn = matchGroup(`${fn.replace(/\$/g, "\\$")}=\\[([a-zA-Z0-9$\\[\\]]{2,})\\]`, body, 1);
       } catch (err) {
         // Function name is not inside an array
       }
@@ -111,44 +109,44 @@ const getFuncName = (body, regexps) => {
       continue;
     }
   }
-  if (!fn || fn.includes("[")) throw Error();
+  if (!fn || fn.includes("[")) throw Error("Could not match");
   return fn;
 };
 
 const DECIPHER_FUNC_NAME = "DisTubeDecipherFunc";
-const extractDecipherFunc = body => {
+const extractDecipherFunc = (exports.d1 = body => {
   try {
-    const helperObject = matchFirst(HELPER_REGEXP, body);
-    const decipherFunc = matchFirst(DECIPHER_REGEXP, body);
+    const helperObject = matchGroup(HELPER_REGEXP, body, 0);
+    const decipherFunc = matchGroup(DECIPHER_REGEXP, body, 0);
     const resultFunc = `var ${DECIPHER_FUNC_NAME}=${decipherFunc};`;
     const callerFunc = `${DECIPHER_FUNC_NAME}(${DECIPHER_ARGUMENT});`;
     return helperObject + resultFunc + callerFunc;
   } catch (e) {
     return null;
   }
-};
+});
 
-const extractDecipherWithName = body => {
+const extractDecipherWithName = (exports.d2 = body => {
   try {
     const decipherFuncName = getFuncName(body, DECIPHER_NAME_REGEXPS);
     const funcPattern = `(${decipherFuncName.replace(/\$/g, "\\$")}=function\\([a-zA-Z0-9_]+\\)\\{.+?\\})`;
-    const decipherFunc = `var ${matchGroup1(funcPattern, body)};`;
-    const helperObjectName = matchGroup1(";([A-Za-z0-9_\\$]{2,})\\.\\w+\\(", decipherFunc);
+    const decipherFunc = `var ${matchGroup(funcPattern, body, 1)};`;
+    const helperObjectName = matchGroup(";([A-Za-z0-9_\\$]{2,})\\.\\w+\\(", decipherFunc, 1);
     const helperPattern = `(var ${helperObjectName.replace(/\$/g, "\\$")}=\\{[\\s\\S]+?\\}\\};)`;
-    const helperObject = matchGroup1(helperPattern, body);
+    const helperObject = matchGroup(helperPattern, body, 1);
     const callerFunc = `${decipherFuncName}(${DECIPHER_ARGUMENT});`;
     return helperObject + decipherFunc + callerFunc;
   } catch (e) {
     return null;
   }
-};
+});
 
-const getExtractFunctions = (extractFunctions, body) => {
+const getExtractFunctions = (extractFunctions, body, postProcess = null) => {
   for (const extractFunction of extractFunctions) {
     try {
       const func = extractFunction(body);
       if (!func) continue;
-      return new vm.Script(func);
+      return new vm.Script(postProcess ? postProcess(func) : func);
     } catch (err) {
       continue;
     }
@@ -164,10 +162,11 @@ const extractDecipher = body => {
   if (!decipherFunc && !decipherWarning) {
     console.warn(
       "\x1b[33mWARNING:\x1B[0m Could not parse decipher function.\n" +
-        `Please report this issue with the "${utils.saveDebugFile(
+        "Stream URLs will be missing.\n" +
+        `Please report this issue by uploading the "${utils.saveDebugFile(
           "base.js",
           body,
-        )}" file on https://github.com/oreohq/ytdl-core/issues.\nStream URL will be missing.`,
+        )}" file on https://github.com/distubejs/ytdl-core/issues/144.`,
     );
     decipherWarning = true;
   }
@@ -175,50 +174,49 @@ const extractDecipher = body => {
 };
 
 const N_TRANSFORM_FUNC_NAME = "DisTubeNTransformFunc";
-const extractNTransformFunc = body => {
+const extractNTransformFunc = (exports.n1 = body => {
   try {
-    const nFunc = matchFirst(N_TRANSFORM_REGEXP, body);
+    const nFunc = matchGroup(N_TRANSFORM_REGEXP, body, 0);
     const resultFunc = `var ${N_TRANSFORM_FUNC_NAME}=${nFunc}`;
     const callerFunc = `${N_TRANSFORM_FUNC_NAME}(${N_ARGUMENT});`;
     return resultFunc + callerFunc;
   } catch (e) {
     return null;
   }
-};
+});
 
-const extractNTransformWithName = body => {
+const extractNTransformWithName = (exports.n2 = body => {
   try {
     const nFuncName = getFuncName(body, N_TRANSFORM_NAME_REGEXPS);
-    const funcPattern = `(${
-      nFuncName.replace(/\$/g, "\\$")
-      // eslint-disable-next-line max-len
-    }=\\s*function([\\S\\s]*?\\}\\s*return (([\\w$]+?\\.join\\(""\\))|(Array\\.prototype\\.join\\.call\\([\\w$]+?,[\\n\\s]*(("")|(\\("",""\\)))\\)))\\s*\\}))`;
-    const nTransformFunc = `var ${matchGroup1(funcPattern, body)};`;
+    const funcPattern = `(${nFuncName.replace(/\$/g, "\\$")}=function\\([a-zA-Z0-9_]+\\)\\{.+?\\})`;
+    const nTransformFunc = `var ${matchGroup(funcPattern, body, 1)};`;
     const callerFunc = `${nFuncName}(${N_ARGUMENT});`;
     return nTransformFunc + callerFunc;
   } catch (e) {
     return null;
   }
-};
+});
+
 
 let nTransformWarning = false;
 const extractNTransform = body => {
   // Faster: extractNTransformFunc
-  const nTransformFunc = getExtractFunctions([extractNTransformFunc, extractNTransformWithName], body);
+  const nTransformFunc = getExtractFunctions([extractNTransformFunc, extractNTransformWithName], body, code =>
+    code.replace(/if\s*\(\s*typeof\s*[\w$]+\s*===?.*?\)\s*return\s+[\w$]+\s*;?/, ""),
+  );
   if (!nTransformFunc && !nTransformWarning) {
     // This is optional, so we can continue if it's not found, but it will bottleneck the download.
     console.warn(
       "\x1b[33mWARNING:\x1B[0m Could not parse n transform function.\n" +
-        `Please report this issue with the "${utils.saveDebugFile(
+        `Please report this issue by uploading the "${utils.saveDebugFile(
           "base.js",
           body,
-        )}" file on https://github.com/oreohq/ytdl-core/issues.`,
+        )}" file on https://github.com/distubejs/ytdl-core/issues/144.`,
     );
     nTransformWarning = true;
   }
   return nTransformFunc;
 };
-
 /**
  * Extracts the actions that should be taken to decipher a signature
  * and transform the n parameter