Amazon Video - subtitle downloader

Allows you to download subtitles from Amazon Video
换行
// ==UserScript==
// @name        Amazon Video - subtitle downloader
// @description Allows you to download subtitles from Amazon Video
// @license     MIT
// @version     2.0.0
// @namespace   tithen-firion.github.io
// @match       https://*.amazon.com/*
// @match       https://*.amazon.de/*
// @match       https://*.amazon.co.uk/*
// @match       https://*.amazon.co.jp/*
// @match       https://*.primevideo.com/*
// @grant       unsafeWindow
// @require     https://cdn.jsdelivr.net/gh/Stuk/jszip@579beb1d45c8d586d8be4411d5b2e48dea018c06/dist/jszip.min.js?version=3.1.5
// @require     https://cdn.jsdelivr.net/gh/eligrey/FileSaver.js@283f438c31776b622670be002caf1986c40ce90c/dist/FileSaver.min.js?version=2018-12-29
// ==/UserScript==
 
class ProgressBar {
  constructor(max) {
    this.current = 0;
    this.max = max;
 
    let container = document.querySelector("#userscript_progress_bars");
    if(container === null) {
      container = document.createElement("div");
      container.id = "userscript_progress_bars"
      document.body.appendChild(container)
      container.style
      container.style.position = "fixed";
      container.style.top = 0;
      container.style.left = 0;
      container.style.width = "100%";
      container.style.background = "red";
      container.style.zIndex = "99999999";
    }
 
    this.progressElement = document.createElement("div");
    this.progressElement.innerHTML = "Click to stop";
    this.progressElement.style.cursor = "pointer";
    this.progressElement.style.fontSize = "16px";
    this.progressElement.style.textAlign = "center";
    this.progressElement.style.width = "100%";
    this.progressElement.style.height = "20px";
    this.progressElement.style.background = "transparent";
    this.stop = new Promise(resolve => {
      this.progressElement.addEventListener("click", () => {resolve(STOP_THE_DOWNLOAD)});
    });
 
    container.appendChild(this.progressElement);
  }
 
  increment() {
    this.current += 1;
    if(this.current <= this.max) {
      let p = this.current / this.max * 100;
      this.progressElement.style.background = `linear-gradient(to right, green ${p}%, transparent ${p}%)`;
    }
  }
 
  destroy() {
    this.progressElement.remove();
  }
}
 
const STOP_THE_DOWNLOAD = "AMAZON_SUBTITLE_DOWNLOADER_STOP_THE_DOWNLOAD";
const TIMEOUT_ERROR = "AMAZON_SUBTITLE_DOWNLOADER_TIMEOUT_ERROR";
const DOWNLOADER_MENU = "subtitle-downloader-menu";
 
const DOWNLOADER_MENU_HTML = `
<ol>
<li class="header">Amazon subtitle downloader</li>
<li class="ep-title-in-filename">Add episode title to filename: <span></span></li>
<li class="incomplete">Scroll to the bottom to load more episodes</li>
</ol>
`;
 
const SCRIPT_CSS = `
#${DOWNLOADER_MENU} {
  position: absolute;
  display: none;
  width: 600px;
  top: 0;
  left: calc( 50% - 150px );
}
#${DOWNLOADER_MENU} ol {
  list-style: none;
  position: relative;
  width: 300px;
  background: #333;
  color: #fff;
  padding: 0;
  margin: 0;
  font-size: 12px;
  z-index: 99999998;
}
body:hover #${DOWNLOADER_MENU} { display: block; }
#${DOWNLOADER_MENU} li {
  padding: 10px;
  position: relative;
}
#${DOWNLOADER_MENU} li.header { font-weight: bold; }
#${DOWNLOADER_MENU} li:not(.header):hover { background: #666; }
#${DOWNLOADER_MENU} li:not(.header) {
  display: none;
  cursor: pointer;
}
#${DOWNLOADER_MENU}:hover li { display: block; }
#${DOWNLOADER_MENU} li > div {
  display: none;
  position: absolute;
  top: 0;
  left: 300px;
}
#${DOWNLOADER_MENU} li:hover > div { display: block; }
 
body:not(.asd-more-eps) #${DOWNLOADER_MENU} .incomplete { display: none; }
 
#${DOWNLOADER_MENU}:not(.series) .series{ display: none; }
#${DOWNLOADER_MENU}.series .not-series{ display: none; }
`;
 
const EXTENSIONS = {
  "TTMLv2": "ttml2",
  "DFXP": "dfxp"
}
 
let INFO_URL = null;
const INFO_CACHE = new Map();
 
let epTitleInFilename = localStorage.getItem("ASD_ep-title-in-filename") === "true";
 
const setEpTitleInFilename = () => {
  document.querySelector(`#${DOWNLOADER_MENU} .ep-title-in-filename > span`).innerHTML = (epTitleInFilename ? "on" : "off");
};
 
const toggleEpTitleInFilename = () => {
  epTitleInFilename = !epTitleInFilename;
  if(epTitleInFilename)
    localStorage.setItem("ASD_ep-title-in-filename", epTitleInFilename);
  else
    localStorage.removeItem("ASD_ep-title-in-filename");
  setEpTitleInFilename();
};
 
const showIncompleteWarning = () => {
  document.body.classList.add("asd-more-eps");
};
const hideIncompleteWarning = () => {
  try {
    document.body.classList.remove("asd-more-eps");
  }
  catch(ignore) {}
};
const scrollDown = () => {
  (
    document.querySelector('[data-testid="dp-episode-list-pagination-marker"]')
    || document.querySeledtor("#navFooter")
  ).scrollIntoView();
};
 
// XML to SRT
const parseTTMLLine = (line, parentStyle, styles) => {
  const topStyle = line.getAttribute("style") || parentStyle;
  let prefix = "";
  let suffix = "";
  let italic = line.getAttribute("tts:fontStyle") === "italic";
  let bold = line.getAttribute("tts:fontWeight") === "bold";
  let ruby = line.getAttribute("tts:ruby") === "text";
  if(topStyle !== null) {
    italic = italic || styles[topStyle][0];
    bold = bold || styles[topStyle][1];
    ruby = ruby || styles[topStyle][2];
  }
 
  if(italic) {
    prefix = "<i>";
    suffix = "</i>";
  }
  if(bold) {
    prefix += "<b>";
    suffix = "</b>" + suffix;
  }
  if(ruby) {
    prefix += "(";
    suffix = ")" + suffix;
  }
 
  let result = "";
 
  for(const node of line.childNodes) {
    if(node.nodeType === Node.ELEMENT_NODE) {
      const tagName = node.tagName.split(":").pop().toUpperCase();
      if(tagName === "BR") {
        result += "\n";
      }
      else if(tagName === "SPAN") {
        result += parseTTMLLine(node, topStyle, styles);
      }
      else {
        console.log("unknown node:", node);
        throw "unknown node";
      }
    }
    else if(node.nodeType === Node.TEXT_NODE) {
      result += prefix + node.textContent + suffix;
    }
  }
 
  return result;
};
const xmlToSrt = (xmlString, lang) => {
  try {
    let parser = new DOMParser();
    var xmlDoc = parser.parseFromString(xmlString, "text/xml");
 
    const styles = {};
    for(const style of xmlDoc.querySelectorAll("head styling style")) {
      const id = style.getAttribute("xml:id");
      if(id === null) throw "style ID not found";
      const italic = style.getAttribute("tts:fontStyle") === "italic";
      const bold = style.getAttribute("tts:fontWeight") === "bold";
      const ruby = style.getAttribute("tts:ruby") === "text";
      styles[id] = [italic, bold, ruby];
    }
 
    const regionsTop = {};
    for(const style of xmlDoc.querySelectorAll("head layout region")) {
      const id = style.getAttribute("xml:id");
      if(id === null) throw "style ID not found";
      const origin = style.getAttribute("tts:origin") || "0% 80%";
      const position = parseInt(origin.match(/\s(\d+)%/)[1]);
      regionsTop[id] = position < 50;
    }
 
    const topStyle = xmlDoc.querySelector("body").getAttribute("style");
 
    console.log(topStyle, styles, regionsTop);
 
    const lines = [];
    const textarea = document.createElement("textarea");
 
    let i = 0;
    for(const line of xmlDoc.querySelectorAll("body p")) {
      let parsedLine = parseTTMLLine(line, topStyle, styles);
      if(parsedLine != "") {
        if(lang.indexOf("ar") == 0)
          parsedLine = parsedLine.replace(/^(?!\u202B|\u200F)/gm, "\u202B");
 
        textarea.innerHTML = parsedLine;
        parsedLine = textarea.value;
        parsedLine = parsedLine.replace(/\n{2,}/g, "\n");
 
        const region = line.getAttribute("region");
        if(regionsTop[region] === true) {
          parsedLine = "{\\an8}" + parsedLine;
        }
 
        lines.push(++i);
        lines.push((line.getAttribute("begin") + " --> " + line.getAttribute("end")).replace(/\./g,","));
        lines.push(parsedLine);
        lines.push("");
      }
    }
    return lines.join("\n");
  }
  catch(e) {
    console.error(e);
    alert("Failed to parse XML subtitle file, see browser console for more details");
    return null;
  }
};
 
const sanitizeName = name => name.replace(/[:*?"<>|\\\/]+/g, "_").replace(/ /g, ".").replace(/\.{2,}/g, ".");
 
const asyncSleep = (seconds, value) => new Promise(resolve => {
  window.setTimeout(resolve, seconds * 1000, value);
});
 
const getName = (episodeId, addTitle, addSeriesName) => {
  let seasonNumber = 0;
  let digits = 2;
  let seriesName = "UNKNOWN";
 
  const info = INFO_CACHE.get(episodeId);
  const season = INFO_CACHE.get(info.show);
  if(typeof season !== "undefined") {
    seasonNumber = season.season;
    digits = season.digits;
    seriesName = season.title;
  }
 
  let title = (
    "S" + seasonNumber.toString().padStart(2, "0")
    + "E" + info.episode.toString().padStart(digits, "0")
  );
 
  if(addTitle)
    title += " " + info.title;
 
  if(addSeriesName)
    title = seriesName + " " + title;
 
  return title;
};
 
const createQueue = ids => {
  let archiveName = null;
  const names = new Set();
  const queue = new Map();
  for(const id of ids) {
    const info = JSON.parse(JSON.stringify(INFO_CACHE.get(id)));
    let name;
    if(info.type === "movie") {
      archiveName = sanitizeName(info.title + "." + info.year);
      name = archiveName;
    }
    else if(info.type === "episode") {
      name = sanitizeName(getName(id, epTitleInFilename, true));
      if(archiveName === null) {
        try {
          const series = INFO_CACHE.get(info.show);
          archiveName = sanitizeName(series.title + ".S" + series.season.toString().padStart(2, "0"));
        }
        catch(ignore) {}
      }
    }
    else
      continue;
 
    let subName = name;
    let i = 2;
    while(names.has(subName)) {
      sub_name = `${name}_${i}`;
      ++i;
    }
    names.add(subName);
    info.filename = subName;
    queue.set(id, info);
  }
  if(archiveName === null)
    archiveName = "subs";
 
  return [archiveName + ".zip", queue];
};
 
const getSubInfo = async envelope => {
  const response = await fetch(
    INFO_URL,
    {
      "credentials": "include",
      "method": "POST",
      "mode": "cors",
      "body": JSON.stringify({
        "globalParameters": {
          "deviceCapabilityFamily": "WebPlayer",
          "playbackEnvelope": envelope
        },
        "timedTextUrlsRequest": {
          "supportedTimedTextFormats": ["TTMLv2","DFXP"]
        }
      })
    }
  );
  const data = await response.json();
  if(data.globalError) {
    if(data.globalError.code && data.globalError.code === "PlaybackEnvelope.Expired")
      throw "authentication expired, refresh the page and try again";
    else
      throw data.globalError;
  }
  try {
    return data.timedTextUrls.result;
  }
  catch(error) {
    console.log(data);
    throw error;
  }
};
 
const download = async e => {
  const ids = e.target.getAttribute("data-id").split(";");
  if(ids.length === 1 && ids[0] === "")
    return;
 
  const [archiveName, queue] = createQueue(ids);
  const metadataProgress = new ProgressBar(queue.size);
  const subs = new Map();
  for(const [id, info] of queue) {
    const resultPromise = getSubInfo(info.envelope);
    let result;
    let error = null;
    try {
      // Promise.any isn't supported in all browsers, use Promise.race instead
      result = await Promise.race([resultPromise, metadataProgress.stop, asyncSleep(30, TIMEOUT_ERROR)]);
    }
    catch(e) {
      console.log(e);
      error = `error: ${e}`;
    }
    if(result === STOP_THE_DOWNLOAD)
      error = "stopped by user";
    else if(result === TIMEOUT_ERROR)
      error = "timeout error";
    if(error !== null) {
      alert(error);
      metadataProgress.destroy();
      return;
    }
 
    metadataProgress.increment();
    if(typeof result === "undefined")
      continue;
 
    for(const subtitle of [].concat(result.subtitleUrls || [], result.forcedNarrativeUrls || [])) {
      let lang = subtitle.languageCode;
      if(subtitle.subtype !== "Dialog")
        lang += `[${subtitle.subtype}]`;
 
      if(subtitle.type === "Subtitle") {}
      else if(subtitle.type === "Sdh")
        lang += "[cc]";
      else if(subtitle.type === "ForcedNarrative")
        lang += "-forced";
      else if(subtitle.type === "SubtitleMachineGenerated")
        lang += "[machine-generated]";
      else
        lang += `[${subtitle.type}]`;
 
      const name = info.filename + "." + lang;
      let subName = name;
      let i = 2;
      while(subs.has(subName)) {
        sub_name = `${name}_${i}`;
        ++i;
      }
      subs.set(
        subName,
        {
          "url": subtitle.url,
          "type": subtitle.format,
          "language": subtitle.languageCode
        }
      )
    }
  }
  metadataProgress.destroy();
 
  if(subs.size === 0) {
    alert("no subtitles found");
    return;
  }
 
  const _zip = new JSZip();
  const progress = new ProgressBar(subs.size);
  for(const [filename, details] of subs) {
    let extension = EXTENSIONS[details.type];
    if(typeof extension === "undefined") {
      const match = details.url.match(/\.([^\/]+)$/);
      if(match === null)
        extension = details.type.toLocaleLowerCase();
      else
        extension = match[1];
    }
 
    const subFilename = filename + "." + extension;
    const resultPromise = fetch(details.url, {"mode": "cors"});
    let result;
    let error = null;
    try {
      // Promise.any isn't supported in all browsers, use Promise.race instead
      result = await Promise.race([resultPromise, progress.stop, asyncSleep(30, TIMEOUT_ERROR)]);
    }
    catch(e) {
      error = `error: ${e}`;
    }
    if(result === STOP_THE_DOWNLOAD)
      error = STOP_THE_DOWNLOAD;
    else if(result === TIMEOUT_ERROR)
      error = "timeout error";
    if(error !== null) {
      if(error !== STOP_THE_DOWNLOAD)
        alert(error);
      break;
    }
    progress.increment();
    let data;
    if(extension === "ttml2") {
      data = await result.text();
      try {
        const srtFilename = filename + ".srt";
        const srtText = xmlToSrt(data, details.language);
        if(srtText !== null)
          _zip.file(srtFilename, srtText);
      }
      catch(ignore) {}
    }
    else
      data = await result.arrayBuffer();
    _zip.file(subFilename, data);
  }
  progress.destroy();
 
  const content = await _zip.generateAsync({type: "blob"});
  saveAs(content, archiveName);
};
 
const addDownloadButtons = parsedActions => {
  const menu = document.querySelector(`#${DOWNLOADER_MENU} > ol`);
 
  for(const [type, details] of parsedActions) {
    const li = document.createElement("li");
    let ids = null;
    if(type === "movie") {
      li.innerHTML = "Download subtitles for this movie";
      ids = details;
    }
    else if(type === "batch" && details.length > 0) {
      li.innerHTML = "Download subtitles for this batch <div><ol></ol></div>";
      ids = details.join(";");
      const ol = li.querySelector("ol");
      for(const episodeId of details) {
        const li = document.createElement("li");
        li.setAttribute("data-id", episodeId);
        li.innerHTML = getName(episodeId, true, false);
        ol.append(li);
      }
    }
    else
      continue;
 
    li.setAttribute("data-id", ids);
    li.addEventListener("click", download, true);
    menu.append(li);
  }
};
 
const parseActions = actions => {
  const parsed = [];
  const series = {};
  for(const [id, playback] of actions) {
    const info = INFO_CACHE.get(id);
    if(typeof info === "undefined")
      continue;
    if(info.type !== "movie" && info.type !== "episode")
      continue;
    if(typeof info.envelope !== "undefined")
      continue;
 
    try {
      let envelopeFound = false;
      for(const child of playback.main.children) {
        if(typeof child.playbackEnvelope !== "undefined") {
          info.envelope = child.playbackEnvelope;
          info.expiry = child.expiryTime;
          envelopeFound = true;
          break;
        }
      }
      if(!envelopeFound)
        continue;
    }
    catch(error) {
      continue;
    }
 
    if(info.type === "movie") {
      parsed.push(["movie", id])
    }
    else if(info.type === "episode") {
      let show = series[info.show];
      if(typeof show === "undefined") {
        series[info.show] = [];
        show = series[info.show];
      }
      show.push([id, info.episode]);
    }
  }
 
  for(const show of Object.values(series)) {
    show.sort((a, b) => a[1] - b[1]);
    const tmp = [];
    for(const [id, ep] of show) {
      tmp.push(id);
    }
    parsed.push(["batch", tmp]);
  }
 
  return parsed;
};
 
const parseDetails = (pageTitleId, state, id, details) => {
  if(typeof INFO_CACHE.get(id) !== "undefined")
    return;
 
  const info = {
    "title": details.title,
    "type": details.titleType
  };
  if(info.type === "movie") {
    info["year"] = details.releaseYear;
  }
  else if(info.type === "episode") {
    info["episode"] = details.episodeNumber;
    info["show"] = pageTitleId;
  }
  else if(info.type === "season") {
    info["season"] = details.seasonNumber;
    info["title"] = details.parentTitle;
    info["digits"] = 2;
    if(pageTitleId === id) {
      try {
        const epCount = state.episodeList.totalCardSize;
        info["digits"] = Math.max(Math.floor(Math.log10(epCount)), 1) + 1;
        if(epCount > state.episodeList.cardTitleIds.length)
          showIncompleteWarning();
      }
      catch(ignore) {}
    }
  }
  else {
    console.log(id, details);
    return;
  }
 
  INFO_CACHE.set(id, info);
};
 
const init = (url, fromFetch) => {
  let props = undefined;
 
  if(typeof fromFetch === "undefined") {
    if(INFO_URL !== null)
      return;
 
    INFO_URL = url;
 
    for(const templateElement of document.querySelectorAll('script[type="text/template"]')) {
      let data;
      try {
        data = JSON.parse(templateElement.innerHTML);
        props = data.props.body[0].props;
      }
      catch(ignore) {
        continue;
      }
 
      if(typeof props !== "undefined")
        break;
    }
  }
  else {
    props = fromFetch.page[0].assembly.body[0].props;
    INFO_CACHE.clear();
    hideIncompleteWarning();
    const menu = document.querySelector(`#${DOWNLOADER_MENU}`);
    if(menu !== null)
      menu.remove();
  }
 
  const pageTitleId = props.btf.state.pageTitleId;
  for(const [id, details] of Object.entries(props.btf.state.detail.detail)) {
    parseDetails(pageTitleId, props.btf.state, id, details);
  }
 
  const actions = [];
  for(const [id, action] of Object.entries(props.atf.state.action.atf)) {
    actions.push([id, action.playbackActions]);
  }
  for(const [id, action] of Object.entries(props.btf.state.action.btf)) {
    actions.push([id, action.playbackActions]);
  }
  const parsedActions = parseActions(actions);
  if(parsedActions.length === 0)
    return;
 
  if(document.querySelector(`#${DOWNLOADER_MENU}`) === null) {
    const menu = document.createElement("div");
    menu.id = DOWNLOADER_MENU;
    menu.innerHTML = DOWNLOADER_MENU_HTML;
    document.body.appendChild(menu);
    menu.querySelector(".ep-title-in-filename").addEventListener("click", toggleEpTitleInFilename);
    menu.querySelector(".incomplete").addEventListener("click", scrollDown);
    setEpTitleInFilename();
  }
 
  addDownloadButtons(parsedActions);
};
 
const parseEpisodes = data => {
  const pageTitleId = data.widgets.pageContext.pageTitleId;
 
  const actions = [];
  for(const episode of data.widgets.episodeList.episodes) {
    parseDetails(pageTitleId, {}, episode.titleID, episode.detail);
    actions.push([episode.titleID, episode.action.playbackActions]);
  }
  const parsedActions = parseActions(actions);
  addDownloadButtons(parsedActions);
};
 
const processMessage = e => {
  const {type, data} = e.detail;
 
  if(type === "url")
    init(data);
  else if(type === "episodes")
    parseEpisodes(data);
  else if(type === "page")
    init(null, data);
}
 
const injection = () => {
  // hijack functions
  ((open, realFetch) => {
    let urlGrabbed = false;
 
    XMLHttpRequest.prototype.open = function() {
      if(!urlGrabbed && arguments[1] && arguments[1].includes("/GetVodPlaybackResources?")) {
        window.dispatchEvent(new CustomEvent("amazon_sub_downloader_data", {detail: {type: "url", data: arguments[1]}}));
        urlGrabbed = true;
      }
      open.apply(this, arguments);
    };
 
    window.fetch = async (...args) => {
      const response = realFetch(...args);
      if(!urlGrabbed && args[0] && args[0].includes("/GetVodPlaybackResources?")) {
        window.dispatchEvent(new CustomEvent("amazon_sub_downloader_data", {detail: {type: "url", data: args[0]}}));
        urlGrabbed = true;
      }
      if(args[0] && args[0].includes("/getDetailWidgets?")) {
        const copied = (await response).clone();
        const data = await copied.json();
        window.dispatchEvent(new CustomEvent("amazon_sub_downloader_data", {detail: {type: "episodes", data: data}}));
      }
      else if(args[1] && args[1].headers && args[1].headers["x-requested-with"] === "WebSPA") {
        const copied = (await response).clone();
        const data = await copied.json();
        window.dispatchEvent(new CustomEvent("amazon_sub_downloader_data", {detail: {type: "page", data: data}}));
      }
      return response;
    };
  })(XMLHttpRequest.prototype.open, window.fetch);
}
 
window.addEventListener("amazon_sub_downloader_data", processMessage, false);
 
// inject script
const sc = document.createElement("script");
sc.innerHTML = "(" + injection.toString() + ")()";
document.head.appendChild(sc);
document.head.removeChild(sc);
 
// add CSS style
const s = document.createElement("style");
s.innerHTML = SCRIPT_CSS;
document.head.appendChild(s);