content.js

"use strict";
(() => {
  // src/lib/batching.ts
  var BATCH_MAX_CHARS = 4e3;
  var BATCH_MAX_ITEMS = 50;
  var SEPARATOR = { text: "\n\n", pattern: /\n\s*\n/ };
  function chunkItems(items) {
    const chunks = [];
    let current = [];
    let chars = 0;
    for (const item of items) {
      if (current.length > 0 && (current.length >= BATCH_MAX_ITEMS || chars + item.text.length > BATCH_MAX_CHARS)) {
        chunks.push(current);
        current = [];
        chars = 0;
      }
      current.push(item);
      chars += item.text.length + SEPARATOR.text.length;
    }
    if (current.length > 0) chunks.push(current);
    return chunks;
  }
  function joinBatch(items) {
    return items.map((item) => item.text).join(SEPARATOR.text);
  }
  function splitBatchResult(translated, expectedCount) {
    const parts = translated.split(SEPARATOR.pattern);
    if (parts.length !== expectedCount) return null;
    return parts.map((part) => part.trim());
  }

  // src/lib/dom.ts
  var TARGET_SELECTOR = ".markdown-body";
  var EXCLUDE_SELECTOR = [
    "pre",
    "code",
    "kbd",
    "samp",
    "tt",
    ".highlight",
    ".notranslate",
    ".zeroclipboard-container",
    "script",
    "style"
  ].join(", ");
  function hasTargetRoots(doc = document) {
    return doc.querySelector(TARGET_SELECTOR) !== null;
  }
  function collectTextNodes(doc = document) {
    const nodes = [];
    const seen = /* @__PURE__ */ new Set();
    for (const root of doc.querySelectorAll(TARGET_SELECTOR)) {
      const walker = doc.createTreeWalker(
        root,
        NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT,
        {
          acceptNode(node) {
            if (node.nodeType === Node.ELEMENT_NODE) {
              return node.matches(EXCLUDE_SELECTOR) ? NodeFilter.FILTER_REJECT : NodeFilter.FILTER_SKIP;
            }
            const text = node.nodeValue?.trim() ?? "";
            if (!text) return NodeFilter.FILTER_REJECT;
            if (!/\p{L}/u.test(text)) return NodeFilter.FILTER_REJECT;
            return NodeFilter.FILTER_ACCEPT;
          }
        }
      );
      let n;
      while (n = walker.nextNode()) {
        const textNode = n;
        if (!seen.has(textNode)) {
          seen.add(textNode);
          nodes.push(textNode);
        }
      }
    }
    return nodes;
  }
  function applyTranslation(node, raw, translation, originals) {
    if (!node.isConnected) return;
    if (!originals.has(node)) originals.set(node, raw);
    const lead = /^\s*/.exec(raw)?.[0] ?? "";
    const trail = /\s*$/.exec(raw)?.[0] ?? "";
    node.nodeValue = lead + translation + trail;
  }
  function restoreOriginals(originals) {
    for (const [node, text] of originals) {
      if (node.isConnected) node.nodeValue = text;
    }
    originals.clear();
  }

  // src/lib/lang.ts
  function baseLang(lang) {
    return lang.replace(/-.*$/, "");
  }
  function scriptOf(lang) {
    const match = /-([A-Za-z]{4})(?:-|$)/.exec(lang);
    return match ? match[1].toLowerCase() : null;
  }
  function isSameLanguage(a, b) {
    return baseLang(a) === baseLang(b) && scriptOf(a) === scriptOf(b);
  }
  function pickDefaultTargetLang(uiLanguage) {
    const ui = uiLanguage || "en";
    if (/^zh-(TW|HK|Hant)/i.test(ui)) return "zh-Hant";
    return baseLang(ui);
  }
  var displayNamesCache = /* @__PURE__ */ new Map();
  function languageDisplayName(code, uiLanguage) {
    let names = displayNamesCache.get(uiLanguage);
    if (names === void 0) {
      try {
        names = new Intl.DisplayNames([uiLanguage], { type: "language" });
      } catch {
        names = null;
      }
      displayNamesCache.set(uiLanguage, names);
    }
    try {
      return names?.of(code) || code;
    } catch {
      return code;
    }
  }
  function sanitizeText(raw) {
    return raw.trim().replace(/\s+/g, " ");
  }

  // src/lib/settings.ts
  var TARGET_LANG_KEY = "targetLang";
  function defaultTargetLang() {
    return pickDefaultTargetLang(chrome.i18n.getUILanguage());
  }
  async function getTargetLang() {
    const items = await chrome.storage.sync.get({ [TARGET_LANG_KEY]: defaultTargetLang() });
    return items[TARGET_LANG_KEY];
  }
  function onTargetLangChanged(callback) {
    chrome.storage.onChanged.addListener((changes, area) => {
      const change = changes[TARGET_LANG_KEY];
      if (area !== "sync" || !change) return;
      callback(change.newValue);
    });
  }

  // src/content.ts
  var DETECT_MIN_CHARS = 20;
  var DETECT_TIMEOUT_MS = 3e3;
  var TRANSLATE_TIMEOUT_MS = 15e3;
  var BATCH_TRANSLATE_TIMEOUT_MS = 3e4;
  var state = {
    targetLang: defaultTargetLang(),
    originals: /* @__PURE__ */ new Map(),
    cache: /* @__PURE__ */ new Map(),
    translators: /* @__PURE__ */ new Map(),
    pendingPairs: /* @__PURE__ */ new Set()
  };
  function isTranslated() {
    return state.originals.size > 0;
  }
  var button = null;
  var detectorPromise = null;
  var lastHref = location.href;
  function msg(key, substitutions) {
    return chrome.i18n.getMessage(key, substitutions);
  }
  function errorMessage(err) {
    return err instanceof Error || err instanceof DOMException ? err.message : String(err);
  }
  function isNotAllowedError(err) {
    return err instanceof DOMException && err.name === "NotAllowedError";
  }
  function withTimeout(promise, ms) {
    const timer = new Promise((_, reject) => {
      setTimeout(() => reject(new Error("timeout")), ms);
    });
    return Promise.race([promise, timer]);
  }
  void getTargetLang().then((lang) => {
    state.targetLang = lang;
    updateButton();
  });
  onTargetLangChanged((lang) => {
    state.targetLang = lang;
    state.translators.clear();
    state.cache.clear();
    if (isTranslated()) restorePage();
    updateButton();
  });
  function getDetector() {
    if (!detectorPromise) {
      detectorPromise = (async () => {
        if (!("LanguageDetector" in self)) return null;
        try {
          return await LanguageDetector.create();
        } catch (err) {
          console.warn(`[github-translate] LanguageDetector unavailable: ${errorMessage(err)}`);
          if (isNotAllowedError(err)) detectorPromise = null;
          return null;
        }
      })();
    }
    return detectorPromise;
  }
  var detectFailureStreak = 0;
  var detectMemo = /* @__PURE__ */ new Map();
  async function detectLanguage(text) {
    if (detectFailureStreak >= 3) return null;
    const memoized = detectMemo.get(text);
    if (memoized !== void 0) return memoized;
    try {
      const result = await withTimeout(
        (async () => {
          const detector = await getDetector();
          if (!detector) return null;
          const [best] = await detector.detect(text);
          if (best && best.detectedLanguage !== "und" && best.confidence >= 0.5) {
            return best.detectedLanguage;
          }
          return null;
        })(),
        DETECT_TIMEOUT_MS
      );
      detectFailureStreak = 0;
      detectMemo.set(text, result);
      return result;
    } catch (err) {
      detectFailureStreak += 1;
      console.debug(`[github-translate] language detection failed: ${errorMessage(err)}`);
      return null;
    }
  }
  async function detectPageLanguage(nodes) {
    const sample = nodes.map((node) => sanitizeText(node.nodeValue ?? "")).join(" ").slice(0, 1e3);
    if (sample) {
      const lang = await detectLanguage(sample);
      if (lang) return lang;
    }
    return "en";
  }
  function getTranslatorFor(src) {
    const target = state.targetLang;
    const key = `${src}>${target}`;
    let promise = state.translators.get(key);
    if (!promise) {
      promise = (async () => {
        try {
          const availability = await Translator.availability({
            sourceLanguage: src,
            targetLanguage: target
          });
          if (availability === "unavailable") return null;
          return await Translator.create({
            sourceLanguage: src,
            targetLanguage: target,
            monitor(m) {
              m.addEventListener("downloadprogress", (e) => {
                setButtonLabel(
                  msg("downloadingModel", [`${src}→${target}`, String(Math.round(e.loaded * 100))])
                );
              });
            }
          });
        } catch (err) {
          console.warn(
            `[github-translate] translator unavailable: ${src}→${target}: ${errorMessage(err)}`
          );
          if (isNotAllowedError(err)) {
            state.pendingPairs.add(src);
            state.translators.delete(key);
          }
          return null;
        }
      })();
      state.translators.set(key, promise);
    }
    return promise;
  }
  function cacheKeyOf(item) {
    return `${item.src}|${item.text}`;
  }
  async function translateChunk(translator, chunk) {
    if (chunk.length > 1) {
      try {
        const out = await withTimeout(
          translator.translate(joinBatch(chunk)),
          BATCH_TRANSLATE_TIMEOUT_MS
        );
        const parts = splitBatchResult(out, chunk.length);
        if (parts) {
          for (let i = 0; i < chunk.length; i++) {
            const item = chunk[i];
            const translation = parts[i];
            state.cache.set(cacheKeyOf(item), translation);
            applyTranslation(item.node, item.raw, translation, state.originals);
          }
          return;
        }
        console.debug(
          `[github-translate] batch separator not preserved; falling back to per-node calls`
        );
      } catch (err) {
        console.debug(`[github-translate] batch translate failed: ${errorMessage(err)}`);
      }
    }
    for (const item of chunk) {
      await translateSingle(translator, item);
    }
  }
  async function translateSingle(translator, item) {
    try {
      const out = await withTimeout(translator.translate(item.text), TRANSLATE_TIMEOUT_MS);
      state.cache.set(cacheKeyOf(item), out);
      applyTranslation(item.node, item.raw, out, state.originals);
    } catch (err) {
      console.debug(`[github-translate] translate failed: ${errorMessage(err)}`);
    }
  }
  async function translatePage() {
    if (!("Translator" in self)) {
      throw new Error(msg("unsupportedBrowser"));
    }
    const nodes = collectTextNodes();
    if (nodes.length === 0) {
      return msg("nothingToTranslate");
    }
    const total = nodes.length;
    let done = 0;
    const progress = (delta) => {
      done += delta;
      setButtonLabel(msg("translating", [String(done), String(total)]));
    };
    progress(0);
    const target = state.targetLang;
    const pageLang = await detectPageLanguage(nodes);
    const bySource = /* @__PURE__ */ new Map();
    for (const node of nodes) {
      const raw = node.nodeValue ?? "";
      const text = sanitizeText(raw);
      let src = pageLang;
      if (text.length >= DETECT_MIN_CHARS) {
        const detected = await detectLanguage(text);
        if (detected) src = detected;
      }
      if (isSameLanguage(src, target)) {
        progress(1);
        continue;
      }
      const item = { node, raw, text, src };
      const cached = state.cache.get(cacheKeyOf(item));
      if (cached !== void 0) {
        applyTranslation(item.node, item.raw, cached, state.originals);
        progress(1);
        continue;
      }
      const group = bySource.get(src);
      if (group) {
        group.push(item);
      } else {
        bySource.set(src, [item]);
      }
    }
    for (const src of bySource.keys()) void getTranslatorFor(src);
    for (const [src, items] of bySource) {
      const translator = await getTranslatorFor(src);
      if (!translator) {
        progress(items.length);
        continue;
      }
      for (const chunk of chunkItems(items)) {
        await translateChunk(translator, chunk);
        progress(chunk.length);
      }
    }
    if (state.pendingPairs.size > 0) return msg("clickAgainToDownload");
    if (!isTranslated()) return msg("nothingToTranslate");
    return null;
  }
  function restorePage() {
    restoreOriginals(state.originals);
  }
  async function onClick() {
    if (!button || button.disabled) return;
    button.disabled = true;
    let notice = null;
    try {
      if (isTranslated()) {
        restorePage();
      } else {
        if (state.pendingPairs.size > 0) {
          const pending = [...state.pendingPairs];
          state.pendingPairs.clear();
          await Promise.all(pending.map((src) => getTranslatorFor(src)));
        }
        notice = await translatePage();
      }
    } catch (err) {
      console.error("[github-translate]", err);
      notice = msg("errorLabel");
      alert(msg("translateFailed", [errorMessage(err)]));
    } finally {
      button.disabled = false;
      updateButton(notice);
    }
  }
  function setButtonLabel(label) {
    if (button && button.textContent !== label) button.textContent = label;
  }
  function updateButton(notice) {
    if (!button || button.disabled) return;
    button.hidden = !hasTargetRoots();
    if (notice) {
      setButtonLabel(notice);
      setTimeout(() => updateButton(), 3e3);
      return;
    }
    setButtonLabel(
      isTranslated() ? msg("showOriginal") : msg("translateTo", [languageDisplayName(state.targetLang, chrome.i18n.getUILanguage())])
    );
  }
  function createButton() {
    button = document.createElement("button");
    button.id = "gh-translate-button";
    button.type = "button";
    button.addEventListener("click", () => {
      void onClick();
    });
    document.body.appendChild(button);
    updateButton();
  }
  function onNavigate() {
    lastHref = location.href;
    state.originals.clear();
    updateButton();
  }
  createButton();
  document.addEventListener("turbo:load", onNavigate);
  document.addEventListener("pjax:end", onNavigate);
  document.addEventListener("soft-nav:end", onNavigate);
  var scheduled = false;
  var observer = new MutationObserver(() => {
    if (scheduled) return;
    scheduled = true;
    requestAnimationFrame(() => {
      scheduled = false;
      if (location.href !== lastHref) {
        onNavigate();
      } else {
        updateButton();
      }
    });
  });
  observer.observe(document.body, { childList: true, subtree: true });
})();