@zucker-framework/ext-kit 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1781 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/util.ts
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+__name(delay, "delay");
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+__name(clamp, "clamp");
+function normalizeError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+__name(normalizeError, "normalizeError");
+function storageGet(keys) {
+  return new Promise((resolve) => chrome.storage.local.get(keys, resolve));
+}
+__name(storageGet, "storageGet");
+function storageSet(value) {
+  return new Promise((resolve) => chrome.storage.local.set(value, () => resolve()));
+}
+__name(storageSet, "storageSet");
+function storageRemove(keys) {
+  return new Promise((resolve) => chrome.storage.local.remove(keys, () => resolve()));
+}
+__name(storageRemove, "storageRemove");
+
+// src/naming.ts
+function sanitize(value) {
+  return String(value || "").replace(/[\\/:*?"<>|#&=%]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+__name(sanitize, "sanitize");
+function hostOf(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return String(url || "");
+  }
+}
+__name(hostOf, "hostOf");
+function normalizeUrls(urls) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of urls || []) {
+    const value = String(raw || "").trim();
+    if (!/^https?:\/\//i.test(value)) {
+      continue;
+    }
+    let key = value;
+    try {
+      const parsed = new URL(value);
+      parsed.hash = "";
+      key = parsed.toString();
+    } catch {
+      continue;
+    }
+    if (!seen.has(key)) {
+      seen.add(key);
+      out.push(key);
+    }
+    if (out.length >= 500) {
+      break;
+    }
+  }
+  return out;
+}
+__name(normalizeUrls, "normalizeUrls");
+function sessionStamp() {
+  const d = /* @__PURE__ */ new Date();
+  const p = /* @__PURE__ */ __name((n) => String(n).padStart(2, "0"), "p");
+  return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}`;
+}
+__name(sessionStamp, "sessionStamp");
+function fileStamp() {
+  const d = /* @__PURE__ */ new Date();
+  const p = /* @__PURE__ */ __name((n) => String(n).padStart(2, "0"), "p");
+  return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+}
+__name(fileStamp, "fileStamp");
+function todayString() {
+  const d = /* @__PURE__ */ new Date();
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+__name(todayString, "todayString");
+function folderNameFor(urls) {
+  const hosts = /* @__PURE__ */ new Set();
+  for (const url of urls) {
+    try {
+      hosts.add(new URL(url).hostname.replace(/^www\./, ""));
+    } catch {
+    }
+  }
+  const stamp = sessionStamp();
+  if (hosts.size === 1) {
+    const host = sanitize([
+      ...hosts
+    ][0]).slice(0, 60);
+    return host ? `${host}-${stamp}` : stamp;
+  }
+  return stamp;
+}
+__name(folderNameFor, "folderNameFor");
+function urlBaseName(url, maxLength, includeQuery) {
+  let base = "page";
+  try {
+    const parsed = new URL(url);
+    const host = parsed.hostname.replace(/^www\./, "");
+    let rest = (parsed.pathname + (includeQuery ? parsed.search : "")).replace(/\/+$/, "");
+    try {
+      rest = decodeURIComponent(rest);
+    } catch {
+    }
+    base = host + rest;
+  } catch {
+    base = url;
+  }
+  return sanitize(base).slice(0, maxLength) || "page";
+}
+__name(urlBaseName, "urlBaseName");
+function buildBatchFileName(folder, item, extension) {
+  const base = urlBaseName(item.url, 120, true);
+  const index = String(item.index).padStart(3, "0");
+  return `${folder}/${index}_${base}.${extension}`;
+}
+__name(buildBatchFileName, "buildBatchFileName");
+function buildQuickFileName(brand, quickFolder, pageUrl, extension) {
+  const base = urlBaseName(pageUrl, 110, false);
+  return `${brand}/${quickFolder}/${base}-${fileStamp()}.${extension}`;
+}
+__name(buildQuickFileName, "buildQuickFileName");
+
+// src/licensing.ts
+var CACHE_TTL_MS = 12 * 60 * 60 * 1e3;
+function unwrap(payload) {
+  const obj = payload;
+  return obj && typeof obj === "object" && "result" in obj ? obj.result : obj || {};
+}
+__name(unwrap, "unwrap");
+function createLicensing(product, brand, config) {
+  const TOKEN_KEY = `${product}_license_token`;
+  const ENTITLEMENT_KEY = `${product}_entitlement`;
+  const DEVICE_KEY = `${product}_device_id`;
+  async function getDeviceId() {
+    const data = await storageGet(DEVICE_KEY);
+    if (data[DEVICE_KEY]) {
+      return data[DEVICE_KEY];
+    }
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    const id = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+    await storageSet({
+      [DEVICE_KEY]: id
+    });
+    return id;
+  }
+  __name(getDeviceId, "getDeviceId");
+  async function activate(code) {
+    const deviceId = await getDeviceId();
+    let response;
+    try {
+      const platform = navigator.userAgentData?.platform || "Chrome";
+      response = await fetch(`${config.apiBase}/extension/licenses/activate`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          code: String(code || "").trim().toUpperCase().replace(/[^A-Z0-9]/g, ""),
+          deviceId,
+          deviceName: `${brand} \xB7 ${platform}`
+        })
+      });
+    } catch {
+      throw new Error("License service unreachable. Check your connection and retry.");
+    }
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      if (response.status === 403) {
+        throw new Error("Invalid code, or its device limit is reached.");
+      }
+      throw new Error("Activation failed. Please retry later.");
+    }
+    const data = unwrap(payload);
+    await storageSet({
+      [TOKEN_KEY]: data.token || "",
+      [ENTITLEMENT_KEY]: {
+        ...data.entitlement || {},
+        checkedAt: Date.now()
+      }
+    });
+    return data.entitlement;
+  }
+  __name(activate, "activate");
+  function normalize(value) {
+    const v = value;
+    if (!v) {
+      return null;
+    }
+    const expired = v.expiresAt && new Date(v.expiresAt).getTime() <= Date.now();
+    return expired ? null : {
+      plan: v.plan || "pro",
+      expiresAt: v.expiresAt || ""
+    };
+  }
+  __name(normalize, "normalize");
+  async function getEntitlement() {
+    const data = await storageGet([
+      TOKEN_KEY,
+      ENTITLEMENT_KEY
+    ]);
+    const token = data[TOKEN_KEY];
+    const cached = data[ENTITLEMENT_KEY];
+    if (!token) {
+      return null;
+    }
+    if (cached?.checkedAt && Date.now() - cached.checkedAt < CACHE_TTL_MS) {
+      return normalize(cached);
+    }
+    let response;
+    try {
+      response = await fetch(`${config.apiBase}/extension/licenses/me`, {
+        headers: {
+          Authorization: `Bearer ${token}`
+        }
+      });
+    } catch {
+      return cached ? normalize(cached) : null;
+    }
+    if (!response.ok) {
+      if (response.status === 401 || response.status === 403) {
+        await clear();
+        return null;
+      }
+      return cached ? normalize(cached) : null;
+    }
+    const payload = await response.json().catch(() => ({}));
+    const entitlement = unwrap(payload)?.entitlement;
+    await storageSet({
+      [ENTITLEMENT_KEY]: {
+        ...entitlement || {},
+        checkedAt: Date.now()
+      }
+    });
+    return normalize(entitlement);
+  }
+  __name(getEntitlement, "getEntitlement");
+  async function isPro() {
+    return Boolean(await getEntitlement());
+  }
+  __name(isPro, "isPro");
+  async function clear() {
+    await storageRemove([
+      TOKEN_KEY,
+      ENTITLEMENT_KEY
+    ]);
+  }
+  __name(clear, "clear");
+  return {
+    activate,
+    getEntitlement,
+    isPro,
+    clear,
+    purchaseUrl: config.purchaseUrl
+  };
+}
+__name(createLicensing, "createLicensing");
+
+// src/download.ts
+function createDownloader(justification) {
+  const pendingDownloadNames = /* @__PURE__ */ new Map();
+  let offscreenSetup = null;
+  chrome.downloads.onDeterminingFilename.addListener((item, suggest) => {
+    const fileName = pendingDownloadNames.get(item.url) || pendingDownloadNames.get(item.finalUrl || "");
+    if (!fileName) {
+      return;
+    }
+    suggest({
+      filename: fileName,
+      conflictAction: "uniquify"
+    });
+    return true;
+  });
+  async function ensureOffscreen() {
+    if (await chrome.offscreen.hasDocument()) {
+      return;
+    }
+    if (!offscreenSetup) {
+      offscreenSetup = chrome.offscreen.createDocument({
+        url: "offscreen.html",
+        reasons: [
+          chrome.offscreen.Reason.BLOBS
+        ],
+        justification
+      }).catch((error) => {
+        if (!String(error?.message || "").includes("Only a single")) {
+          throw error;
+        }
+      }).finally(() => {
+        offscreenSetup = null;
+      });
+    }
+    return offscreenSetup;
+  }
+  __name(ensureOffscreen, "ensureOffscreen");
+  async function downloadViaBlob(base64, mime, filename) {
+    await ensureOffscreen();
+    const created = await chrome.runtime.sendMessage({
+      target: "offscreen",
+      type: "CREATE_BLOB_URL",
+      base64,
+      mime
+    });
+    if (!created?.ok || !created.url) {
+      throw new Error(created?.error || "Failed to prepare download");
+    }
+    const url = created.url;
+    pendingDownloadNames.set(url, filename);
+    const cleanup = /* @__PURE__ */ __name(() => {
+      pendingDownloadNames.delete(url);
+      chrome.runtime.sendMessage({
+        target: "offscreen",
+        type: "REVOKE_BLOB_URL",
+        url
+      }).catch(() => {
+      });
+    }, "cleanup");
+    try {
+      const downloadId = await new Promise((resolve, reject) => {
+        chrome.downloads.download({
+          url,
+          filename,
+          conflictAction: "uniquify",
+          saveAs: false
+        }, (id) => {
+          const error = chrome.runtime.lastError;
+          error ? reject(new Error(error.message)) : resolve(id);
+        });
+      });
+      setTimeout(cleanup, 6e4);
+      return downloadId;
+    } catch (error) {
+      cleanup();
+      throw error;
+    }
+  }
+  __name(downloadViaBlob, "downloadViaBlob");
+  return {
+    downloadViaBlob
+  };
+}
+__name(createDownloader, "createDownloader");
+
+// src/session.ts
+function debuggerAttach(target, version) {
+  return new Promise((resolve, reject) => {
+    chrome.debugger.attach(target, version, () => {
+      const error = chrome.runtime.lastError;
+      error ? reject(new Error(error.message)) : resolve();
+    });
+  });
+}
+__name(debuggerAttach, "debuggerAttach");
+function debuggerDetach(target) {
+  return new Promise((resolve, reject) => {
+    chrome.debugger.detach(target, () => {
+      const error = chrome.runtime.lastError;
+      error ? reject(new Error(error.message)) : resolve();
+    });
+  });
+}
+__name(debuggerDetach, "debuggerDetach");
+function sendCommand(target, method, params) {
+  return new Promise((resolve, reject) => {
+    chrome.debugger.sendCommand(target, method, params || {}, (result) => {
+      const error = chrome.runtime.lastError;
+      error ? reject(new Error(error.message)) : resolve(result || {});
+    });
+  });
+}
+__name(sendCommand, "sendCommand");
+function waitForLoad(tabId, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = /* @__PURE__ */ __name((fn, value) => {
+      if (!settled) {
+        settled = true;
+        chrome.tabs.onUpdated.removeListener(listener);
+        clearTimeout(timer);
+        fn(value);
+      }
+    }, "finish");
+    const listener = /* @__PURE__ */ __name((updatedTabId, changeInfo) => {
+      if (updatedTabId === tabId && changeInfo.status === "complete") {
+        finish(resolve);
+      }
+    }, "listener");
+    const timer = setTimeout(() => finish(reject, new Error("Page load timeout")), timeoutMs);
+    chrome.tabs.onUpdated.addListener(listener);
+    chrome.tabs.get(tabId).then((tab) => {
+      if (tab.status === "complete") {
+        finish(resolve);
+      }
+    }).catch(() => {
+    });
+  });
+}
+__name(waitForLoad, "waitForLoad");
+function challengeError(name) {
+  const error = new Error(`Blocked by ${name} verification`);
+  error.isChallenge = true;
+  return error;
+}
+__name(challengeError, "challengeError");
+function isChallengeError(error) {
+  return Boolean(error?.isChallenge);
+}
+__name(isChallengeError, "isChallengeError");
+var CHALLENGE_TITLE_RE = /just a moment|checking your browser|attention required|verifying|security checkpoint|正在验证|安全检查点|verify you are human|are you a robot|请完成验证|人机验证|captcha/;
+async function probePage(target) {
+  const r = await sendCommand(target, "Runtime.evaluate", {
+    returnByValue: true,
+    expression: `(function(){
+      var uri=document.documentURI||"";
+      if(uri.indexOf("chrome-error://")===0) return {error:"Page failed to load (DNS or network error)",challenge:""};
+      var t=(document.title||"").toLowerCase();
+      var b=(document.body?document.body.innerText:"").slice(0,500).toLowerCase();
+      var u=(location.href||"").toLowerCase();
+      var s=t+" "+b+" "+u;
+      var c="";
+      if(/just a moment|checking your browser|attention required|cf-browser-verification|challenges\\.cloudflare/.test(s)) c="Cloudflare";
+      else if(/verifying your browser|\u6B63\u5728\u9A8C\u8BC1\u60A8\u7684\u6D4F\u89C8\u5668|security checkpoint|\u5B89\u5168\u68C0\u67E5\u70B9/.test(s)) c="Vercel";
+      else if(/verify you are human|are you a robot|\u8BF7\u5B8C\u6210\u9A8C\u8BC1|\u4EBA\u673A\u9A8C\u8BC1|captcha/.test(s)) c="bot-check";
+      return {error:"",challenge:c};
+    })()`
+  });
+  const value = r.result?.value;
+  return value || {
+    error: "",
+    challenge: ""
+  };
+}
+__name(probePage, "probePage");
+async function waitForVerification(tabId, shouldStop, timeoutMs = 18e4) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (shouldStop()) {
+      return false;
+    }
+    await delay(2500);
+    const tab = await chrome.tabs.get(tabId).catch(() => null);
+    if (!tab) {
+      return false;
+    }
+    const title = (tab.title || "").toLowerCase();
+    const url = (tab.url || "").toLowerCase();
+    if (url.startsWith("chrome-error")) {
+      continue;
+    }
+    if (title && !CHALLENGE_TITLE_RE.test(title)) {
+      return true;
+    }
+  }
+  return false;
+}
+__name(waitForVerification, "waitForVerification");
+async function focusTab(tabId) {
+  await chrome.tabs.update(tabId, {
+    active: true
+  }).catch(() => {
+  });
+  try {
+    const tab = await chrome.tabs.get(tabId);
+    if (tab.windowId != null) {
+      await chrome.windows.update(tab.windowId, {
+        focused: true
+      });
+    }
+  } catch {
+  }
+}
+__name(focusTab, "focusTab");
+function autoScroll(target) {
+  return sendCommand(target, "Runtime.evaluate", {
+    awaitPromise: true,
+    expression: `new Promise(function(resolve){
+      var distance=600, scrolled=0, guard=0;
+      var maxHeight=Math.min(document.body?document.body.scrollHeight:0, 20000);
+      var timer=setInterval(function(){
+        window.scrollBy(0, distance);
+        scrolled+=distance; guard+=1;
+        var reached=scrolled>=Math.max(maxHeight, document.body?document.body.scrollHeight:0);
+        if(reached || guard>60){
+          clearInterval(timer);
+          setTimeout(function(){ window.scrollTo(0,0); setTimeout(resolve, 400); }, 300);
+        }
+      }, 120);
+    })`
+  }).catch(() => void 0);
+}
+__name(autoScroll, "autoScroll");
+function revealAnimations(target, reversible = false) {
+  return sendCommand(target, "Runtime.evaluate", {
+    expression: `(function(){
+      try{
+        var reversible=${reversible ? "true" : "false"};
+        var state=reversible?{style:null,aos:[],inline:[]}:null;
+        var css=document.createElement('style');
+        css.textContent=[
+          '[data-aos]{opacity:1!important;transform:none!important;transition:none!important;}',
+          '.wow{visibility:visible!important;opacity:1!important;animation-name:none!important;}',
+          '.animate__animated,.animated{opacity:1!important;}',
+          '[data-scroll]{opacity:1!important;transform:none!important;}',
+          '.reveal,[data-sr],[data-sr-id],.sr-reveal{opacity:1!important;transform:none!important;visibility:visible!important;}'
+        ].join('');
+        (document.head||document.documentElement).appendChild(css);
+        if(state) state.style=css;
+        document.querySelectorAll('[data-aos]').forEach(function(el){
+          if(state&&!el.classList.contains('aos-animate')) state.aos.push(el);
+          el.classList.add('aos-animate');
+        });
+        // \u901A\u7528\u515C\u5E95\uFF1A\u88AB\u52A8\u753B\u85CF\u8D77\u6765\u7684\u5185\u5BB9\u5757\uFF08opacity\u22480 \u4E14\u5E26 transition/animation\uFF09\u5F3A\u5236\u663E\u793A\u3002
+        // \u53EA\u5904\u7406 static/relative\uFF08\u666E\u901A\u5185\u5BB9\u6D41\uFF09\uFF0C\u8DF3\u8FC7 fixed/absolute\uFF08\u591A\u4E3A\u5F39\u7A97/\u83DC\u5355/\u8F6E\u64AD\uFF09\uFF0C\u907F\u514D\u8BEF\u4F24
+        var all=document.body?document.body.querySelectorAll('*'):[];
+        for(var i=0;i<all.length;i++){
+          var el=all[i], s=getComputedStyle(el);
+          if(parseFloat(s.opacity)<0.05 && (s.transitionDuration!=='0s'||s.animationName!=='none')){
+            var p=s.position;
+            if(p==='static'||p==='relative'){
+              if(state) state.inline.push({
+                el:el,
+                opacity:el.style.getPropertyValue('opacity'),
+                opacityPriority:el.style.getPropertyPriority('opacity'),
+                transform:el.style.getPropertyValue('transform'),
+                transformPriority:el.style.getPropertyPriority('transform')
+              });
+              el.style.setProperty('opacity','1','important');
+              el.style.setProperty('transform','none','important');
+            }
+          }
+        }
+        if(state) window.__zuckerExtRevealState=state;
+      }catch(e){}
+    })()`
+  }).catch(() => void 0);
+}
+__name(revealAnimations, "revealAnimations");
+async function getScrollPosition(target) {
+  const result = await sendCommand(target, "Runtime.evaluate", {
+    returnByValue: true,
+    expression: `({ x: window.scrollX || 0, y: window.scrollY || 0 })`
+  });
+  const value = result.result?.value;
+  return value || {
+    x: 0,
+    y: 0
+  };
+}
+__name(getScrollPosition, "getScrollPosition");
+function restorePageAfterQuick(target, position) {
+  const x = Number(position?.x) || 0;
+  const y = Number(position?.y) || 0;
+  return sendCommand(target, "Runtime.evaluate", {
+    expression: `(function(){
+      try{
+        var state=window.__zuckerExtRevealState;
+        if(state){
+          if(state.style&&state.style.remove) state.style.remove();
+          (state.aos||[]).forEach(function(el){ el.classList.remove('aos-animate'); });
+          (state.inline||[]).forEach(function(saved){
+            if(saved.opacity) saved.el.style.setProperty('opacity',saved.opacity,saved.opacityPriority||'');
+            else saved.el.style.removeProperty('opacity');
+            if(saved.transform) saved.el.style.setProperty('transform',saved.transform,saved.transformPriority||'');
+            else saved.el.style.removeProperty('transform');
+          });
+          delete window.__zuckerExtRevealState;
+        }
+      }catch(e){}
+      window.scrollTo(${x}, ${y});
+    })()`
+  });
+}
+__name(restorePageAfterQuick, "restorePageAfterQuick");
+
+// src/engine.ts
+var LOAD_TIMEOUT_MS = 3e4;
+var SAME_HOST_MIN_GAP_MS = 1800;
+var DEFAULT_TEXTS = {
+  alreadyRunning: "Another capture is already running",
+  cannotQuick: "This page cannot be captured. Open an http(s) website first.",
+  challengeBeforeQuick: /* @__PURE__ */ __name((challenge) => `Complete the ${challenge} verification before capturing this page.`, "challengeBeforeQuick"),
+  quickFolder: "Quick Captures"
+};
+function initExtension(config) {
+  const texts = {
+    ...DEFAULT_TEXTS,
+    ...config.texts || {}
+  };
+  const freeDailyLimit = config.freeDailyLimit ?? 30;
+  const USAGE_KEY = `${config.product}_free_usage`;
+  const BATCH_KEY = `${config.product}_batch_state`;
+  const prefix = config.messagePrefix;
+  const licensing = createLicensing(config.product, config.brand, config.licensing);
+  const downloader = createDownloader(`Convert large ${config.brand} output into a downloadable blob URL.`);
+  let batch = idleBatch();
+  let restorePromise = restoreBatch();
+  let quickRunning = false;
+  chrome.runtime.onInstalled.addListener(() => {
+    const previousRestore = restorePromise;
+    restorePromise = (async () => {
+      await previousRestore.catch(() => {
+      });
+      batch = idleBatch();
+      await storageRemove(BATCH_KEY);
+      setBadge("");
+    })();
+  });
+  chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
+    if (message?.target === "offscreen") {
+      return false;
+    }
+    handleMessage(message).then(sendResponse).catch((error) => sendResponse({
+      ok: false,
+      error: normalizeError(error)
+    }));
+    return true;
+  });
+  function idleBatch() {
+    return {
+      running: false,
+      cancelRequested: false,
+      startedAt: null,
+      folder: "",
+      total: 0,
+      done: 0,
+      success: 0,
+      failed: 0,
+      current: "",
+      freeLimited: false,
+      needVerify: null,
+      skipVerify: false,
+      settings: {
+        ...config.defaultSettings
+      },
+      pro: false,
+      items: []
+    };
+  }
+  __name(idleBatch, "idleBatch");
+  async function handleMessage(message) {
+    await restorePromise;
+    switch (message.type) {
+      case `${prefix}_START`:
+        return startBatch(message.urls, message.settings);
+      // 两个后缀都接受：CAPTURE_CURRENT（截图类）/ CONVERT_CURRENT（转换类），兼容既有 popup
+      case `${prefix}_CAPTURE_CURRENT`:
+      case `${prefix}_CONVERT_CURRENT`:
+        return quickCapture(message.tabId, message.settings);
+      case `${prefix}_CANCEL`:
+        return cancelBatch();
+      case `${prefix}_CLEAR_BATCH`:
+        return clearBatch();
+      case `${prefix}_SKIP_VERIFY`:
+        batch.skipVerify = true;
+        await persistBatch();
+        return {
+          ok: true
+        };
+      case `${prefix}_STATE`:
+        return {
+          ok: true,
+          batch: publicBatch(),
+          quota: await getQuota()
+        };
+      case `${prefix}_ACTIVATE`:
+        await licensing.activate(message.code);
+        return {
+          ok: true,
+          quota: await getQuota()
+        };
+      case `${prefix}_CLEAR_LICENSE`:
+        await licensing.clear();
+        return {
+          ok: true,
+          quota: await getQuota()
+        };
+      default:
+        return {
+          ok: false,
+          error: "Unknown message"
+        };
+    }
+  }
+  __name(handleMessage, "handleMessage");
+  async function getQuota() {
+    const entitlement = await licensing.getEntitlement().catch(() => null);
+    if (entitlement) {
+      return {
+        pro: true,
+        expiresAt: entitlement.expiresAt,
+        limit: null,
+        used: 0,
+        remaining: 999999
+      };
+    }
+    const data = await storageGet(USAGE_KEY);
+    const usage = data[USAGE_KEY];
+    const today = todayString();
+    const used = usage && usage.date === today ? usage.used || 0 : 0;
+    return {
+      pro: false,
+      limit: freeDailyLimit,
+      used,
+      remaining: Math.max(0, freeDailyLimit - used)
+    };
+  }
+  __name(getQuota, "getQuota");
+  async function recordUsage(count) {
+    const data = await storageGet(USAGE_KEY);
+    const today = todayString();
+    const usage = data[USAGE_KEY];
+    const used = usage && usage.date === today ? usage.used || 0 : 0;
+    await storageSet({
+      [USAGE_KEY]: {
+        date: today,
+        used: used + count
+      }
+    });
+  }
+  __name(recordUsage, "recordUsage");
+  async function startBatch(urls, settings) {
+    if (batch.running || quickRunning) {
+      return {
+        ok: false,
+        error: texts.alreadyRunning
+      };
+    }
+    const normalized = normalizeUrls(urls);
+    if (!normalized.length) {
+      return {
+        ok: false,
+        error: "No valid http(s) URLs"
+      };
+    }
+    const quota = await getQuota();
+    if (!quota.pro && quota.remaining <= 0) {
+      return {
+        ok: false,
+        error: `Daily free limit reached (${quota.limit} pages/day). Go Pro for unlimited pages.`
+      };
+    }
+    const freeLimited = !quota.pro && normalized.length > quota.remaining;
+    const accepted = quota.pro ? normalized : normalized.slice(0, quota.remaining);
+    const options = {
+      ...config.defaultSettings,
+      ...settings || {}
+    };
+    batch = {
+      ...idleBatch(),
+      running: true,
+      startedAt: Date.now(),
+      folder: `${config.brand}/${folderNameFor(accepted)}`,
+      total: accepted.length,
+      freeLimited,
+      settings: options,
+      pro: quota.pro,
+      items: accepted.map((url, index) => ({
+        url,
+        index: index + 1,
+        status: "pending",
+        fileName: "",
+        error: "",
+        warning: "",
+        usageRecorded: false
+      }))
+    };
+    await persistBatch();
+    runBatch(options).catch((error) => {
+      batch.running = false;
+      batch.current = normalizeError(error);
+      persistBatch();
+    });
+    return {
+      ok: true,
+      batch: publicBatch(),
+      quota: await getQuota()
+    };
+  }
+  __name(startBatch, "startBatch");
+  async function quickCapture(tabId, settings) {
+    if (batch.running || quickRunning) {
+      return {
+        ok: false,
+        error: texts.alreadyRunning
+      };
+    }
+    if (!Number.isInteger(tabId)) {
+      return {
+        ok: false,
+        error: "No active web page"
+      };
+    }
+    const tab = await chrome.tabs.get(tabId).catch(() => null);
+    if (!tab?.url || !/^https?:\/\//i.test(tab.url)) {
+      return {
+        ok: false,
+        error: texts.cannotQuick
+      };
+    }
+    const quota = await getQuota();
+    if (!quota.pro && quota.remaining <= 0) {
+      return {
+        ok: false,
+        error: `Daily free limit reached (${quota.limit} pages/day). Go Pro for unlimited pages.`
+      };
+    }
+    quickRunning = true;
+    setBadge("1");
+    try {
+      const options = {
+        ...config.defaultSettings,
+        ...settings || {}
+      };
+      const result = await captureExistingTab(tabId, tab.url, options);
+      if (!quota.pro) {
+        await recordUsage(1);
+      }
+      setBadge("OK");
+      setTimeout(() => setBadge(""), 4e3);
+      return {
+        ok: true,
+        result,
+        quota: await getQuota()
+      };
+    } catch (error) {
+      setBadge("ERR");
+      setTimeout(() => setBadge(""), 4e3);
+      return {
+        ok: false,
+        error: normalizeError(error),
+        quota: await getQuota()
+      };
+    } finally {
+      quickRunning = false;
+    }
+  }
+  __name(quickCapture, "quickCapture");
+  async function captureExistingTab(tabId, pageUrl, options) {
+    const target = {
+      tabId
+    };
+    let attached = false;
+    let scrollPosition = {
+      x: 0,
+      y: 0
+    };
+    try {
+      await debuggerAttach(target, "1.3");
+      attached = true;
+      await sendCommand(target, "Page.enable");
+      await sendCommand(target, "Runtime.enable");
+      const probe = await probePage(target);
+      if (probe.error) {
+        throw new Error(probe.error);
+      }
+      if (probe.challenge) {
+        throw new Error(texts.challengeBeforeQuick(probe.challenge));
+      }
+      scrollPosition = await getScrollPosition(target);
+      await delay(clamp(Number(options.delayMs) || Number(config.defaultSettings.delayMs) || 1500, 0, 1e4));
+      await autoScroll(target);
+      await revealAnimations(target, true);
+      await delay(400);
+      const output = await config.capture(makeContext("quick", tabId, pageUrl, options, target));
+      const fileName = buildQuickFileName(config.brand, texts.quickFolder, pageUrl, output.extension);
+      await downloader.downloadViaBlob(output.base64, output.mime, fileName);
+      return {
+        fileName,
+        warning: output.warning || ""
+      };
+    } finally {
+      if (attached) {
+        await restorePageAfterQuick(target, scrollPosition).catch(() => {
+        });
+        await debuggerDetach(target).catch(() => {
+        });
+      }
+    }
+  }
+  __name(captureExistingTab, "captureExistingTab");
+  async function cancelBatch() {
+    if (batch.running) {
+      batch.cancelRequested = true;
+      batch.current = "Stopping\u2026";
+      await persistBatch();
+    }
+    return {
+      ok: true,
+      batch: publicBatch()
+    };
+  }
+  __name(cancelBatch, "cancelBatch");
+  async function clearBatch() {
+    if (batch.running) {
+      return {
+        ok: false,
+        error: "Stop the running batch before clearing it"
+      };
+    }
+    batch = idleBatch();
+    await storageRemove(BATCH_KEY);
+    setBadge("");
+    return {
+      ok: true,
+      batch: publicBatch()
+    };
+  }
+  __name(clearBatch, "clearBatch");
+  async function runBatch(options) {
+    const lastHostAt = {};
+    for (const item of batch.items) {
+      if (item.status !== "pending") {
+        continue;
+      }
+      if (batch.cancelRequested) {
+        break;
+      }
+      const host = hostOf(item.url);
+      const since = Date.now() - (lastHostAt[host] || 0);
+      if (lastHostAt[host] && since < SAME_HOST_MIN_GAP_MS) {
+        batch.current = "Pacing to avoid rate-limits\u2026";
+        await delay(SAME_HOST_MIN_GAP_MS - since);
+        if (batch.cancelRequested) {
+          break;
+        }
+      }
+      lastHostAt[host] = Date.now();
+      item.status = "running";
+      batch.current = item.url;
+      setBadge(`${batch.done + 1}/${batch.total}`);
+      await persistBatch();
+      let shouldCharge = false;
+      try {
+        const result = await captureUrl(item, options);
+        item.fileName = result.fileName;
+        item.warning = result.warning;
+        item.status = "success";
+        batch.success += 1;
+        if (!batch.pro && !item.usageRecorded) {
+          item.usageRecorded = true;
+          shouldCharge = true;
+        }
+      } catch (error) {
+        item.status = "failed";
+        item.error = normalizeError(error);
+        batch.failed += 1;
+      }
+      batch.done = batch.success + batch.failed;
+      await persistBatch();
+      if (shouldCharge) {
+        await recordUsage(1);
+      }
+    }
+    batch.running = false;
+    batch.current = batch.cancelRequested ? "Stopped" : "Done";
+    batch.needVerify = null;
+    await persistBatch();
+    setBadge(batch.failed ? "ERR" : "OK");
+    setTimeout(() => setBadge(""), 4e3);
+  }
+  __name(runBatch, "runBatch");
+  async function captureUrl(item, options) {
+    const maxChallengeRetry = 2;
+    let lastError;
+    for (let attempt = 0; attempt <= maxChallengeRetry; attempt += 1) {
+      if (batch.cancelRequested) {
+        throw new Error("Cancelled");
+      }
+      try {
+        return await captureOnce(item, options, false);
+      } catch (error) {
+        lastError = error;
+        if (!isChallengeError(error)) {
+          throw error;
+        }
+        if (attempt < maxChallengeRetry) {
+          const backoff = 8e3 * (attempt + 1);
+          batch.current = `Rate-limited \u2014 cooling down ${backoff / 1e3}s (retry ${attempt + 1}/${maxChallengeRetry})`;
+          await delay(backoff);
+        }
+      }
+    }
+    if (isChallengeError(lastError) && !batch.cancelRequested) {
+      return await captureOnce(item, options, true);
+    }
+    throw lastError;
+  }
+  __name(captureUrl, "captureUrl");
+  async function captureOnce(item, options, interactive) {
+    const tab = await chrome.tabs.create({
+      url: item.url,
+      active: Boolean(interactive)
+    });
+    const tabId = tab.id;
+    if (!tabId) {
+      throw new Error("Could not open tab");
+    }
+    const target = {
+      tabId
+    };
+    let attached = false;
+    try {
+      await waitForLoad(tabId, LOAD_TIMEOUT_MS);
+      await delay(Number(options.delayMs) || 0);
+      if (batch.cancelRequested) {
+        throw new Error("Cancelled");
+      }
+      await debuggerAttach(target, "1.3");
+      attached = true;
+      await sendCommand(target, "Page.enable");
+      await sendCommand(target, "Runtime.enable");
+      const probe = await probePage(target);
+      if (probe.error) {
+        throw new Error(probe.error);
+      }
+      if (probe.challenge) {
+        if (!interactive) {
+          throw challengeError(probe.challenge);
+        }
+        await debuggerDetach(target).catch(() => {
+        });
+        attached = false;
+        await focusTab(tabId);
+        batch.needVerify = {
+          url: item.url,
+          challenge: probe.challenge
+        };
+        batch.current = `Complete ${probe.challenge} verification in the opened tab\u2026`;
+        await persistBatch();
+        batch.skipVerify = false;
+        const passed = await waitForVerification(tabId, () => batch.cancelRequested || batch.skipVerify);
+        batch.needVerify = null;
+        batch.current = item.url;
+        await persistBatch();
+        if (!passed) {
+          throw challengeError(`${probe.challenge} verification not completed`);
+        }
+        await delay(800);
+        await debuggerAttach(target, "1.3");
+        attached = true;
+        await sendCommand(target, "Page.enable");
+        await sendCommand(target, "Runtime.enable");
+      }
+      const ctx = makeContext("batch", tabId, item.url, options, target);
+      if (config.beforeScroll) {
+        await config.beforeScroll(ctx);
+      }
+      await autoScroll(target);
+      await revealAnimations(target);
+      await delay(400);
+      const output = await config.capture(ctx);
+      const fileName = buildBatchFileName(batch.folder, item, output.extension);
+      await downloader.downloadViaBlob(output.base64, output.mime, fileName);
+      return {
+        fileName,
+        warning: output.warning || ""
+      };
+    } finally {
+      if (attached) {
+        await debuggerDetach(target).catch(() => {
+        });
+      }
+      await chrome.tabs.remove(tabId).catch(() => {
+      });
+    }
+  }
+  __name(captureOnce, "captureOnce");
+  function makeContext(mode, tabId, url, options, target) {
+    return {
+      mode,
+      tabId,
+      url,
+      options,
+      send: /* @__PURE__ */ __name((method, params) => sendCommand(target, method, params), "send")
+    };
+  }
+  __name(makeContext, "makeContext");
+  function publicBatch() {
+    return {
+      running: batch.running,
+      total: batch.total,
+      done: batch.done,
+      success: batch.success,
+      failed: batch.failed,
+      current: batch.current,
+      folder: batch.folder,
+      freeLimited: batch.freeLimited,
+      needVerify: batch.needVerify,
+      items: batch.items.map((item) => ({
+        url: item.url,
+        index: item.index,
+        status: item.status,
+        fileName: item.fileName,
+        error: item.error,
+        warning: item.warning
+      }))
+    };
+  }
+  __name(publicBatch, "publicBatch");
+  async function persistBatch() {
+    await storageSet({
+      [BATCH_KEY]: batch
+    });
+  }
+  __name(persistBatch, "persistBatch");
+  async function restoreBatch() {
+    const data = await storageGet(BATCH_KEY);
+    const saved = data[BATCH_KEY];
+    if (!saved?.items?.length) {
+      return;
+    }
+    batch = {
+      ...idleBatch(),
+      ...saved
+    };
+    batch.settings = {
+      ...config.defaultSettings,
+      ...saved.settings || {}
+    };
+    batch.items = saved.items.map((item) => ({
+      url: item.url || "",
+      index: item.index || 0,
+      status: item.status === "running" ? "pending" : item.status || "pending",
+      fileName: item.fileName || "",
+      error: item.error || "",
+      warning: item.warning || "",
+      usageRecorded: item.usageRecorded || false
+    }));
+    batch.done = batch.items.filter((item) => item.status === "success" || item.status === "failed").length;
+    batch.success = batch.items.filter((item) => item.status === "success").length;
+    batch.failed = batch.items.filter((item) => item.status === "failed").length;
+    batch.needVerify = null;
+    batch.skipVerify = false;
+    if (saved.running && batch.items.some((item) => item.status === "pending")) {
+      batch.running = true;
+      batch.cancelRequested = false;
+      batch.current = "Resuming interrupted batch\u2026";
+      await persistBatch();
+      runBatch(batch.settings).catch(async (error) => {
+        batch.running = false;
+        batch.current = normalizeError(error);
+        await persistBatch();
+      });
+    } else if (saved.running) {
+      batch.running = false;
+      batch.current = "Done";
+      await persistBatch();
+    }
+  }
+  __name(restoreBatch, "restoreBatch");
+  function setBadge(text) {
+    chrome.action.setBadgeText({
+      text
+    });
+    chrome.action.setBadgeBackgroundColor({
+      color: config.badgeColor
+    });
+  }
+  __name(setBadge, "setBadge");
+}
+__name(initExtension, "initExtension");
+
+// src/popup.ts
+function initPopup(config) {
+  const byId = /* @__PURE__ */ __name((id) => document.getElementById(id), "byId");
+  const el = {
+    urls: byId("urls"),
+    urlCount: byId("urlCount"),
+    addUrls: byId("addUrls"),
+    scanSite: byId("scanSite"),
+    queueSummary: byId("queueSummary"),
+    queueList: byId("queueList"),
+    selectAll: byId("selectAll"),
+    selectNone: byId("selectNone"),
+    moreQueueActions: byId("moreQueueActions"),
+    queueMenu: byId("queueMenu"),
+    removeUnselected: byId("removeUnselected"),
+    clearQueue: byId("clearQueue"),
+    captureCurrent: byId(config.quickButtonId || "captureCurrent"),
+    start: byId("start"),
+    cancel: byId("cancel"),
+    progressWrap: byId("progressWrap"),
+    progressText: byId("progressText"),
+    progressCurrent: byId("progressCurrent"),
+    clearBatch: byId("clearBatch"),
+    progressBar: byId("progressBar"),
+    resultList: byId("resultList"),
+    verifyBanner: byId("verifyBanner"),
+    verifyText: byId("verifyText"),
+    skipVerify: byId("skipVerify"),
+    folderNote: byId("folderNote"),
+    quotaText: byId("quotaText"),
+    proLink: byId("proLink"),
+    haveCode: byId("haveCode"),
+    licensePanel: byId("licensePanel"),
+    licenseCode: byId("licenseCode"),
+    activateBtn: byId("activateBtn"),
+    deactivateBtn: byId("deactivateBtn"),
+    status: byId("status")
+  };
+  let pollTimer = null;
+  let queue = [];
+  let queueLocked = false;
+  const prefix = config.messagePrefix;
+  void init();
+  async function init() {
+    el.urls.addEventListener("input", updateUrlCount);
+    el.addUrls.addEventListener("click", addInputUrls);
+    el.scanSite.addEventListener("click", scanCurrentSite);
+    el.selectAll.addEventListener("click", () => setAllSelected(true));
+    el.selectNone.addEventListener("click", () => setAllSelected(false));
+    el.moreQueueActions.addEventListener("click", () => el.queueMenu.classList.toggle("hidden"));
+    el.removeUnselected.addEventListener("click", removeUnselected);
+    el.clearQueue.addEventListener("click", clearQueue);
+    el.captureCurrent.addEventListener("click", quickCapture);
+    el.start.addEventListener("click", startBatch);
+    el.cancel.addEventListener("click", cancelBatch);
+    el.clearBatch.addEventListener("click", clearBatchResults);
+    el.skipVerify.addEventListener("click", () => send({
+      type: `${prefix}_SKIP_VERIFY`
+    }));
+    el.haveCode.addEventListener("click", () => el.licensePanel.classList.toggle("hidden"));
+    el.activateBtn.addEventListener("click", activateLicense);
+    el.deactivateBtn.addEventListener("click", deactivateLicense);
+    await loadQueue();
+    updateUrlCount();
+    renderQueue();
+    await refreshState();
+  }
+  __name(init, "init");
+  async function activateLicense() {
+    const code = el.licenseCode.value.trim();
+    if (!code) {
+      setStatus("Paste your activation code first", true);
+      return;
+    }
+    el.activateBtn.disabled = true;
+    setStatus("Activating\u2026");
+    const response = await send({
+      type: `${prefix}_ACTIVATE`,
+      code
+    });
+    el.activateBtn.disabled = false;
+    if (!response.ok) {
+      setStatus(response.error || "Activation failed", true);
+      return;
+    }
+    el.licenseCode.value = "";
+    el.licensePanel.classList.add("hidden");
+    renderQuota(response.quota);
+    setStatus("Pro activated \u2014 enjoy unlimited pages!");
+  }
+  __name(activateLicense, "activateLicense");
+  async function deactivateLicense() {
+    const response = await send({
+      type: `${prefix}_CLEAR_LICENSE`
+    });
+    if (response.ok) {
+      renderQuota(response.quota);
+      setStatus("License removed from this device");
+    }
+  }
+  __name(deactivateLicense, "deactivateLicense");
+  function parseUrls() {
+    return normalizeInputUrls(el.urls.value.split(/\s+/));
+  }
+  __name(parseUrls, "parseUrls");
+  function updateUrlCount() {
+    el.urlCount.textContent = String(parseUrls().length);
+  }
+  __name(updateUrlCount, "updateUrlCount");
+  function normalizeInputUrls(values) {
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const value of values) {
+      try {
+        const url = new URL(String(value || "").trim());
+        if (!/^https?:$/.test(url.protocol)) {
+          continue;
+        }
+        url.hash = "";
+        const normalized = url.toString();
+        if (!seen.has(normalized)) {
+          seen.add(normalized);
+          out.push(normalized);
+        }
+      } catch {
+      }
+    }
+    return out;
+  }
+  __name(normalizeInputUrls, "normalizeInputUrls");
+  function addInputUrls() {
+    const urls = parseUrls();
+    if (!urls.length) {
+      setStatus("Paste at least one valid http(s) URL", true);
+      return;
+    }
+    const added = addUrlsToQueue(urls);
+    el.urls.value = "";
+    updateUrlCount();
+    setStatus(added ? `Added ${added} URL${added === 1 ? "" : "s"} to the queue` : "Those URLs are already in the queue");
+  }
+  __name(addInputUrls, "addInputUrls");
+  function addUrlsToQueue(urls) {
+    const existing = new Set(queue.map((item) => item.url));
+    let added = 0;
+    for (const url of normalizeInputUrls(urls)) {
+      if (!existing.has(url) && queue.length < 500) {
+        queue.push({
+          url,
+          selected: true
+        });
+        existing.add(url);
+        added += 1;
+      }
+    }
+    if (added) {
+      saveQueue();
+      renderQueue();
+    }
+    return added;
+  }
+  __name(addUrlsToQueue, "addUrlsToQueue");
+  async function scanCurrentSite() {
+    setStatus("Scanning current tab\u2026");
+    try {
+      const [tab] = await chrome.tabs.query({
+        active: true,
+        currentWindow: true
+      });
+      if (!tab?.id) {
+        throw new Error("No active tab");
+      }
+      const [result] = await chrome.scripting.executeScript({
+        target: {
+          tabId: tab.id
+        },
+        func: collectSameOriginLinks
+      });
+      const scan = result?.result || {
+        urls: [],
+        sitemapCount: 0
+      };
+      const found = scan.urls || [];
+      if (!found.length) {
+        setStatus("No same-site links found on this page", true);
+        return;
+      }
+      const added = addUrlsToQueue(found);
+      const sitemapNote = scan.sitemapCount ? `, including ${scan.sitemapCount} from sitemap` : "";
+      setStatus(`Found ${found.length} same-site URLs${sitemapNote}; added ${added} new`);
+    } catch (error) {
+      setStatus(errText(error), true);
+    }
+  }
+  __name(scanCurrentSite, "scanCurrentSite");
+  async function startBatch() {
+    const urls = queue.filter((item) => item.selected).map((item) => item.url);
+    if (!urls.length) {
+      setStatus("Select at least one URL from the queue", true);
+      return;
+    }
+    el.start.disabled = true;
+    setStatus("Starting\u2026");
+    const response = await send({
+      type: `${prefix}_START`,
+      urls,
+      settings: config.collectSettings()
+    });
+    el.start.disabled = false;
+    if (!response.ok) {
+      setStatus(response.error || "Failed to start", true);
+      return;
+    }
+    renderBatch(response.batch);
+    renderQuota(response.quota);
+    schedulePoll();
+    setStatus(response.batch?.freeLimited ? "Started (list truncated to today's free quota)" : "Batch started");
+  }
+  __name(startBatch, "startBatch");
+  async function quickCapture() {
+    const [tab] = await chrome.tabs.query({
+      active: true,
+      currentWindow: true
+    });
+    if (!tab?.id || !/^https?:\/\//i.test(tab.url || "")) {
+      setStatus("Open an http(s) website first", true);
+      return;
+    }
+    el.captureCurrent.disabled = true;
+    el.start.disabled = true;
+    setStatus(config.texts.quickIng);
+    const response = await send({
+      type: `${prefix}_${config.quickType}`,
+      tabId: tab.id,
+      settings: config.collectQuickSettings()
+    });
+    el.captureCurrent.disabled = false;
+    renderQueue();
+    if (!response.ok || !response.result) {
+      setStatus(response.error || config.texts.quickFailed, true);
+      return;
+    }
+    renderQuota(response.quota);
+    setStatus(config.quickResult(response.result));
+  }
+  __name(quickCapture, "quickCapture");
+  async function cancelBatch() {
+    const response = await send({
+      type: `${prefix}_CANCEL`
+    });
+    if (response.ok) {
+      renderBatch(response.batch);
+    }
+  }
+  __name(cancelBatch, "cancelBatch");
+  async function clearBatchResults() {
+    const response = await send({
+      type: `${prefix}_CLEAR_BATCH`
+    });
+    if (!response.ok) {
+      setStatus(response.error || "Could not clear results", true);
+      return;
+    }
+    renderBatch(response.batch);
+    setStatus("Batch results cleared");
+  }
+  __name(clearBatchResults, "clearBatchResults");
+  async function refreshState() {
+    const response = await send({
+      type: `${prefix}_STATE`
+    });
+    if (!response.ok) {
+      return;
+    }
+    renderQuota(response.quota);
+    renderBatch(response.batch);
+    if (response.batch?.running) {
+      schedulePoll();
+    }
+  }
+  __name(refreshState, "refreshState");
+  function schedulePoll() {
+    if (pollTimer) {
+      clearInterval(pollTimer);
+    }
+    pollTimer = setInterval(async () => {
+      const response = await send({
+        type: `${prefix}_STATE`
+      });
+      if (!response.ok) {
+        return;
+      }
+      renderQuota(response.quota);
+      renderBatch(response.batch);
+      if (!response.batch?.running && pollTimer) {
+        clearInterval(pollTimer);
+      }
+    }, 800);
+  }
+  __name(schedulePoll, "schedulePoll");
+  function renderQuota(quota) {
+    if (!quota) {
+      return;
+    }
+    if (quota.pro) {
+      const until = quota.expiresAt ? ` \xB7 ${String(quota.expiresAt).slice(0, 10)}` : "";
+      el.quotaText.textContent = `unlimited${until}`;
+      el.proLink.classList.add("hidden");
+      el.deactivateBtn.classList.remove("hidden");
+      el.activateBtn.classList.add("hidden");
+    } else {
+      el.quotaText.textContent = `${quota.remaining}/${quota.limit} today`;
+      el.proLink.classList.remove("hidden");
+      el.deactivateBtn.classList.add("hidden");
+      el.activateBtn.classList.remove("hidden");
+    }
+  }
+  __name(renderQuota, "renderQuota");
+  function renderBatch(batch) {
+    if (!batch) {
+      return;
+    }
+    el.start.classList.toggle("hidden", batch.running);
+    el.captureCurrent.classList.toggle("hidden", batch.running);
+    el.cancel.classList.toggle("hidden", !batch.running);
+    queueLocked = batch.running;
+    renderQueue();
+    el.progressWrap.classList.toggle("hidden", !batch.total);
+    el.clearBatch.classList.toggle("hidden", batch.running || !batch.total);
+    if (batch.total) {
+      el.progressText.textContent = `${batch.done} / ${batch.total}`;
+      el.progressCurrent.textContent = batch.current || "";
+      el.progressBar.style.width = `${batch.total ? Math.round(batch.done / batch.total * 100) : 0}%`;
+    }
+    const verify = batch.needVerify;
+    el.verifyBanner.classList.toggle("hidden", !verify);
+    if (verify) {
+      el.verifyText.textContent = `${verify.challenge} \xB7 ${verify.url.replace(/^https?:\/\//, "")}`;
+    }
+    el.resultList.replaceChildren();
+    for (const item of batch.items) {
+      const rowEl = document.createElement("div");
+      rowEl.className = "resultItem";
+      const state = document.createElement("span");
+      state.className = `state ${item.status}`;
+      state.textContent = {
+        pending: "\xB7",
+        running: "\u2026",
+        success: "\u2713",
+        failed: "\u2717"
+      }[item.status] || "\xB7";
+      const url = document.createElement("span");
+      url.className = "url";
+      url.textContent = item.url.replace(/^https?:\/\//, "");
+      rowEl.append(state, url);
+      if (item.error) {
+        const err = document.createElement("span");
+        err.className = "err";
+        err.textContent = item.error.slice(0, 60);
+        rowEl.append(err);
+      }
+      if (item.warning) {
+        const warning = document.createElement("span");
+        warning.className = "warning";
+        warning.textContent = item.warning.slice(0, 100);
+        rowEl.append(warning);
+      }
+      el.resultList.append(rowEl);
+    }
+    if (batch.folder && batch.done > 0) {
+      el.folderNote.classList.remove("hidden");
+      el.folderNote.textContent = `Saved to Downloads/${batch.folder}/`;
+    } else {
+      el.folderNote.classList.add("hidden");
+      el.folderNote.textContent = "";
+    }
+  }
+  __name(renderBatch, "renderBatch");
+  async function loadQueue() {
+    const data = await chrome.storage.local.get(config.queueKey);
+    const saved = Array.isArray(data[config.queueKey]) ? data[config.queueKey] : [];
+    queue = saved.filter((item) => item && typeof item.url === "string").slice(0, 500).map((item) => ({
+      url: item.url,
+      selected: item.selected !== false
+    }));
+  }
+  __name(loadQueue, "loadQueue");
+  function saveQueue() {
+    void chrome.storage.local.set({
+      [config.queueKey]: queue
+    });
+  }
+  __name(saveQueue, "saveQueue");
+  function renderQueue() {
+    const selected = queue.filter((item) => item.selected).length;
+    el.queueSummary.textContent = `${selected}/${queue.length} selected`;
+    el.start.textContent = selected ? config.texts.startSome(selected) : config.texts.startNone;
+    el.start.disabled = selected === 0;
+    el.selectAll.disabled = queueLocked || !queue.length;
+    el.selectNone.disabled = queueLocked || !queue.length;
+    el.moreQueueActions.disabled = queueLocked || !queue.length;
+    el.addUrls.disabled = queueLocked;
+    el.scanSite.disabled = queueLocked;
+    el.captureCurrent.disabled = queueLocked;
+    el.queueList.replaceChildren();
+    if (!queue.length) {
+      const empty = document.createElement("p");
+      empty.className = "queueEmpty";
+      empty.textContent = "Add URLs or scan the current site to begin.";
+      el.queueList.append(empty);
+      return;
+    }
+    queue.forEach((item, index) => {
+      const row = document.createElement("div");
+      row.className = `queueItem${item.selected ? "" : " unselected"}`;
+      const checkbox = document.createElement("input");
+      checkbox.type = "checkbox";
+      checkbox.checked = item.selected;
+      checkbox.disabled = queueLocked;
+      checkbox.setAttribute("aria-label", `Include ${item.url}`);
+      checkbox.addEventListener("change", () => {
+        item.selected = checkbox.checked;
+        saveQueue();
+        renderQueue();
+      });
+      const url = document.createElement("button");
+      url.type = "button";
+      url.className = "queueUrl";
+      url.textContent = item.url.replace(/^https?:\/\//, "");
+      url.title = item.url;
+      url.disabled = queueLocked;
+      url.addEventListener("click", () => editQueueItem(index));
+      const remove = document.createElement("button");
+      remove.type = "button";
+      remove.className = "queueRemove";
+      remove.textContent = "\xD7";
+      remove.title = "Remove URL";
+      remove.disabled = queueLocked;
+      remove.addEventListener("click", () => {
+        queue.splice(index, 1);
+        saveQueue();
+        renderQueue();
+      });
+      row.append(checkbox, url, remove);
+      el.queueList.append(row);
+    });
+  }
+  __name(renderQueue, "renderQueue");
+  function editQueueItem(index) {
+    const current = queue[index];
+    const value = prompt("Edit URL", current.url);
+    if (value === null) {
+      return;
+    }
+    const [normalized] = normalizeInputUrls([
+      value
+    ]);
+    if (!normalized) {
+      setStatus("Enter a valid http(s) URL", true);
+      return;
+    }
+    if (queue.some((item, itemIndex) => itemIndex !== index && item.url === normalized)) {
+      setStatus("That URL is already in the queue", true);
+      return;
+    }
+    current.url = normalized;
+    saveQueue();
+    renderQueue();
+  }
+  __name(editQueueItem, "editQueueItem");
+  function setAllSelected(selected) {
+    if (queueLocked) {
+      return;
+    }
+    queue.forEach((item) => {
+      item.selected = selected;
+    });
+    saveQueue();
+    renderQueue();
+  }
+  __name(setAllSelected, "setAllSelected");
+  function removeUnselected() {
+    queue = queue.filter((item) => item.selected);
+    el.queueMenu.classList.add("hidden");
+    saveQueue();
+    renderQueue();
+  }
+  __name(removeUnselected, "removeUnselected");
+  function clearQueue() {
+    queue = [];
+    el.queueMenu.classList.add("hidden");
+    saveQueue();
+    renderQueue();
+  }
+  __name(clearQueue, "clearQueue");
+  function send(message) {
+    return new Promise((resolve) => {
+      chrome.runtime.sendMessage(message, (response) => {
+        const error = chrome.runtime.lastError;
+        resolve(error ? {
+          ok: false,
+          error: error.message
+        } : response || {
+          ok: false,
+          error: "No response"
+        });
+      });
+    });
+  }
+  __name(send, "send");
+  function setStatus(text, isError = false) {
+    el.status.textContent = text;
+    el.status.classList.toggle("error", isError);
+  }
+  __name(setStatus, "setStatus");
+  function errText(error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+  __name(errText, "errText");
+}
+__name(initPopup, "initPopup");
+async function collectSameOriginLinks() {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const origin = location.origin;
+  let sitemapCount = 0;
+  const add = /* @__PURE__ */ __name((value) => {
+    try {
+      const url = new URL(value || "", location.href);
+      url.hash = "";
+      if (url.origin === origin && /^https?:$/.test(url.protocol) && !seen.has(url.toString()) && out.length < 500) {
+        seen.add(url.toString());
+        out.push(url.toString());
+        return true;
+      }
+    } catch {
+    }
+    return false;
+  }, "add");
+  add(location.href);
+  for (const a of document.querySelectorAll("a[href]")) {
+    add(a.getAttribute("href"));
+    if (out.length >= 500) {
+      break;
+    }
+  }
+  const sitemapQueue = [
+    new URL("/sitemap.xml", origin).toString()
+  ];
+  const visitedSitemaps = /* @__PURE__ */ new Set();
+  while (sitemapQueue.length && visitedSitemaps.size < 8 && out.length < 500) {
+    const sitemapUrl = sitemapQueue.shift();
+    if (visitedSitemaps.has(sitemapUrl)) {
+      continue;
+    }
+    visitedSitemaps.add(sitemapUrl);
+    try {
+      const response = await fetch(sitemapUrl, {
+        credentials: "same-origin"
+      });
+      if (!response.ok) {
+        continue;
+      }
+      const xml = new DOMParser().parseFromString(await response.text(), "application/xml");
+      for (const loc of xml.querySelectorAll("loc")) {
+        const value = loc.textContent?.trim();
+        if (!value) {
+          continue;
+        }
+        if (/\.xml(?:\.gz)?(?:$|\?)/i.test(value)) {
+          try {
+            const nested = new URL(value, sitemapUrl);
+            if (nested.origin === origin && !visitedSitemaps.has(nested.toString())) {
+              sitemapQueue.push(nested.toString());
+            }
+          } catch {
+          }
+        } else if (add(value)) {
+          sitemapCount += 1;
+        }
+        if (out.length >= 500) {
+          break;
+        }
+      }
+    } catch {
+    }
+  }
+  return {
+    urls: out,
+    sitemapCount
+  };
+}
+__name(collectSameOriginLinks, "collectSameOriginLinks");
+export {
+  buildBatchFileName,
+  buildQuickFileName,
+  createLicensing,
+  fileStamp,
+  folderNameFor,
+  hostOf,
+  initExtension,
+  initPopup,
+  normalizeUrls,
+  sanitize,
+  sessionStamp,
+  todayString,
+  urlBaseName
+};